How Companies Will Be Run by AI Agents

For most of the last two years, AI inside a company has meant a chat window. Someone asks it a question, it answers, and a person takes that answer and does the work. Useful, but the company still runs the way it always did. People do the work. Software helps.

That is over. The current generation of AI does not answer questions about the work. It does the work. Give it access to your systems and a clear description of the job and it will write the code, produce the content, run the analysis, handle the request, and report back. Software that does work on its own, inside your business, is what people mean when they say agent. And it is now good enough to be given real jobs, not demos.

This is the biggest change to how companies operate since the internet, and most companies are approaching it the wrong way. They are treating it as a software purchase: buy a tool, connect it, watch the productivity number go up. It does not work, and the reason it does not work is the subject of this piece.

Here is the shift in one line. Execution is becoming free. Direction is not.

The cost of producing work has collapsed. Code, copy, analysis, design, research, support. What used to take a trained person a week takes an afternoon, and it gets better every month whether you participate or not. But the ability to produce work was never what made a company a company. A company is the apparatus around the work: who does what, who is allowed to do what, how work gets to the right place, what it costs, and what happened. For people, that apparatus took a century to build and is so complete that nobody notices it. For agents, none of it exists.

The AI labs are building the workers. They are not building the company the workers work at. That part is on you, and it does not come from buying a tool.

The companies that figure this out will grow by adding agents instead of people, and they are going to pull away from everyone else. Not because agents are smarter than people. Because a company that can take on more work without taking on more headcount has a different cost structure, a different speed, and a different ceiling, and every improvement in the models widens the gap for free.

Getting there is not a project. It is a transition, and it happens in layers. Each layer produces something the next one needs. That is why you cannot skip them, and it is why most agent initiatives die: they start at the top of the stack with nothing underneath it.

Layer zero: the software

Every company starts here, and most think it is the whole thing.

You look at the stack of third-party software you pay for and realize you could own it. Agents can build it. It can be shaped exactly to how you work. Your data stops living in twelve vendors' databases. Things that took three tools and an automation chain become one screen.

Do this. It is a real prerequisite. Agents need a system they can reach into and act inside, and a pile of SaaS subscriptions with thin, rate-limited APIs is not that system. Owning the surface your work lives on is what makes everything after this possible.

But understand what you have done. You changed what the company runs on. You did not change how the company works. The people are doing the same work the same way, in better software. If you stop here and bolt a few agents onto the old workflows, you have an expensive demo, and the workflows were the problem.

Software is the floor. It is not the house.

Layer one: every human works through AI directly

This is where the transition actually begins, and it is not a technical decision. It is an organizational one, and only leadership can make it.

Every person in the company works through AI, directly, on the work they are responsible for. Not an AI team. Not an innovation lead. Not a pilot with three volunteers. Everyone, every day.

Partial adoption teaches the company nothing. What it produces is a shadow layer: a few people quietly using tools, no shared way of working, and leadership convinced they have visibility because they approved a license. The company learns to direct work only when all of it is being directed.

Three things happen at this layer that cannot happen any other way.

The company's real processes surface. Nobody knows how the work actually gets done until they have to explain it to something that will do exactly what it is told and nothing else. Every "you also have to check with her before that goes out" becomes visible, and once it is visible it can be written down.

The humans move to the part of the job that was always the valuable part. The person who used to produce the work becomes the person who directs and verifies it. Judgment, taste, context, the sense of what good looks like. That was never the production. It was buried under it.

And you find out where the company's judgment lives. Some of it lives in people. A surprising amount lives in nobody, held together by habit and proximity. Those are the places an agent will do something wrong with total confidence. The only way to find them is to have people who know the work watching agents attempt it.

Nothing at this layer is autonomous. No agent is running anything alone. This is the layer where the company learns to direct, and where the raw material for the next layer gets created.

Layer two: the company, written down and reachable

For a person to direct an agent on real work, the agent needs what a new hire needs. It has to know how the company works. It has to be able to reach the systems where the work lives. And it has to have the reach a person in that role would have.

Three things, and they are the actual asset.

The company written down. Every process exists as a plain-language document that says what the work is, how it is done, what good looks like, what the exceptions are, and what must never happen. Not a wiki. Working documents an agent loads at the start of a task and follows. For the first time the company's knowledge exists outside people's heads in a form that can be executed. Most companies never built this because people carried it implicitly. Agents carry nothing implicitly.

The system exposed through a protocol. Everything a person can do in the operating system, an agent can do through it. Clients, projects, content, reporting, requests, approvals. This is where owning the software pays off, because you can give agents the full surface of the business instead of a sliver.

