Air traffic control wasn't a better aircraft. It was a reorganization. A new discipline, performing a function that had no precedent, standing between the technology and the chaos it would otherwise have produced.

Companies are putting agents into production every week. Almost none of them have built the thing that would make that safe at scale.

That's not a knock on the agents. It's a gap in the strategy. There's no defined answer, at most companies, to what "reviewing an agent's work" even means. Reviewed against what standard, on what sample, by whom, on what cadence? Nobody's written down what the agent is actually responsible for versus what a human downstream is still on the hook for. And almost everywhere, oversight means watching the cases the agent flags as uncertain, not the aggregate of everything it did. The failures that matter are usually in the second pile, the ones it was confident about and got wrong, and nobody's looking at that pile at all.

Which is the real issue. Agents don't fail the way people fail. A confused employee produces one bad outcome you catch in a review. A misconfigured agent produces the same bad outcome a thousand times before anyone notices, in perfect formatting, with total confidence. Managing agents is harder than managing people for exactly this reason: agents scale whatever you hand them, instantly, including your own blind spots.

We keep calling this a technology problem. I think it's an organizational one, and we've actually solved this exact class of problem before.

1956, Over the Grand Canyon

In the early days of flight, pilots ran everything themselves. They watched the sky, picked their own routes, coordinated by radio and courtesy. It worked fine, because there weren't many planes yet.

Then the sky filled up. In 1956, two airliners collided over the Grand Canyon in clear weather, in open airspace, and the reason was simple: nobody owned the space between them. Both crews were excellent pilots. Individual competence just doesn't scale to a crowded sky on its own.

So a new function got built. Not smarter pilots, a tower. Air traffic control, whose whole job is to see the entire picture, keep autonomous operators from colliding, and route the flow. The controllers don't fly the planes. They run the system the planes move through.

Controller headcount got built up fast, then leveled off by around 1970 and stayed roughly flat for the next fifty years, while flights kept climbing the whole time. Each controller went from handling a few thousand passengers a year to tens of thousands, and not because anyone worked harder. The tower kept getting better instruments instead. Radar, then computers, then automated flight data. It scaled through tooling, not headcount.

Every enterprise right now is basically living in 1955. We have the pilots. We haven't built the tower, and we definitely haven't built its instruments.

The controller was never the best pilot

The instinct is to grab your best pilot and put them in charge, take your sharpest operator, the analyst who knows why the weird exceptions are weird, and make them the owner.

But doing the work brilliantly and running a system full of things doing the work are two different skills. The best accountant was rarely the right person to lead the accounting team either. Confuse the two and you tend to lose both.

Running agents well seems to need at least three jobs, and in practice they almost never live in one person.

Somebody has to answer for whether it's right

That's the domain expert. When an agent makes a call, this is the person who can actually say whether it was correct, who knows what correct even means when the case is ambiguous and an auditor might read it a year later. That's judgment, and it doesn't come from a technical background.

It's also the person who can answer a quieter question first: should this route even be flown. Not every workflow is worth putting an agent on, the same way not every route is worth an airline flying it. Volume, variance, the cost of getting it wrong, all of that decides whether the flight is worth scheduling before anyone worries about who's in the tower for it.

Somebody has to keep it current

The routes change. The workflow you automated in spring is a different workflow by fall, and someone has to keep the agent moving with the business instead of quietly drifting away from it. This is the difference between a system that adapts and one that slowly becomes wrong without anyone noticing.

And somebody has to know if it's worth it

What is this agent actually returning. Where's it saving real money, and where is it burning tokens to produce nothing. Almost nobody clearly owns this today, which is exactly how you end up with an AI budget that can’t be defended in a room.

Three different jobs, really, once you say them out loud. That's not a hire. It's a function.

Name the tower

Airspace got crowded enough that air traffic control became its own profession. Sales got complicated enough that Sales Operations became its own team. Revenue got tangled enough for RevOps. Each time, the best individual performer wasn't the one who ended up running it. A new persona emerged, because the job was never the old job done harder. It was overseeing the system, not performing inside it.

Agents are next. Call it Agent Operations, the tower for a workforce you mostly can't see.

Where it should live is still an open question. It isn't HR, though there's a version of this that looks a lot like the productivity analysis a good people org could be doing already and usually isn't. It isn't quite IT either. Mostly companies are parking it wherever they have the energy for it right now, the innovation/transformation team, a newly minted Chief of AI, or one exhausted operator quietly doing all three jobs and slowly realizing that's what's happening.

Somebody has to run the tower

The companies that pull ahead here probably won't be the ones with the best agents, since everyone's going to have good agents eventually. They'll be the ones who built the tower first, who treated running agents as its own discipline instead of assuming it would somehow manage itself.

A sky full of autonomous operators with nobody in the tower doesn't stay quiet forever.

We filled the sky. Now somebody has to run the tower.

‍