McKinsey Described the Agent Factory. Most Systems Are Still Just Sequences

There is a difference between describing a system and being able to run one, and right now that difference is being underestimated. McKinsey & Company outlined the agent factory  in their The AI revolution in software development article as the next operating model for enterprise AI, a shift toward systems where agents coordinate, decisions compound, and workflows become continuous rather than discrete. The direction is right, and in many ways inevitable. But what most teams have taken from that description is a model to adopt, when what they have been handed is a constraint they have not yet solved. Because the agent factory is not a capability upgrade. It is a system requirement. And most architectures in production today don’t satisfy it.

The Model Assumes a System

 The agent factory assumes that multiple agents can operate together across time on a shared understanding of the world, not just a shared dataset or a shared prompt, but a consistent view of entities, relationships, and state that persists as decisions are made and updated. That assumption is where things begin to break.

Most systems in place today were built for retrieval and generation. They assemble information, produce an answer, and reset. Each interaction stands on its own. Each decision is locally constructed. That works when tasks are isolated. It doesn’t work when decisions depend on each other.

Most Agent Systems Aren’t Systems

On the surface, many teams appear to be moving in the right direction. They have introduced multiple agents, layered in orchestration frameworks, expanded their tool chains, and begun connecting workflows that were previously separate. It looks like a system is forming. It isn’t. Most agent systems aren’t systems, they are sequences. A set of independent processes, coordinated in order, each operating on its own reconstructed view of context. The distinction is easy to miss early on because the outputs still look reasonable. Each step, in isolation, appears to work. The problem only becomes visible when those steps begin to depend on each other.

Sequences Break Under Dependency

 In a sequence, each step assumes that the context it receives is complete and correct. But in systems where context is reconstructed at every step, that assumption does not hold. Each agent: retrieves slightly different information, infers relationships differently, and operates on a version of reality that may already be outdated. Individually, these decisions can appear coherent. Collectively, they diverge. Agents don’t fail. Sequences fail under dependency.

Drift is the Failure Mode

When systems operate as sequences, inconsistency is not an edge case. It is the natural outcome. Each step introduces small variations in how context is assembled and interpreted. Those variations compound as decisions propagate. What begins as a minor difference becomes a structural inconsistency. Drift is not noise. It is the system losing a shared version of reality. As systems scale, this does not become a risk. It becomes the default.

Why Orchestration Doesn’t Fix It

 The typical response is to improve orchestration and define workflows more precisely, control execution more tightly, add guardrails between steps. But orchestration addresses order, not understanding. It determines what happens and when. It does not determine whether each step is grounded in the same context. You can orchestrate actions. You cannot orchestrate shared understanding. Without shared context, even perfectly orchestrated sequences produce inconsistent outcomes, simply because each step is based on a different interpretation of reality.

The Difference Between a Sequence and a System

That difference is not incremental. It is structural.

Without Shared Context, Coordination Becomes Rework

 When context is not shared, every agent is forced to solve the same problem repeatedly: reconstructing the world before it can act. The system compensates by retrieving more information, recomputing more state, and revalidating more assumptions. But without shared context, coordination becomes recomputation. And recomputation does not scale.

Where the System Breaks

 As more agents are introduced, the system does not simply become more capable. It becomes more interdependent. More agents create more dependencies. More dependencies create more opportunities for inconsistency. Without a stable, shared representation of context, the system has no way to maintain alignment across those dependencies. So, it works harder. Not because the problem is inherently more complex. Because the architecture is absorbing complexity it was never designed to manage.

The Illusion of a Working System

At small scale, sequences can appear indistinguishable from systems. Outputs look correct. Workflows appear coordinated. The gaps remain hidden. At scale, the illusion breaks. The system slows down. Decisions become inconsistent. Costs rise faster than capability. Trust begins to erode. Not because the model is failing. Because the system never existed.

What Makes the Agent Factory Real

For the agent factory to function as a system, context must be:

• shared across agents
• persistent across time
• structured as relationships, not fragments
• maintained, not reconstructed

Only then can decisions build on each other instead of reinterpreting each other. Only then does coordination become a property of the system rather than something it is constantly trying to approximate.

The Real Gap

McKinsey described the operating model. They did not define the condition required to make it work. That condition is not: more agents, better models, and richer orchestration. It is the ability to maintain a shared, structured understanding of context across decisions. Most systems today do not have that. They execute sequences. They do not operate as systems.

The Real Takeaway

 The agent factory is not a future concept. It is a present constraint, and it is already separating systems that scale from those that stall. Until context is treated as a persistent, shared layer of the system and not something assembled at runtime, most implementations will follow the same pattern. They will be convincing at first. They will scale inconsistently. They are expensive to maintain. That outcome is not a risk. It is the default.