Agent Is Only Half of a Pair

A chart from a16z puts an agent at $80 an hour — roughly what an engineer costs, one choice away. But there are two other numbers on the same chart that nobody quotes: managed well, four dollars; managed badly, seven thousand. The four-dollar number requires a human to accept the work. The metric was built by dividing by you.

a16z put out a chart this month, from Hebbia’s George Sivulka, with a line I haven’t been able to shake: for the median firm, an agent costs about $80 an hour, which they point out is roughly what a software engineer costs.

It’s a clean sentence. Two numbers, one axis, and a decision sitting underneath it — you’re paying for one of these, so choose. I spent a while trying to work out why it bothered me, and most of that time was wasted on the obvious answer, which is that the number is probably wrong. The number isn’t the problem. The comparison is.

The pitch underneath the chart is scale. The essay it comes from is built around the idea that 100X tokens are the new 10X engineers: infinite volume at almost no marginal cost, the work that used to take a professional a week finished before you’re through your coffee.

Real estate already ran that experiment.

Twenty years ago, finding a house meant a realtor, an MLS login you didn’t have, and a stack of printouts. Then Zillow showed up, and every listing in the country became available to every buyer, instantly, for nothing. That’s the 100x. Not an analogy for it — the actual thing, shipped, two decades ago, in a market where the agent has a title and a license and a commission.

So did buying a house get a hundred times faster? Did the realtors go away?

You know how it went. You still walked the properties, because you’re the one who has to live in there. You still read the inspection and decided whether the roof was a dealbreaker or a discount. You still qualified for the mortgage, and the bank did not care how many listings you’d seen. Zillow scaled. You didn’t. It automated the half that was already easy, and the half that was hard sat exactly where it had always been.

And look at what Zillow actually became. It gave away infinite listings — and built its business selling you back to a realtor. The machine that was going to make the agent unnecessary makes its money routing you to one.

The listings were never the job. The filter was. And after the filter, somebody still has to go and look.

Which should have been obvious from the start: nobody has ever hired an agent for scale. You don’t hire a realtor to go faster — you hire one because they know which streets flood and you don’t. You don’t hire a literary agent to increase your output; you hire one because they can get an editor on the phone and you can’t. Speed and volume were never the pitch, because speed and volume were never the problem.

What you’re actually buying is two things. The first is that they know things you don’t and do work you’d rather not do — the boring half, which is most of the day. The second is that they’re on the hook. Their name is on the contract, they carry a license, and when it goes wrong there is a person who owns it.

AI gives you a good version of the first. It gives you none of the second.

Go find the paperwork from when you bought your house. There are two sides to it. One side is the agent. The other side is you, and you have a title too — you’re the principal. Agent is half of a pair, the way tenant is half of a pair; the word doesn’t mean anything unless somebody is standing on the other side of it. So when a vendor says autonomous agent, the question worth asking isn’t whether it runs by itself. It’s who the principal is. The answer is never nobody.

There’s a second thing on that paperwork. Your realtor doesn’t bill you for showings. They get paid when the house closes and not a dollar before, which is why they don’t want to walk you through forty houses. They want you to buy one. (Contingency recruiters are the purest version: paid when the person starts, money back if the hire quits inside ninety days.) Now think about how you pay for an AI agent. Per token. Per showing. Nobody has ever built an agent that gets paid on close, so of course they loop. You hired someone hourly and then asked them to tell you how many hours the job takes.

Which is where I should be careful, because taken flat that’s too strong.

Software runs unattended all the time. An execution algorithm works a million orders in a day and no human looks at a single one of them. Anyone who has worked near a trading desk has watched it happen for years.

But nobody on that desk calls the algo the agent. The agent is the broker — and in that market it isn’t loose talk, it’s the distinction the whole business runs on: you execute as agent, for the client, or as principal, on your own book. Same two words as the ones on your closing paperwork. The algo is a tool the agent uses to do the job. A million orders, not a human in any of them, and the agency relationship sits exactly where it always sat: a client with a mandate, a broker carrying a best-execution obligation, and a name on the ticket when the fill is wrong.

Autonomy went all the way down to the transaction and didn’t move the agency an inch. The software got autonomous. The agent didn’t go anywhere.

Now run it the other way. Tell your realtor to buy any house that clears three bedrooms, good schools, no flood zone, up to $300 a square foot — and to go ahead without calling you. You haven’t created an autonomous agent. You’ve written an algorithm and hired someone expensive to run it. Nobody does this, and not because it’s forbidden. The specification is the part you couldn’t write. It’s why you called them.

