You launched on a Tuesday. By Friday, you have 12 signups. A good week. You open your user dashboard and see them. Twelve little green dots. In 2023, that dot meant a user was active. A simple boolean. In 2026, it means something else entirely. It’s a promise. A promise that an agent—an autonomous, AI-powered entity tied to their account—is awake, watching, and ready to act. And for an indie maker, that promise is a quiet, ticking time bomb.

This is the reality of the “dot always-on agent.” It’s not just a feature; it’s the default expectation, set by giants who can afford to burn mountains of cash on inference. For them, a user’s green dot is a gateway to more data, deeper integration, and total lock-in. For you, it’s a liability in waiting. Competing on their terms is a fool's errand. The game isn't to build a better, cheaper, always-on agent. It’s to change the game entirely.

The Real Problem Isn't Code, It's Expectation

The tech to build an agent is trivial now. A few API calls to Anthropic, a serverless function, a vector store. You can spin up a proof of concept in an afternoon. The tutorials are everywhere. That’s the trap. The hard part isn't making the agent work; it's making it work under the crushing weight of user expectations and operational cost.

Your user just left Google Docs, where an agent co-authored their text, scheduled a meeting based on its contents, and summarized the last three related documents without being asked. Now they’re in your app. They see that same green dot next to their avatar. They expect magic. What they don't see is the bill. Every "thought" your agent has, every token it processes, costs you. It's a direct, per-user, per-second COGS that doesn’t scale down gracefully.

Big Tech subsidizes this. Their agent's "work" is a loss-leader for their cloud services, their ad models, their hardware sales. You don't have that luxury. Your business model is the product itself. If your per-user agent cost exceeds your ARPU, you're dead. And with the unbounded, conversational nature of most always-on agents, predicting that cost is nearly impossible. You’re not selling software; you’re selling a volatile commodity you have no control over.

The real problem, then, is the expectation of a synchronous, conversational, omniscient assistant. It’s a paradigm designed by and for the incumbents. Fighting on that battlefield means signing up for a war of attrition you will lose.

How to Compete: Go Narrow, Go Asynchronous

You can't out-spend them. So you must out-think them. Abandon the paradigm of the "green dot" companion and embrace the power of the focused, background worker. Don't build a friend. Build a tool.

This Week: Build a *Scoped* Agent

Your goal is not to build a general-purpose agent. It is to automate a single, high-value, repetitive task. This week, pick one. Not ten. One.

• Does your app help manage projects? Build an agent that, once a day, scans all new comments and generates a one-paragraph summary of risks and blockers.

• Is it a CRM? Build an agent that listens for new leads and automatically drafts a personalized, one-sentence opening line for an email.

• Is it a social media tool? Build an agent that finds the single best comment on a user's post and suggests a reply.

The key is scope. The agent does one thing. It does it well. It does it in the background. This dramatically simplifies your prompt engineering, reduces the chance of catastrophic failure, and makes costs predictable. You are no longer building a chatbot; you are building a superpower for your user that runs on a schedule.

The implementation is straightforward. Use a queue-triggered serverless function. A user action or a cron job adds a message to the queue, the function wakes up, performs its single task, and goes back to sleep. You only pay for the brief execution time.

// A Cloudflare Worker triggered from a queue for an async agent
export default {
  async queue(batch, env) {
    for (const message of batch.messages) {
      // Message body contains the specific task context
      const { documentId, userId, task } = message.body;
      if (task !== 'SUMMARIZE_RISKS') continue;

      // 1. Fetch only the data you need
      const comments = await env.DB.getNewComments(documentId);
      if (comments.length === 0) continue;

      // 2. Call a model with a highly-scoped, engineered prompt
      const prompt = `Scan these comments and identify project risks. Output a bulleted list. Comments: ${JSON.stringify(comments)}`;
      const riskSummary = await env.AI.generate(prompt);

      // 3. Deliver the value async
      await env.NOTIFIER.send(userId, `Daily risk summary for your project is ready.`);
      await env.DB.saveSummary(documentId, riskSummary);
    }
  }
}

Embrace the "Yellow Dot"