The same access a person in the role has. Companies get this wrong in the safe direction. Give an agent read-only access to a sandbox and it can do nothing useful, and everyone concludes agents do not work. Give it the access a person in that role has, inside the same boundaries, and it can do the job. Which forces the boundaries to actually exist, on paper, instead of living in a manager's sense of what is reasonable.

Put those together and "a person using a chatbot" becomes "a person directing a worker that knows the company." The amount of work that moves per person changes in a way that is hard to believe until you watch it.

Layer three: the loops

Now the word "agent" starts to mean what people think it means.

Once the processes are written, the system is reachable, and people have spent time verifying agent work by hand, you know which processes agents do reliably. Those become loops. Not "an agent that runs the company." A specific process, with a specific trigger, a written mandate, a defined output, and a defined moment where it hands back to a person. The human's job moves from doing the work to designing and supervising the loop.

Two rules hold.

The verifier is never the doer. An agent asked to grade its own work will praise it. Every loop gets a separate check, a second agent with a skeptical mandate or a person, before anything reaches the outside world.

The agent looks up. A loop stops and asks when a decision is consequential, when it needs expertise the process document does not capture, or when something is happening that a person would want to see. An agent that never looks up is not autonomous. It is unsupervised, and unsupervised at scale is how you end up in the news.

Layer four: employment

Somewhere in layer three you hit a wall, and the wall is the real subject of this decade for companies.

Everything a company does to employ a person, it built over a century and has since forgotten about. Someone issues an identity. Someone issues access. A manager sets limits. Finance tracks cost. Records exist so the company remembers what it did and why. Nobody thinks about this apparatus because it is finished.

For agents, none of it exists. And the moment you are running real loops, you need all of it.

Identity. An agent has to be someone. A name, a role, an accountable owner, a signature on its work. Today most agents wear the badge of whoever launched them, so a company running twelve of them cannot answer the simplest question in management: who did that.

Authority. What it may do alone, what needs approval, what is forbidden. Human organizations answer this explicitly and call it delegation. Most agent deployments answer it with a binary: watch every step, or let it run and hope. Written authority is what lets you stop watching every step.

Direction. Work arrives in a form the agent can execute, in priority order, and when it needs a human it can reach one wherever they are. The most expensive failure in agent work is not an error. It is a loop that stopped, asked a question, and waited four hours because nobody was looking.

Accounting. Agent labor has a cost per unit and a failure rate. Every company knows its labor cost per person, per project, per client. Almost none know the equivalent for agents, which means they cannot price the work or tell which of it makes money.

Record. What was done, by whom, under what authority, approved by whom, at what cost, to what effect. In a human company this is compliance exhaust. In a company that runs on agents it is the primary asset. Anyone can rent the same models. Nobody else has your history.

You need none of this at layer one. A little at layer two. By layer three you cannot run without it. The companies abandoning agent projects are, almost always, companies that reached layer three without noticing that the layers below it were prerequisites.

Why the order is not optional

Each layer manufactures what the next one consumes.

Owning the software gives agents a surface. Putting every person through AI surfaces the processes and maps where judgment lives. Writing the company down turns that into something an agent can execute. Reachable systems and real access turn documents into work. Loops turn work into throughput. And the moment throughput is real, identity, authority, direction, accounting, and record stop being nice ideas and become the difference between a company and a pile of sessions.

Skip layer one and there is nothing to write down. Skip layer two and the loops have nothing to run on. Skip layer four and the loops cannot be trusted with anything that matters, so they never get to do anything that matters, so the initiative gets cancelled for unclear business value. That sentence is most of the agent failures you will read about, and none of them are the model's fault.

What this asks of whoever runs the company

Three decisions, in order, that nobody else can make.

That every person works through AI directly, as a condition of the job, with the company's support behind them. Uncomfortable because it is universal. The only version that works, for the same reason.

That the company gets written down. The actual processes, in the words the work is done in, maintained by the people who do it. Slow, unglamorous, and it is the asset. A company whose processes exist only in people cannot employ agents, and could never really scale people either.

That someone decides what agents may do without asking. Per process, on paper, by a person with the authority to decide it. Until it is written, agents cannot be trusted with anything consequential. The moment it is, they can be trusted with nearly everything in that process.

Everything else is engineering, and the engineering gets easier every month. Those three decisions are not engineering, and they are not getting easier. They are the difference between a company that adds agents when it grows and a company that is still buying tools.

Execution is becoming free. Direction is not. The companies that learn direction first are going to be very hard to catch.