There’s only one dial. Every notch of autonomy is bought by taking discretion out, and discretion was the product. An autonomous agent isn’t a better agent — it’s an algorithm wearing a better word.

So the claim isn’t that agents can’t run without you. Software can, and does, and has for decades. It’s that the thing running without you was never the agent — and the plan that cuts headcount is written as though it were.

Which brings me back to the chart, and the part of it nobody quotes.

There are two other numbers on it. Managed well, an agent costs four dollars an hour. Managed badly, seven thousand. Same work, same models, a 1,750x spread. And the footnote explains where the expensive end comes from: runaway sessions, scaling with unattended autonomy. Their chart, not mine. The thing being sold is autonomy, and the price of autonomy is printed in the footnote at seven thousand dollars an hour.

The cheap number has a footnote too. Cost per shipped hour, they explain, is the total spent on the agent divided by the hours of work that got accepted. Accepted by a person. Somebody read it and said yes. So the four-dollar number requires a human, and the seven-thousand-dollar number is what happens when you don’t have one. That isn’t a range of outcomes. It’s a before-and-after picture of removing the person, printed on the chart that’s being used to remove them.

I wrote a while back about the one-sided ledger — how usage-based billing made AI’s cost perfectly legible and its value invisible, and how the half you can see is the half that ends up driving the decision. This is the same trick run backwards. The agent’s cost is on the chart. Your review time isn’t on the chart. Nobody hid it. The metric was built by dividing by you.

The best argument against everything I’ve just said concedes all of it. It goes: fine, an agent needs a checker — but checking is cheaper than making. One engineer with a review queue ships what used to take five, and you’d pay a small premium per unit for that every day of the week. That’s true. It’s the real case for agents, and it’s why I buy them.

Read it again, though. The case for agents is built on a human who never leaves. The strongest bull argument on the market is that you are permanent. Even the people selling you the future are quietly pricing you into it.

Which is where this gets expensive, and it isn’t the spend.

Your company is going to buy the automation story and receive an assistant. That part is survivable; assistants are good, and I’d rather have one than not. What isn’t survivable is the plan that got written on the way there. The plan says headcount comes down and the work goes away. What actually happens is that the work changes shape — you stop making things and start approving things, your visible output drops, your accountability climbs, and the volume you’re on the hook for grows, because the machine produces faster than you can read. Then someone runs the math and cuts the reviewers to fund the number.

And the number was only ever true because of the reviewers. The savings came from removing the people, and the savings only existed because of the people. The moment you capture them, they’re gone. The plan works right up until it works.

Somebody will tell you evals solve this — write down what good looks like, up front, and let the machine grade itself against it. Sivulka argues exactly that: evals are how you get leverage out of a workforce that scales infinitely. This is the dial again. An eval is a specification, and a fully specified agent is an algorithm. He isn’t wrong about where that works. Code ships with its own evals; it runs or it doesn’t, which is why coding is the one place any of this is clearly paying.

But go back to Zillow, which has had this feature the whole time. It’s called a saved search. Three bedrooms, good schools, under budget, no flood zone — write the list, and the machine grades every house in the county against it while you sleep. Now go buy a house off that list without seeing one.

You can’t, and you know exactly why. Your list changes after the third showing. You didn’t know you cared about morning light. You didn’t know the quiet street backed onto a fire station. The showings aren’t how you check your criteria against houses — the showings are how you find out what your criteria are. If you could write the list in advance, you wouldn’t need to go. The reason you go is that you can’t.

Evals don’t take you out of the loop. They move you to the front of it and call that leverage.

I wrote in June that the artifact was never the job — that making the thing and exercising the judgment behind it used to be one act, and that when a model can produce the artifact, what’s left is to name the quality you own and hold it at the seam, because the seam is where accountability lives.

This is what happens next. Someone prices the seam at zero.

Software runs unattended. It still isn’t the agent. An agent acts for somebody — that’s the entire content of the word, as true of the ones carrying a license and a fiduciary duty and a few hundred years of law as it is of the one running in your terminal right now. It isn’t a limitation waiting on the next model. It’s the definition, and it’s the only part of any of this that isn’t going to change.

So buy the agents. The maker-checker math is real. Just don’t sign the plan that assumes they run without you, and then removes the “without you” to pay for it.

You’re not the bottleneck. You’re the reason the four-dollar number is four dollars.