The green dot means "I'm online and ready to chat." It creates an expectation of immediacy. This is the expensive promise. The "yellow dot" means "I'm idle, but I'm working." It implies asynchronous execution. This is your sustainable advantage.

Frame your agent's UX around this principle. Don't give it a chat window. Give it a dashboard of its recent "jobs." Show the user what it did last night. Let them configure its schedule. This turns the agent from a conversational liability into a reliable, fire-and-forget feature. The user doesn't wait for an answer; they receive a deliverable.

This asynchronous-first approach lets you use cheaper, slower models. It lets you batch-process jobs to reduce overhead. It lets you build a product that feels magical without bankrupting you on inference costs. You can find inspiration by looking at the best automation and productivity tools—they focus on workflows and results, not conversations.

What to Ignore

The signal-to-noise ratio in AI is worse than ever. As a solo founder, your most valuable resource is focus. Here's what to actively ignore.

Ignore Real-Time Chat

Unless your product is explicitly a chatbot, do not add a chat interface to your agent. It’s a black hole for engineering resources, a magnet for scope creep, and a direct line to unpredictable costs. Users will ask it anything and everything, judging its failures harshly and taking its successes for granted. A simple "Here's what I did for you today" notification is a thousand times more powerful and a million times cheaper.

Ignore the Multi-Agent "Swarm" Hype

You will see demos of "research agents" that spawn "planner agents" that delegate to "writer agents." This is fascinating R&D, and it's also the fastest way for an indie to burn through their entire year's budget in an afternoon. Stick to a single agent for a single task. Simplicity is your shield.

Ignore the Platform Play

Don't build "Stripe for Agents" or "Heroku for Agents." The foundational model providers are already building these platforms, and they're giving them away to lock you into their ecosystem. Your job isn't to build infrastructure for other developers; it's to solve a painful problem for a specific customer. Build the boring, single-purpose agent that saves a marketing manager ten hours a week. That's a business. An agent platform is a VC pitch deck.

The Catch: Your Agent is a New Kind of Tech Debt

Even with a scoped, asynchronous approach, these agents introduce a new and insidious form of technical debt. This isn’t about messy code; it’s about managing a component that is non-deterministic, opaque, and owned by someone else.

The Cost of Being Wrong

When your agent fails, it doesn't throw a 500 error. It produces a subtly incorrect summary. It drafts a slightly off-key email. It hallucinates a fact. These aren't bugs you can catch with unit tests. They are silent trust-killers. Budget time and resources for robust logging of inputs and outputs, and for building user-facing controls to flag bad results. Your agent's "undo" button is more important than its "go" button.

Prompt Drift as Dependency Hell

Your meticulously crafted prompt is a fragile contract with a model you don't control. When OpenAI or Google ships `gpt-5.5-turbo-2027` and depreciates the model you built on, your agent's behavior will change. The tone might shift. The formatting might break. You are dependent on the model provider's release cycle, and "prompt rot" is now a permanent part of your maintenance burden. You must version your prompts like code and regularly re-evaluate them against new model versions.

You Are a Data Custodian

The moment your agent processes user data—even if it's just for a second in a serverless function before being passed to a third-party API—you become responsible for it. The attack surface for your product just grew by an order of magnitude. An always-on agent has access to a constant stream of user information, making it a prime target. Don't get lazy here. Enforce strict data handling policies, be transparent with users, and look into privacy-preserving tools that can help you minimize your liability. Your privacy policy is now one of your most important product documents.

The age of always-on agents is here, but it doesn't have to be your doom. It can be your unfair advantage, if you refuse to play by Big Tech's rules. The green dot is a trap. It promises a synchronous, conversational future that only they can afford to build.

Your path is different. Build the quiet, asynchronous worker. The "yellow dot" agent that delivers focused value in the background. Solve a single, painful problem and automate it away. Make your agent a tool, not a teammate. Build something small, scoped, and relentlessly useful.

Then, when it's ready, ship it. Put it on a directory like Builtbyindies. Get those first 12 users. And when you see their icons in your dashboard, don't see them as a promise you have to keep. See them as proof that you solved a real problem. That’s a foundation you can build on.