How to Build an AI Agent That Makes Money

Why most agent products never clear their inference bill

A monthly revenue target sounds like a sales problem. It is usually a cost problem.

Selling software has near-zero marginal cost, so the tenth customer is nearly pure margin. An agent product does not work that way. Every task consumes tokens, and every unhappy path consumes more: the retry after a failed tool call, the second attempt with more context attached, the long transcript dragged along on every turn of a stuck loop. That is real cost of goods sold, and it scales with usage rather than shrinking.

Builders miss this because they estimate from a clean demo. One well-formed request, one good answer, a small number. Then production arrives: ambiguous inputs, missing files, an API returning something unexpected, and the agent burning several passes to recover. The task that looked cheap in testing runs three times over and costs several times more.

So before you build, write down two numbers. What a customer pays per task, and what a task costs you when it goes badly. The gap between them is your business. If you do not know the second number, you do not have a price, you have a hope.

The unit economics you actually need to model

Keep the model simple enough to hold in your head. Revenue per customer per month, tasks run per customer per month, and cost per task including failures. Multiply the last two, subtract from the first, and you have contribution margin per customer. Everything else is detail.

The number that surprises people is tasks per customer. Builders assume a customer will run the agent a handful of times. Customers who find it useful run it constantly, and the ones who love your product hardest are the ones who destroy your margin fastest. A flat monthly price with unlimited usage means your best customer is your worst account.

That is why the loser case matters more than the average. Price against what a heavy user costs you in a bad month. If the product still clears margin there, growth is safe. If it only works when usage is light, you have built something that punishes you for succeeding.

Pick a niche where the same work repeats

The strongest agent businesses are narrow and repetitive. Not because narrow is easier to build, but because repetition is what lets cost fall as you grow.

When customers in one niche ask overlapping questions, the answer you produced once can serve the next request instead of being regenerated from scratch. Compliance checks against the same regulation, onboarding against the same platform, migration between the same two systems, reporting against the same data model: in each case, the tenth customer is asking a version of something you have already answered well.

A general-purpose assistant has none of that overlap. Every request is novel, so every request costs full price, forever. That is the quiet reason horizontal agent products struggle while boring vertical ones work. The vertical one gets cheaper to serve each month. The horizontal one does not.

When you evaluate an idea, ask how much of the work repeats across customers. High repetition means your cost curve bends down over time. Low repetition means you are renting an LLM and reselling it at a markup, which is a race you will not win.

Cut cost per task instead of raising the price

Once you know your cost per task, there are two ways to widen margin. Charge more, which the market limits, or spend less per task, which is under your control.

Most of what an agent regenerates is not novel. It re-derives the same domain rules, the same procedures, the same explanations, every session, at full price. Retrieval fixes that directly: index the knowledge your product depends on, and have the agent search it before it queries the model. The answer is retrieved rather than regenerated.

RDK indexes your files as encrypted private chunks on the RDK network, so your customer data and your procedures stay yours while remaining searchable by your agent. With stacked retrieval, a private index answers 40 to 65 percent of queries, the public network adds another 15 to 20 percent, and the LLM handles the remaining 5 to 10 percent as fallback. Token spend drops 80 to 90 percent.

Run that through the model above. A task costing a dollar to serve now costs closer to fifteen cents, and the customer notices nothing except that answers are more consistent. That is the difference between a product that dies at scale and one that gets more profitable as it grows.

There is a second revenue line worth knowing about. Chunks you publish publicly earn USDC per retrieval when other agents pull them, so the reference material you had to write anyway can pay for itself instead of sitting idle in a docs folder.

A build order for the first paying customer

Start with one customer and one task they already pay a human to do. Not a platform, not a suite. One task, one buyer, one measurable outcome.

Run it manually with Claude Code first, in your own session, for a real customer's real work. You will learn the actual failure modes and the actual cost per task in a week, and both numbers will be worse than you guessed. That is the point of doing it before you build any product surface.

Then write down everything you learned: the domain rules, the edge cases, the checks that catch bad output. Index it. Now the agent starts each run with your accumulated knowledge instead of rediscovering it, which is the same lever that fixes both cost and quality.

Only then automate the surface: an interface, a queue, billing. Price on the outcome, priced against your bad month, and add the second customer only once the first one is profitable on paper. Ten customers who all fit one repeated workflow will get you further than fifty who each need something bespoke.