What actually empowers an entrepreneur in the age of AI

The answer, and the number behind it

LangGraph halts a graph after 25 supersteps by default and raises a recursion-limit error rather than let it run forever (LangGraph docs). That default exists because the most expensive thing an autonomous agent does is loop in a way nobody bounded.

An entrepreneur is empowered by exactly one thing: owning a narrow, metered, revenue-bearing loop that an agent can run end to end and a human can halt. Not by access to a model. That costs $0.15 per million input tokens and everybody has it (OpenAI pricing).

Access is not an advantage. Nobody is gated out of intelligence anymore. What separates one founder from the next is whether they have a loop that produces money, instruments it, and caps it.

What actually got cheap, priced

I took Metadata.io from $0 to $15M ARR and raised $50M to do it. A meaningful share of that money went into work that is now a prompt and a cron job. Cost shift, not magic.

What did not get cheap

In early 2025, METR ran a randomised controlled trial with 16 experienced open-source developers across 246 real tasks on repositories they already maintained. With AI tools allowed, they took 19% longer. They had forecast a 24% speedup beforehand, and still believed they had been sped up by 20% afterwards (METR).

Read that gap twice. The measurement and the feeling pointed in opposite directions, on work the participants were expert at.

Generation got cheap. Verification did not. Distribution did not. Trust did not. Support obligations did not. If your plan is "AI makes us 10x faster," you have a feeling, not a number — and the one controlled study on experienced practitioners went the other way.

So pick work where verification is cheap or automatic. A lead-qualification agent whose output is checked by whether the meeting happened is a good candidate. A code-generation agent writing into a 400,000-line repo nobody can review is not.

The control layer is what you actually build

The model is rented. The framework is interchangeable. What is yours is the layer that decides which proposed action is allowed to execute, how many times, and against what budget. The long version is in agent orchestration is a control layer, not a framework.

Both major agent runtimes ship a step cap because they have to. The OpenAI Agents SDK takes a max_turns argument on every run and raises MaxTurnsExceeded when it is exceeded (docs). LangGraph defaults to 25 (docs). Neither cap is enforced by the model. They are enforced by code outside the model, which is the only place a cap works — a model that is already looping cannot be asked to notice it is looping.

Three details in that diagram are the whole job. The caps sit outside the model. The spend is logged per run, not per month. The halt path goes to a human, not to a retry.

If you are starting, start with one of those loops and nothing else. Get into the AI business by shipping one capped agent is the narrow version of this argument; how to start a business with AI agents in one file is the smallest implementation of it.

What a run costs, with your own numbers

Take a research-and-draft agent: roughly 12 model turns per task, context averaging 8,000 input tokens a turn because it accumulates as the run proceeds, 600 output tokens a turn, 2,000 tasks a month. That is 96,000 input tokens and 7,200 output tokens per task — 192M input and 14.4M output tokens monthly. At the published gpt-4o-mini rate of $0.15 and $0.60 per million (OpenAI), that is $28.80 plus $8.64. Under forty dollars.

Move the model picker to a frontier tier and the same workload jumps by more than an order of magnitude. That is the real decision in agent economics: which turns in the loop deserve an expensive model. Most do not. Routing, extraction and classification belong on the cheap tier. The one turn that writes the thing a customer reads can be expensive.

Two levers from the pricing table apply to that same workload without changing a line of prompt. If the research turns do not need to answer within a second, routing them through the Batch API halves their token cost against a 24-hour completion window (OpenAI). If the system prompt and any fixed corpus are stable across runs, prompt caching moves the repeated portion of those 8,000 input tokens onto cache reads, which bill at a fraction of the base input rate (Anthropic). Neither lever matters much at forty dollars a month. Both matter at the volume where a working loop is actually earning, which is exactly the point at which nobody wants to stop and refactor.

Note what the calculator does not show. The forty dollars is not your cost. Your cost is the human who reviews the fraction of outputs that are wrong, plus the customer you lose when a wrong one ships. Price that before you price tokens.

What I would not use

I would not give an agent spend authority. Not a card, not a budget it can draw against, not the ability to buy credits. Stripe publishes an agent toolkit that exposes payment primitives as tools (GitHub), and it is well built — I still would not wire the outbound direction of it to an unsupervised loop in year one. Approval gates on money are cheap. Unwinding charges is not.

I would not put computer-use agents on a revenue-bearing step. Anthropic shipped computer use as a public beta and described it in the announcement as experimental and error-prone at tasks people find trivial (Anthropic). The vendor is telling you. Believe the vendor. Where an API exists, use the API; a screenshot-and-click loop is a last resort for systems with no interface, and it should be staffed accordingly. I unpacked the terminology confusion in what a computer agent is, and the three things people mean by it.

I would not build an agent framework. Every founder who writes their own orchestration library ends up maintaining a worse version of something with a changelog. Pick a runtime with a documented step cap and move on.

I would not run an agent in front of customers before it has run in shadow. Same inputs, real outputs, no delivery, a human reading the log. Run it long enough to see the tail, because a week of real traffic surfaces the malformed, hostile and empty inputs that no hand-built test set contains. The cost of shadow mode is tokens. The cost of skipping it is the relationship.

The protocol bet worth making

Anthropic open-sourced the Model Context Protocol in November 2024 as a standard way to connect models to tools and data sources (Anthropic), with a public spec and SDKs (modelcontextprotocol.io). It has since been adopted far outside Anthropic.

The reason to care is not elegance. It is replaceability. If your CRM, your warehouse and your email sender are exposed as MCP servers, swapping the model underneath costs a config change instead of a rewrite. Glue each tool directly into one vendor's function-calling format and you have married the vendor. Model prices and capabilities move monthly. Your integration layer should not have to.

That is the only standards bet I would make right now. Everything else in the agent stack is still moving.

Where the money actually leaks

None of these are exotic. They are the standard list, and they are why the control layer is the product. Building a SaaS with AI is two builds, not one makes the same point from the other direction: the feature is one build, the harness around it is the other, and the second is the one founders skip.

What is actually yours

Strip out everything rented and look at what remains. Not the model — that is a line item with published pricing. Not the framework. Not the agent, which someone can clone from a blog post by Friday.

What remains is the loop you chose, the data it has produced, the evals that prove it works, and the customers who send it work. Six patents and two companies later, that is the part I would protect. The model you are using this quarter will be obsolete next quarter, and the switching cost should be an afternoon. The loop, the log and the distribution are what compound.