Entrepreneurship in the age of AI: what actually changed

Cache reads cost 0.1×. Batch costs 50%.

Anthropic bills prompt-cache reads at 0.1× the base input token price and cache writes at 1.25× (Anthropic docs). OpenAI's Batch API takes 50% off both input and output tokens for work that can wait up to 24 hours (OpenAI docs).

Those two lines are the shape of the whole business. Entrepreneurship in the age of AI is buying inference at wholesale, wrapping it in a control plane you own — caps, verification, state, metering — and selling a metered outcome. The model is a commodity input. Your margin, your defensibility and every one of your outages live in the layer around it.

I took Metadata.io from $0 to $15M ARR and raised $50M on the previous version of this bet — that software could make marketing decisions a human was making by hand. Six patents came out of it. What is different now is not that the models are smarter. It is that the cost of producing software fell faster than the cost of distributing it, and most founders are still optimising the half that already got cheap.

Cost of production fell. Cost of distribution did not.

A working prototype of a narrow workflow is now a weekend. Nobody's cost of acquiring a customer went down by the same factor.

That gap produces one predictable failure. Teams ship five products instead of one, because shipping is cheap, and then discover they have five products with no distribution instead of one product with no distribution. The constraint moved. It did not disappear.

Wrapper businesses with no proprietary loop get compressed from both ends: the model vendor ships your feature, and a competitor ships your UI over a weekend. What survives is a loop you own — proprietary data that accumulates from usage, an eval set nobody else has, a workflow with switching cost, or a distribution channel you did not rent. The artefact that wins is not "an AI product" at all. It is an ordinary product whose cost of goods sold happens to be inference. Read what AI SaaS actually means before you decide which one you are building — people mix the two senses constantly and price accordingly badly.

Your COGS is a number you can read every day

This is the real change to company-building, and it is unglamorous. In classic SaaS, marginal cost per customer rounded to zero and gross margin was a fact of the category. With agents, marginal cost per run is a variable you control with engineering decisions, and it shows up on a bill 30 days later.

Take a support-triage agent. 25 model calls per run. Roughly 12,000 input tokens per call once you count tool schemas, retrieved documents and the transcript it re-sends every turn. About 900 output tokens per call. 20,000 runs a month.

That is 300,000 input tokens and 22,500 output tokens per run — arithmetic, not a benchmark. The asymmetry is what matters. At frontier list prices, output costs several times input per million tokens (OpenAI pricing, Anthropic pricing), and yet a chatty agent that re-sends a growing context still spends most of its money on input. Which is exactly the money prompt caching takes back at 0.1×.

Three moves change that number by more than any prompt engineering will:

And one accounting move: meter the unit your customer recognises. Stripe's usage-based billing exposes meters and per-unit pricing directly (docs), so "per resolved ticket" or "per enriched record" is a billing primitive, not a spreadsheet. If your price is a flat seat fee and your cost is per token, you have written yourself a contract to lose money on your best customers.

The control plane is the product

The model does not enforce your budget. It cannot. Every limit that matters is code sitting outside the model call, and that code is most of what you actually own.

Note the dashed line. A retry passes back through the gate and decrements the same counters. An agent that gets a free retry has no cap at all.

Every serious framework now ships this as a primitive rather than advice. LangGraph has a recursion limit and checkpointed state (repo). The OpenAI Agents SDK exposes run-loop limits and guardrails (repo). Temporal handles durable execution and retry policy outside the model entirely (docs). A proxy like LiteLLM will enforce per-key budgets before a request ever reaches a vendor (repo).

On the money side, treat spend authority as a separate grant from tool access. Stripe Issuing supports per-card spending limits and merchant-category restrictions (docs) — which is the difference between an agent that can buy and an agent that can buy $40,000 of ads.

Tool access itself has consolidated on the Model Context Protocol (modelcontextprotocol.io). Good news for integration cost, neutral news for safety: MCP standardises how a tool is exposed, not whether the agent should have used it. If you want the concrete build, I wrote the first-agent version with hard caps here.

