A company run by an agent, talking to a company run by another agent, settling on a price neither of their founders are in the room for. The first generation of transactions without humans in them. Some of it is already happening; most of it is closer than people think.
Sometime in the next few years, a real US company will sign a real contract with another real US company, and no one on either side will read it before it's signed.
It will be small at first. A monthly retainer between two single-person businesses, paid weekly. A SaaS upgrade negotiated down four cents per call because the volume warranted it. A treasury sweep into a money-market fund whose terms were checked against a counterparty risk policy a human wrote eight months ago and forgot. The first agent-to-agent transactions won't look futuristic. They'll look like the ones already happening — only the people approving them won't be people.
What's changed is not that machines can talk to each other. They've done that for decades. What's changed is that machines can now form intent, hold a position, and concede on it. They can argue. They can read a contract and notice the part that doesn't match what their company actually wants. They can ask a clarifying question and not pick up the phone afterward, because there isn't one.
We're at the moment where this stops being a research demo and starts being a normal way a company gets things done.
For most of history, a transaction needed two humans in agreement. Soon, most of them won't.
"A company run by an agent" sounds like one thing. It really isn't. There's a small ladder hidden inside it — each rung a step further from the founder being in the loop, and a step closer to the company acting on its own behalf.
| № | The rung | What changes |
|---|---|---|
| 01 | Agent-assisted | A founder asks an agent to draft, summarize, or schedule. Every consequential action still passes through a human pair of hands. Most companies today. |
| 02 | Agent-operated | An agent runs a defined process — collections, vendor renewals, payroll, support — within explicit limits the founder set. The founder reviews; the agent executes. |
| 03 | Agent-managed | The agent holds the company's calendar, books, contracts, and money. A human sets policy and signs off on exceptions. Day-to-day, the agent is the operator. |
| 04 | Agent-led | The agent makes the routine economic decisions — what to price, who to hire, when to refund — against goals a human gave it. The board still meets; the company is mostly running itself between meetings. |
| 05 | Agent-built | The product itself is an agent, the operations are an agent, the support is an agent, and a small group of people set direction. The smallest viable team becomes one human and a stack of authorities. |
| 06 | Agent-counterparty | Other companies' agents don't need a person to talk to. The company can be negotiated with, paid by, and onboarded by software — because it can act on its own behalf, under its own seal. |
Most of the interesting things happen between rungs 04 and 06. That's where a company stops being a wrapper around a team and starts being a real legal person you can do business with through an API. Not a chatbot in front of a real company — the company itself, signing things.
For most of the last two years, the interesting question has been: can an agent be a buyer? Can it search, compare, negotiate, and pay on a person's behalf. That's the right question for consumer software. It is not the more interesting one.
The more interesting one is: can an agent be a seller? Can a company built mostly out of software answer the door when another company's agent comes knocking — quote a price, hold a margin, sign a contract under a real corporate seal, and stand behind what it sold. That requires more than language. It requires the company underneath to be a thing software can act through.
Once both sides are agents, a lot of the apparatus we built around making humans transact with humans starts to look strange. The sales call. The pricing page that hides the number. The contract you sign as a PDF in an email. None of these were the point. The point was: two companies agreed to a thing and bound themselves to it. There are faster ways to do that, if both sides are reading.
The first thing that gets compressed is the negotiation. Two agents can exchange a hundred turns in the time a human takes to draft one email. They don't get tired, don't get stuck on ego, don't forget the floor their CFO set. What was a four-week procurement cycle collapses into a two-minute conversation — with a transcript both companies' books can point to.
Pricing stops being a published number. It becomes a position, held by an agent, against constraints written by a human. Volume, term, payment schedule, exclusivity, support level — each one becomes a lever the agent can pull, against a margin floor and a strategic policy it isn't allowed to cross. The price you and I get isn't the same. Neither of us was supposed to get the same one. We just couldn't afford to negotiate before.
The other side of this is funding. The first agent-led fund is closer than people are willing to say out loud. An LP gives capital and a thesis. A fund agent screens, models, diligences, and writes checks. It can talk to a thousand founders in a week and remember every conversation. Some of those founders are people. Some of those founders are agents, pitching companies built mostly by other agents.
What an investor agent actually wants from a company will look familiar — cap table, revenue, contracts, risk — but it'll want the answers structured, signed, and current. The data room becomes an endpoint. A SAFE is a small file the company's own agent can read, redline, and counter-sign under a policy the founder set last week.
Procurement is the other obvious place. A treasury agent sweeps cash into a higher-yield product because the spread crossed a threshold. A compute agent moves training jobs between three providers because one of them dropped its overnight price. None of these were big enough decisions to bother a human about. All of them are big enough, in aggregate, to matter to the year.
None of this is interesting if the receipts aren't real. A handshake between two agents has to land somewhere the law already understands. A contract has to bind a legal person. A payment has to clear under the name of an entity in good standing. A signature has to come from someone the bylaws actually authorize. This is where most of the agent-commerce demos quietly fall apart. They show the negotiation; they don't show what happens next.
A company's agent isn't a chat window. It's a set of authorities. Signing this kind of document up to this dollar amount. Wiring up to this much without a human. Onboarding a vendor whose terms match this template. Authorities live inside the entity's governance, written down as policy the company itself can produce on demand. Outside that envelope, the agent stops and asks.
When my agent talks to yours, it should be able to ask: who are you, who authorized you, what can you commit to, and how do I know. The answer ought to come back as something verifiable — the entity's identifier, its registered agent, the policy that gives this agent the authority to sign, the limits on it. Not a screenshot of a corporate page. The page itself, signed.
Every meaningful exchange between two agents — the quote, the counter, the accept, the wire — ends up in both companies' books. Same hashes, same timestamps, the same audit trail visible to both sides. Disputes get cheaper because there's almost nothing to argue about. The company is born with its own history, and the history accumulates without anyone copying anything by hand.
A handshake between two agents only counts if the company underneath each one is a real, signing, accountable thing.
We don't think any of this is far away. Most of the missing pieces are mechanical. A company has to be formed quickly and cleanly enough that an agent can stand one up. Its governance has to be programmable enough that the policy an agent operates under is the same policy the company is bound by. Its history has to be signed by default. Its counterparties have to be able to ask it questions and get answers that mean something.
That's the layer we're building. An entity that knows what it is, what it has agreed to, and who is allowed to speak for it. The conversational surface comes from the model. The trust comes from the substrate underneath — the formation, the cap table, the signing authority, the registered agent, the books. If those are right, the agent on top can do useful, accountable things. If they're not, the agent is a costume, and the other side will eventually figure that out.
We're not predicting a world without people. Direction, taste, judgment, accountability — those stay human. What changes is the middle layer — the calls, the email threads, the back-and-forth on terms, the wire approvals that take three days because someone is on vacation. That work falls to software, and the companies that can act through software well will move at a different speed than the ones that can't.
If your company can be talked to, paid, hired, and bound — through an agent that knows what it's allowed to do — you've already crossed the line. The first generation of companies set up this way will be in business with each other long before most of us notice.