Why Agentic Engineering Demands a Structural Response

Hierarchy is an information routing protocol. Each layer aggregates context from below and relays decisions from above. Add people, add layers. Add layers, slow the signal. From the Roman legions to the modern corporation, every org design innovation — matrix structures, cross-functional squads, Holacracy — has been an attempt to work around this tradeoff. None succeeded at scale.

AI agents are about to put this constraint under pressure it has never faced.

The bottleneck is moving

AI is making every individual engineer several times more productive. No engineering organization has become several times more valuable as a result. The productivity dissipates — because it isn’t coordinated.

This is the electrification pattern. In the 1890s, textile mills replaced steam motors with electric motors and saw no productivity gains for 30 years. The gains materialized only when the factory itself was redesigned. The technology was superior. The organization was not.

The empowered, cross-functional product team — a PM, a designer, a tech lead, and a handful of engineers — was itself a response to the coordination problem. Rather than routing all customer insight up through management and back down, it made the team the primary surface for gathering signal and resolving ambiguity through human conversation. Leadership focused on coherence and strategic direction — lower bandwidth, fewer layers, faster decisions. It worked well for a world where coding was the bottleneck and all team members were human.

That world is ending. Engineers are running multiple agent sessions in parallel, queuing overnight work, extending their toolchains. Some are several times more productive than a year ago. But their organizations haven’t changed. And two bottlenecks are emerging that the current model can’t absorb:

Product definition and design review. PMs cannot specify fast enough. A 1:5 PM-to-engineer ratio assumed coding was the slow step. Vague briefs that once could be iterated over weeks now produce divergent code within a day. Meanwhile, a single designer cannot meaningfully produce mockups for four engineers each running parallel agent sessions. Design becomes a serial chokepoint in an increasingly parallel system. As more features land simultaneously, integration quality and strategic alignment strain proportionally.

The end of collaborative ambiguity. An agile product team can operate with loosely defined deliverables — focusing on the customer problem and iterating together. But an engineer directing a fleet of AI agents cannot work this way. Agents need explicit specifications, clear acceptance criteria, well-defined boundaries. Running agents is closer to running a mini waterfall team than participating in a collaborative sprint. The product team model absorbed ambiguity through human conversation. The agentic model requires that ambiguity be resolved before the work begins.

Two wrong answers

The copilot response is to keep the existing structure and give everyone AI tools. This makes each person faster without changing how they coordinate. But the bottleneck isn’t individual speed — it’s the shared backlog, the serial design review, the PM trying to specify for four engineers simultaneously. Augmenting individuals inside a structure designed for sequential execution produces faster individuals waiting in the same queues. Electric motors bolted onto the steam-age factory.

The world-model response is a newer idea, articulated most clearly by Jack Dorsey in a recent essay on Block. The proposal: replace human coordination with an AI system that maintains a model of company operations and customer behavior, and let an intelligence layer compose solutions autonomously. Normalize to three roles — individual contributors, directly responsible individuals, and player-coaches. No permanent middle management.

Block may be the ideal test case: remote-first, artifact-rich, with real-time transaction data on both sides of millions of financial interactions. But as a general model it has a structural blind spot. A system built on operational data will find operational opportunities. It will not surface that the team should pursue an entirely different problem space, or that a cultural shift demands a strategic pivot no dashboard would suggest.

Freeing an organization of management is not autonomy, it’s anarchy. Hierarchy routes information, but it also absorbs organizational friction — shielding teams from competing priorities, clearing bureaucratic obstacles, managing the pressure that flows downward. As John Cutler puts it, framing management purely as information processing ignores these asymmetries. Good managers are critical. It’s the structure they operate in that needs to change.

Right now, leadership is pushing for AI-driven productivity with increasing urgency, while product teams are scrambling to adapt. Both responses above fail because they start from the top. The better starting point is where the agents are actually entering the production system, with the simpler question: what should a team look like when one engineer with agent capacity can deliver what the whole team used to?

A larger organization needs a structural answer

Essentially, adding agent capacity is adding headcount. You didn’t hire anyone, but your organization just got much larger. Four engineers each running parallel agent sessions produce the output of a team several times their size. And larger organizations have always required structural responses. The question is what kind.

The answer starts with the engineer. One engineer with agent capacity is now a delivery unit, not a contributor. They need constraints — outcome definitions, design system rules, API contracts, performance budgets — not detailed specs. You could give every engineer a dedicated PM and designer (a pod of three), which eliminates the specification bottleneck directly. But good PMs and designers are already scarcer than engineers, and that gap widens as AI makes engineering capacity more abundant. The alternative is to trust the engineer with more judgment within clear guardrails. This develops capability over time rather than consuming it, and it works with the talent you have today. And “engineer” here describes a structural role, not a job title — a designer or domain expert with technical fluency could occupy the same position. We may see roles normalize. What matters is one person accountable for what ships, within constraints set by the layer above.

Scales comes through coherence. Four engineer-led workstreams shipping into the same product need someone who holds the whole. The triad stops producing artifacts and starts steering: setting constraints, reviewing outputs, ensuring workstreams add up to a coherent product. Their value is no longer what they produce but the quality of the guardrails they set. Same seven people, new operating model, four parallel streams instead of one shared backlog. A product team scales into a product group, or division, whatever you like to call your higher layer.

This is also why pods need this layer above them at any real scale. Four independent pods need a coordinator who owns coherence — and what you end up building looks a lot like a triad steering workstreams, just at a higher altitude with weaker context.

Coherence is a fractal problem — it reappears at every layer. Multiple teams need someone holding the product-level picture. The structural response doesn’t solve this everywhere. But it builds the answer in at the layer where organizations feel the pain first.

The real payoff is scope, not efficiency. The dominant framing sees AI-driven org change as doing the same with fewer people. But when one engineer with agent capacity can deliver what a full team does today, the remaining delivery units represent new capacity — adjacent problems, deeper capability, technical bets that never survived prioritization. The challenge becomes “what new outcome areas should we pursue?” not “how do we sequence this backlog?” The constraint was never headcount. It was coordination architecture.

Where this lands

The product team model we’ve relied on for the past decade was a good answer to the coordination problem of its era. It made the team the customer-facing surface and freed leadership to focus on coherence. But it assumed human-paced execution and collaborative ambiguity resolution — both of which break under agentic pressure.

The response has to be structural. Constraints that replace conversations. Coherence built into the structure, not bolted on after the fact.

The hierarchy doesn’t go away. It just stops doing the wrong work. Whether the nodes in your org chart are humans, agents, or both, and roles change, the architecture problem is the same. You still need layers. You still need constraints. You still need someone — or something — that steers.