Failure modes that are already documented

None of these are speculative. They are the recurring set, and the fix is always outside the model.

The pattern across the table: the model is stateless, non-deterministic and happy to be wrong confidently. Every one of these fixes is ordinary distributed-systems hygiene applied to a component that lies. That is the actual job.

What I would not build

I would not build a multi-agent swarm as a first architecture. Not because it cannot work, but because you get compounding non-determinism before you have any way to measure it — n agents, n context windows, n places for an unverified claim to enter the chain, and a debugging surface where you cannot tell which hop invented the number. One agent, one loop, hard caps, a verifier you wrote. Add the second agent when the first has a failure you can point at.

Two more positions, plainly.

I would not delegate spend authority to an agent yet, beyond a per-transaction ceiling I would be willing to lose in full. Not because the models are careless, but because prompt injection is a documented, ranked, unsolved category (OWASP LLM01) and money is the one side effect you cannot roll back with an idempotency key.

I would not ship on a public benchmark score. SWE-bench Verified is 500 tasks a human annotator confirmed were solvable and correctly specified (OpenAI) — genuinely careful work, and still not a measurement of your workflow on your data. Fifty of your own examples with expected outputs beats any leaderboard for the decision you are actually making.

The founder's job changed shape

I am building a zero-human company in public: agents doing the work, me paying the bills for them, including on side projects. I wrote up the first two years of that here. The founder's job moved from doing the work and hiring people to do the work to specifying the work precisely enough that a non-human can be held to it.

That is a narrower skill than management and a broader one than prompting. It looks like: writing the acceptance test before the task, defining the unit you will meter, deciding what the agent may touch, and reading the ledger. At Silver Spotfire I took a product from $50K to $1.5M ARR the old way — headcount for every increment of output. The interesting question now is which increments still need one.

An agent has no accountability, no relationships and no judgement about whether the goal was correct. Anything that requires a person to own the outcome in front of a customer still requires a person. Everything with a checkable output is a candidate.

If you are choosing between hosted and self-hosted for that stack, the trade-offs are specific rather than ideological — I laid them out in self-hosted AI agent platforms.

Compliance became a product requirement, on a published schedule

Regulation (EU) 2024/1689 — the AI Act — entered into force on 1 August 2024, with prohibited-practice provisions applying from 2 February 2025, general-purpose AI model obligations from 2 August 2025, and the bulk of the remaining obligations from 2 August 2026 (EUR-Lex, European Commission). Those are dates in a published law, not forecasts.

For a small company selling to larger ones, the diligence questionnaire arrives before the regulator does. Buyers ask what data leaves their tenant, which subprocessors see it, whether outputs are logged, and whether you can map your practices onto the NIST AI Risk Management Framework (NIST). Answering that costs a week if you built the ledger from day one and a quarter if you did not, because retrofitting audit trails onto an agent that already ran 40,000 times means reconstructing what it did from vendor logs.

The cheap version: log every model call with its inputs, its tool invocations, the verifier's verdict and the cost, keyed to the run. That log is your incident response, your eval corpus and your compliance evidence at once.

The model you launch on will be retired

OpenAI maintains a public deprecations page with shutdown dates and recommended replacements (docs). Anthropic ships model generations with new names and new price points (pricing). Claude Code, Agents SDK, MCP — all of it moves on a changelog cadence measured in weeks (Claude Code docs).

So the asset is not the prompt and it is not the model choice. It is the harness: a versioned set of your own cases with expected outputs, cheap enough to run on every model change, that tells you within an hour whether the new model made your product better or quietly worse. Build it late and you find out about regressions from customers.

That harness is also the thing that lets you take the price cut. When a cheaper tier lands, the founder with 200 graded examples migrates in a day and books the margin. The one without them stays on the expensive model because switching feels risky — which it is, for exactly as long as they have no way to check.

If you want the smallest possible first version of all of this, it is one endpoint with a cap and a meter on it: start there.