It’s almost cliché now to say that AI is rapidly collapsing the productivity unit. But what is less obvious is what it does to the coordination surface. Most organizations are preparing for only the first.
Every organization must balance three systems to deliver business outcomes: Productivity, Context, and Coordination. Productivity creates the artifact, Context gives people and agents the state required to act intelligently, and Coordination resolves dependencies, disagreements, decisions, and accountability.
A couple of quarters ago, we developed an entire operating model around these three systems. Since it was a pretty significant and un-tested operating change, we first ran a canary across our single most important project - the one we built for coordination (next article). We learned and iterated, and then rolled it out across every project and function in the organization.
I am writing our learnings down as a three-part series. This article examines the shrinking productivity unit, the second tackles organizational memory (everyone and their sibling is building one) and the limits of Context, and the third addresses Coordination - the most significant of the three.
Context is useless without coordination.
The current conversation focuses on shrinking Productivity units, while enterprise-memory efforts address Context. Coordination remains the challenging issue because smaller units create more boundaries across which outcomes have to be composed.
The two-pizza team had a good run
The unit of production has been shrinking for decades, especially in software.
Heavy-engineering teams remain large for good reasons. Rockets, semiconductor fabrication lines, manufacturing systems, or quantum networks require many specialist capabilities to deliver on outcomes. AI can help accelerate design, simulation, software, and analysis but physical systems still require many specialists.
Software followed a different path. Cloud-native architectures absorbed much of the infrastructure work that product teams once staffed themselves, allowing teams to provision compute, storage, databases, telemetry, and deployment infrastructure through services. The productivity unit shrank toward the two-pizza team.
Cloud shrank the team and handed the coordination problem to APIs.
At Amazon, the Bezos-era API mandate became the de facto manifesto for this architecture. Teams exposed capabilities through service interfaces rather than requiring access into someone else’s implementations. APIs, service contracts, ownership boundaries, and observability constrained the technical coordination surface enough for autonomous 2-pizza teams to deliver outcomes.
Agentic systems are now absorbing even more work. A few humans can generate code, tests, specifications, research, analysis, content, and operational workflows that previously required a much larger team. We call this productivity unit a Tiny Team with Tokens, or T3 - usually one to five humans augmented by agentic systems assigned to a problem.
But as the T3s asymptote towards near-zero intra-team coordination and move faster because of it, the organization splits its outcomes across many more T3s. The coordination surface and tax across teams and with stakeholders just explodes exponentially. A good operating model design keeps most of those possible coordination interfaces from becoming critical dependencies.
The smaller the productivity unit gets, the more important its coordination interfaces become.
A note: The upper-left of the figure - the singular node - is therefore a direction of travel, and may never be an end state: use the smallest viable productivity unit, make context continuously available, and eliminate routine coordination wherever the work does not actually require it.
One person, many interfaces
As an example of this extreme compression narrative, Brian Armstrong recently announced that Coinbase will experiment with one-person teams combining engineering, design, and product management in one AI-augmented role. This is an interesting experiment because it places a one-person productivity unit inside a multi-team enterprise.
A one-person company (as touted by many, including Sam Altman and Dario Amodei) has no internal inter-team coordination surface, while a one-person team remains connected to shared architecture, organizational priorities, customers, cultures, communities, governance, and other teams.
Size of one belongs in the design space whenever the outcomes permit it, but it is not true most of the time in enterprises.
Models and agents can generate code, research, specifications, and architectural alternatives. But customer conversations, open source code collaborations, judgment under ambiguity, community trust, and accountability after a bad decision still require humans. Team size follows this irreducible human work. A bounded, reversible, artifact-heavy problem may need one person, while work requiring complementary judgment, relationships, or accountability will usually need three to five.
When a T3 grows beyond five, leaders should inspect the problem definition because the team may contain multiple independently deliverable problems that belong in separate T3s — you are, at this point, inching towards a two-pizza team.
Gartner recently put a number on the size that is almost identical to our number: it predicts that 60% of organizations will adopt smaller software engineering teams of size 1-6, at scale by 2029.
Tokens absorb agentifiable work while humans retain responsibility for the outcome.
The coordination tax moves
A large team pays substantial coordination cost inside the team because more people must align before acting. A small team lowers that internal tax, but the surrounding work still has to be composed into an outcome. As organizations divide outcomes among more T3s, they create more boundaries where assumptions, dependencies, architectures, and decisions must align. Clear problem decomposition, ownership, interfaces, and resolution paths keep that dependency graph manageable.
Without that design, small teams duplicate work, optimize against incompatible assumptions, and pursue locally rational priorities that fail to produce an organizational outcome.
Artifact velocity measures how quickly a unit produces output, while outcome velocity measures how quickly the organization converts interdependent outputs into something that matters to a customer, community, or market. Each era - from large heavy-engineering systems to Tiny Teams with Tokens (T3) - makes artifact generation cheaper and reduced coordination inside the productivity unit, while raising the coordination across teams. The 2-pizza teams solved it through services and APIs. We need a new mechanism for solving this for T3s - which is the topic of the next two articles in this series.
When the productivity unit shrinks, the bottleneck shifts to coordination.



