GPT theory and the Post-Intelligence Bottleneck
So far, we've seen that:
- There is a Post-Intelligence Bottleneck that is stopping us from realizing AI's productive potential
- AI is a General Purpose Technology (GPT), and history shows that GPTs like electricity and IT have required new infrastructure and ways of working to become fully realized
Now, I'll bring these together - and suggest how the Post-Intelligence Bottleneck highlights our need for new infrastructure and ways of working.
Revisiting our scenario of mass adoption
We previously had imagined a fictitious Fortune 500 scale company, Dunane & MacMillan (DMM).
We had seen that, even with 100% AI adoption and proficiency, DMM might plausibly gain no more than 2.0-2.5x in overall company productivity, and possibly far less.
This would be a miraculous increase on rates of growth - but still a massive productivity hemorrhage on the 100x potential of AI.
Skeptics might posit that the structure of an organization is necessarily inefficient in some ways - through things like information loss and coordination costs.
I want to suggest that at least some of this Post-Intelligence Bottleneck is a gap in infrastructure and ways of working - similar to the economic history of electricity and IT.
As we'll see, a new agent-native infrastructure could dramatically reduce organizational costs - and unlock the real productive potential of AI.
The intuitive case for new infrastructure and ways of working
One key fact we must remember is this: AI is not human.
This might seem trite, but it's the foundational pillar for the more precise point: we should not assume that organizational or productivity infrastructure built for humans is appropriate or optimal for AI agents.
For most of the past 30 years, knowledge work has operated within a central paradigm of artifacts created through GUIs and a human delegation tree:
- The organization runs a pyramid-like chain of command. At its simplest, this can be conceived as: CEO -> management -> ICs (individual contributors).
- ICs are the ultimate executors for a lot of delegated work, which typically takes place through GUIs (graphical user interfaces) for things like email, documents and spreadsheets.
- Management and the CEO use a mixture of meetings and GUIs for 'work about work', e.g. documenting what work should be done and communicating that down the delegation tree.
With AI, what's already emerging is humans sitting over a delegation tree for AI agents. This can be 1:1 (one human to one agent), 1:M (one human to many agents), or even 1:M:M (one human to many 'orchestrator agents', each of whom manages many 'worker agents').
There are two dimensions along which we can see gaps opening up, in infrastructure and ways of working:
- Where does the work happen efficiently? If AI agents are the 'doers', are GUIs the best place for the creation of knowledge work artifacts?
- How is the work organized efficiently? If humans have delegation trees composed of multiple agent layers, are meetings and GUIs the best way to delegate and coordinate?
Four gaps in agent infrastructure
Across these two dimensions, there are four gaps in today's infrastructure behind the Post-Intelligence Bottleneck.
They correspond to four questions about agent activity:
- The interface gap: the 'how'
- The coordination gap: the 'what'
- The provenance gap: the 'why'
- The discretion gap: the 'who'
The interface gap: the 'how' of agent activity
Up until the 21st century, most humans navigated around using physical maps. We'd pull it out, locate our starting point, and try to manufacture a route from there to our desired destination, with a combination of eye-balling, finger-tracing, and received wisdom / heuristics.
Now, imagine asking your favorite AI model, "Can you help me navigate from my home to this office address, in a route that goes via this local school?"
It'd be cool and technically impressive if the AI was able to parse a physical map, process the route information within and digest it into some human-facing directions for you.
However, with the way that frontier AI works today, it'd also be incredibly inefficient.
There's a more machine-friendly way of navigating: GPS, a technology that is purpose-built for machine consumption.
The breakthrough in navigation came not from 'training machines to navigate the way that humans do' - it came from building an entirely new method and interface that achieved the same outcome in a far more efficient manner.
Lots of incumbents may try to retrofit agent-facing interfaces, like MCP, onto their existing products. But it seems plausible that the best agent-native interface for knowledge work will emerge from being agent-first.
For instance, GPS isn't 'a new interface for a map' - it's an entirely different way of representing spatial information, with comes with a more machine-friendly interface baked-in.
This is the interface infrastructure gap. For agents carrying out knowledge work on our behalf, we need to figure out:
- What do agents need to work at their best?
- What interfaces would support that?
The coordination gap: the 'what' of agent activity
Even at human-speed, effective team coordination is a real problem - one which has birthed an industry and several frameworks like agile, OKRs and RACI.
With agents, the problem is disproportionately bigger.
Imagine if a new 'self-driving rocket car' suddenly spawned into existence and started driving on our roads with the following characteristics:
- Rocket cars travel 100x faster than human cars
- Rocket cars are invisible to other rocket cars
- Rocket cars can spontaneously appear and disappear
It would be enormously difficult to have an effective transportation system based on our current roads and traffic infrastructure.
This colorful thought experiment is a crude way to intuit some of the aspects of agent coordination:
- We have many more actors. Every human can have multiple agents working under them.
- The precise number of actors is unpredictable and incredibly dynamic. It's possible to scale up and down ephemeral agents very quickly.
- Agents can't really 'own' tasks or projects in the human sense of 'being accountable' for it. They don't have persistent, stable identity or existence. (There is no 'agent colleague, Diana' - just an illusion created from a stateless LLM response to input about its purported identity and previous output.)
This is the coordination infrastructure gap. For humans overseeing fleets of fast-moving, ephemeral agents, we need to figure out:
- How do we maintain coherent, real-time awareness of what agents are doing across an organization?
- How do we prevent and resolve conflicts between agents acting on behalf of different humans?
- How do we preserve meaningful human accountability when the 'doers' are stateless and ephemeral?
The provenance gap: the 'why' of agent activity
Chesterton's Fence is a philosophy of change. It takes its name from a parable by the eponymous G. K. Chesterton, who wrote of an imaginary fence:
There exists in such a case a certain institution or law; let us say, for the sake of simplicity, a fence or gate erected across a road. The more modern type of reformer goes gaily up to it and says, "I don't see the use of this; let us clear it away." To which the more intelligent type of reformer will do well to answer: "If you don't see the use of it, I certainly won't let you clear it away. Go away and think. Then, when you can come back and tell me that you do see the use of it, I may allow you to destroy it.
This is a principle that many a software engineer has run afoul of - making changes to a codebase which seems like relatively uncontroversial 'cleaning up', because they don't see the utility of the code that they're removing, only to crash the production app, as it turns out there was some obscure quirk or edge case which the removed code was a patch for.
It's probably not right to dogmatically follow Chesterton's Fence - there may be times where the original intent or rationale of some code, ritual or design is irretrievably lost, and that unfortunate fact shouldn't be an indefeasible blocker on iteration.
However, Chesterton's Fence shows us the value of knowing "why are things the way they currently are?"
Imagine coming back to a financial model in a shared spreadsheet, and noticing that it looks completely different to how you last saw it - both in its structure and in what seem to be its input assumptions.
For this spreadsheet to be useful to you, you probably need to understand a few key things:
- Who changed it?
- Why did they change it?
- What's the basis of the new assumptions?
When we work only with humans, this is default-recoverable.
When we work with humans who each oversee a fleet of agents, this becomes far harder.
- The spreadsheet's history can't tell you whether its changes were made by a human or by an agent
- If it was an agent, the human whose agents made the edits might not even be aware that it was their agents if they're overseeing a fleet of agents
- It might even have been near-simultaneous (and possibly mutually inconsistent) edits by two agents with two different human principals, neither of which was aware of the other agent's intended changes
This is the provenance infrastructure gap. We need a systematic way of identifying:
- Which changes were made by humans or agents?
- For agent-authored changes, who authorized them?
- For agent-authored changes, what input (e.g. decisions, constraints, context) was given to the agent?
The discretion gap: the 'who' of agent activity
A great executive assistant doesn't just follow rules. They know when to interrupt their boss and when to handle something themselves. They know the difference between "the CEO would want to see this immediately" and "this can wait until Monday." They can tell a colleague "I can't share the details, but I'd hold off on that if I were you" — giving a useful signal without betraying a confidence.
This is discretion: the ability to exercise contextual judgment at organizational boundaries. It depends on understanding relationships, reading sensitivity, and knowing when something is above your pay grade — even when nobody explicitly told you where that line is.
Humans are naturally (if imperfectly) good at this. We're socially embedded. We pick up on cues. We feel when something is off. And critically, we're slow enough that if our instincts fail us, someone usually catches the problem before real damage is done.
Agents have none of this. They don't feel organizational tension. They don't pick up on the subtext of why a certain topic might be sensitive. And they move fast enough that by the time a human notices something has gone wrong, the damage is done.
When a human delegates to an agent, they're not just handing over a task — they're implicitly granting a scope of discretion. The agent acts on the human's behalf, and in doing so, it inherits some of their organizational reach. But how much? With what sensitivity to context? And what should it do when it encounters something that a socially aware human would instinctively pause at?
Today, the answer is binary: an agent either has access or it doesn't. A permission is granted or it isn't. Big organizations already have sophisticated answers to authority — roles, approval chains, compliance controls. But these are brick walls: nothing gets through regardless of context.
Discretion is what fills the gaps between the rules. It's what prevents a perfectly-authorized action from being catastrophically ill-timed. And the infrastructure for it looks less like a wall and more like a membrane — a boundary that can reason about what crosses it. Not just "do you have permission?" but "what are you trying to do, and why, and is now the right time?"
The problem deepens as agent hierarchies grow. A human delegates to an orchestrator, which spawns workers, which spawn sub-agents. At each level, the implicit scope of discretion gets passed down — but without any structural mechanism for narrowing it, or for equipping agents with the contextual awareness they'd need to exercise it wisely.
For agents operating at organizational scale, we need infrastructure for discretion:
- How do agents recognize when they've reached a boundary that requires judgment, not just permission?
- When an agent encounters sensitivity it doesn't fully understand, how does it negotiate — sharing enough context to get a useful response without overstepping?
- How do we express policies that aren't binary allow/deny, but contextual — "it depends on what you're trying to do and why"?
- How does discretion narrow as it flows down a delegation chain, so that sub-agents can't inadvertently exercise judgment their human principal never intended to grant?
These four gaps - interface, coordination, provenance and discretion - are not independent problems. They're facets of a single structural deficit: today's knowledge work infrastructure was built for humans working at human speed, with human social instincts, through human interfaces. Agents break every one of those assumptions simultaneously.
The gaps are real, but they're also solvable. To see what solving them might actually look like in practice, let's follow a story through a single Tuesday morning at a Fortune 500 company - and watch what happens when agent-native infrastructure is in place.