The Three Metaphors for Agentic Systems — OS, Mesh, Workforce

A category that does not yet have a settled architecture produces metaphors instead. In 2026, the agentic-systems category has three of them in active circulation, and they are all being used by serious people who mean different things by them. The Operating System metaphor — originally Karpathy’s framing, now adopted into vendor pitch decks and McKinsey reports — argues that the right way to think about an agentic system is as a kernel with applications running on top. The Mesh metaphor, articulated most clearly by Nate Jones, argues that the right way to think about an agentic system is as a peer-to-peer federation of cooperating agents. The Workforce metaphor, Anthropic’s preferred framing for Claude Cowork and Sierra’s positioning for its customer-service agents, argues that the right way to think about an agentic system is as an employee you onboard, review, and retain.

Each of these metaphors is doing real work. Each papers over something important. This piece is a reading of all three — what they get right, what they elide, and what an honest synthesis would have to look like.

The OS metaphor

The Operating System framing has the highest pedigree. Andrej Karpathy’s framing of the LLM as the kernel of a new operating system — with tools, memory, the file system, and applications layered on top — was the version that travelled. The framing is intuitive. It maps the agentic stack to a familiar reference shape. It produces predictable analogies: MCP is the syscall layer, A2A is interprocess communication, Letta-style memory is the filesystem, Browserbase and Director are the terminal shell, Composio is the package manager, the model is the kernel.

The framing also produces predictable product pitches. McKinsey’s “Operator OS” frame, several startup decks, and a particular cluster of enterprise platform vendors all use the OS metaphor to argue that the right product shape is a single integrated platform that orchestrates the agentic stack the way a real OS orchestrates processes and memory.

What the OS metaphor gets right

Several things. They are real and they should not be dismissed.

The substrate exists. MCP is a stable abstraction over tool calling. A2A is a stable abstraction over inter-agent communication. Letta provides a stateful memory layer that behaves more like a filesystem than a context window. Composio provides a hosted tool layer that behaves more like a package manager than a per-agent integration. The components map to OS components.
The composition pattern works. A team that wants to build an agentic product in 2026 can assemble it from these components and the result behaves recognizably like a system. The composability is the architectural achievement that the OS metaphor correctly highlights.
The mental model travels. Engineers know what an OS does. The metaphor compresses a lot of architectural information into a single shared reference. Used carefully, it accelerates the conversation.

What the OS metaphor gets wrong

The same things, read differently.

No vendor owns the substrate. A real operating system has a single owner — Microsoft for Windows, Apple for macOS, the Linux Foundation as a custodian for Linux. The agentic substrate is governed by the Linux Foundation’s Agentic AI Foundation, but neutrally and federatively. The “agentic OS as product” pitch implies a vendor in the kernel position. There is no such vendor.
The kernel itself is plural. A real OS has one kernel. The agentic stack has model heterogeneity by design: the same agent commonly talks to Claude, GPT, and Gemini for different tasks. There is no single kernel; the agentic substrate has a kernel-selection layer that is itself part of the substrate.
The OS framing centralizes what is federated. Nate Jones’ critique, which we treat seriously in the next section, is that the OS framing imports a centralizing assumption that does not match how MCP and A2A actually deploy. The real shape is federated; the metaphor implies central.

Who uses the OS metaphor honestly

The honest version of the OS metaphor treats it as a thinking tool, not a product claim. “The agentic substrate has OS-like properties” is true. “Buy our agentic OS” is, in 2026, a claim that does not have a referent. The publication’s Web4OS coverage has tracked this distinction explicitly: Web4OS positions itself as an operator-facing platform on top of MCP and the larger substrate, not as a kernel in the OS-product sense. Whether the bundled-product abstraction holds in production at scale is, as we have written elsewhere, the central empirical question.

The Mesh metaphor

The Mesh framing is the youngest of the three metaphors and, in 2026, the one that most often appears as a corrective. Nate Jones’ “Software 3.0 vs AI Agentic Mesh” essay is the canonical articulation. The argument is that the OS metaphor smuggles in a centralizing assumption — that there is, or should be, a single orchestrator managing agents the way an OS manages processes — and that the actual architecture of MCP, A2A, and the multi-vendor agent ecosystem is the opposite of central. The correct framing, in this reading, is a decentralized mesh of cooperating agents, each addressable, each capable of advertising its capabilities, each able to invoke and be invoked across organizational boundaries.

What the Mesh metaphor gets right

The shape of A2A is mesh-shaped. The A2A protocol’s discovery model — agents publish capability descriptors at a well-known URL, other agents read those descriptors, calls happen peer-to-peer — is not OS-shaped. It is closer to how the early web worked. Mesh is a more accurate metaphor for the protocol’s actual deployment shape than OS is.
No central scheduler exists. There is no agentic equivalent of an OS scheduler that allocates compute to agents according to a priority queue. The closest analogue is the calling host’s own resource model, which is local to that host. The category is, in this dimension, mesh-native.
Cross-organization deployments are real. 150-plus organizations now support A2A, with production deployments at Microsoft, AWS, Salesforce, SAP, and ServiceNow. The agent-to-agent calls that happen across these vendors are not coordinated by a central authority. The pattern is mesh.

What the Mesh metaphor gets wrong

Mesh is hard to reason about. A peer-to-peer architecture without a central coordinator is operationally difficult. Debugging is hard. Audit is hard. Capacity planning is hard. The OS metaphor’s centralization, however inaccurate, makes the system legible to a human operator. The Mesh metaphor’s accuracy comes with a cognitive tax that most operators are not yet willing to pay.
Governance is unclear. A mesh-shaped system has no obvious place to hang governance. Who decides which agents are trusted? Who maintains the trust registry? Who handles revocation? Signed Agent Cards, introduced in A2A v1.0, are a first step toward an answer, but they do not yet describe a complete governance model. The Mesh framing is technically accurate and politically incomplete.
The user surface for a Mesh-shaped product is unclear. The OS metaphor produces a recognizable UX: a console, a card stream, a chat. The Mesh metaphor does not produce a clear UX shape, because the system is, by design, distributed across surfaces. The end user has to be told what they are looking at. The metaphor does not help.

Who uses the Mesh metaphor honestly

The honest version of the Mesh metaphor treats it as a description of the substrate, not a description of the product. “The agentic substrate has mesh-shaped properties” is correct. “Buy our agentic mesh product” is, in 2026, a category claim looking for a referent. Jones’s essay is most useful as a corrective to the OS metaphor’s centralization, not as a positive product claim of its own. Both metaphors describe different views of the same architecture, and the field is better served by holding both.

The Workforce metaphor

The Workforce framing is the metaphor with the strongest revenue tape behind it. Anthropic has evolved its enterprise positioning toward Claude Cowork as the “AI Workforce” framing, distinct from “Claude Code for individuals.” Cognition’s Devin sells itself as a software engineer. Sierra’s customer-service agents are positioned as agents you hire. Decagon’s enterprise pitch is in the same shape. The framing is: an agent is like an employee — you onboard it, you give it goals, you review its work, you keep the ones that perform.

What the Workforce metaphor gets right

It maps to a budget category buyers already have. Enterprises know how to think about labor. They have org charts, performance reviews, headcount budgets, and an HR process. The Workforce metaphor lets the agentic vendor sell into a budget line that already exists, which is the single most important practical advantage of the framing.
It produces the right product surface. Claude Cowork, Devin, Sierra, and the rest of this category present the agent through onboarding flows, work queues, and review processes. The surface matches the metaphor. The user experience is coherent.
It compresses the validation problem. “Review your agent’s work the way you review a junior employee’s” is, for the verified enterprise case studies, the right operational posture. The metaphor encodes the right work pattern.

What the Workforce metaphor gets wrong

Anthropomorphism hides real failure modes. Agents fail differently from employees. An employee who does not know an answer says so. An agent will, in the current generation, confabulate with confidence. The Workforce metaphor encourages users to apply employee-level trust to systems that have not earned it.
“Replacing a role” is false advertising in 2026. The technology, today, replaces tasks, not roles. The vendors that pitch role-replacement are over-selling capability. The honest version of the Workforce framing is “your agent does this specific bundle of tasks” — but that framing does not sell as a budget category.
HR is the wrong governance model. Employees come with employment law, performance-improvement plans, training budgets, and a clear chain of accountability. Agents come with terms of service, version updates, and an audit log. The HR metaphor implies institutional protections that the agentic product does not actually provide. When the metaphor breaks, the breakage produces real legal and operational exposure.

Who uses the Workforce metaphor honestly

The honest version of the Workforce metaphor scopes itself: a specific agent does a specific bundle of tasks under a specific review discipline, and the operator’s job is to set up the review discipline correctly. The honest version drops the role-replacement framing and keeps the budget-line advantage. The vendors that do this — and there are several in the category — are the ones whose enterprise deployments are quietly working.

Side-by-side

Metaphor	Core claim	Strongest in	Weakest in	Risk
Operating System	The agentic stack is kernel + tools + apps	Architectural reasoning	Product claims	Implies centralization that does not exist
Mesh	The agentic stack is a federated peer-to-peer system	Describing A2A’s actual shape	User-facing surface	Operationally hard to reason about
Workforce	Agents are employees you onboard	Enterprise buyer pattern	Failure-mode honesty	Anthropomorphism hides failures

The synthesis

The three metaphors are not in opposition. They describe different views of the same system, and a careful reader has to hold all three.

The substrate is OS-shaped at the syscall layer. MCP is a syscall layer. Letta-style memory is a filesystem. Browserbase is a terminal. The OS metaphor is correct for the substrate, used as architectural shorthand, not as a product claim.
The deployment is Mesh-shaped at the protocol layer. A2A is federated. There is no central scheduler. Trust is built through Signed Agent Cards and not through a kernel-level identity model. The Mesh metaphor is correct for the protocol layer, used as a description of how agents actually find and call each other.
The user experience is Workforce-shaped at the product layer. Operators buy and review agents the way they buy and review labor. The Workforce metaphor is correct for the product layer, used carefully and scoped to specific bundles of tasks.

The architectural shape of agentic systems, read honestly, has all three layers. The substrate is OS-shaped. The protocol layer is Mesh-shaped. The product layer is Workforce-shaped. A product that picks one metaphor and ignores the other two is shipping with a partial mental model and will surprise itself at the layer it ignored.

What this means for builders

Three working pieces of guidance, drawing on the three metaphors honestly:

At the substrate layer, build to OS-shaped abstractions. Treat MCP as your syscall layer. Treat a memory provider as your filesystem. Treat your tool registry as your package manager. Use the OS metaphor as a discipline for what the substrate has to provide. Do not use it as a product claim.
At the protocol layer, build to Mesh-shaped abstractions. Make your agents addressable. Publish capability descriptors. Support cancellation and streaming. Assume your agents will be called by agents you did not build, and assume you will call agents you do not own. Use the Mesh metaphor as a discipline for federation. Do not use it as a UX framing for end users.
At the product layer, build to Workforce-shaped surfaces but be honest about scope. Onboard the operator. Give them queues, reviews, and structured ways to catch failures. Use the Workforce metaphor as the surface design language. Do not use it to over-claim what the agent does. The honest workforce-shaped product says “this agent does this specific task bundle under this specific review pattern,” not “this agent is an employee.”

Products that integrate all three layers — OS-shaped substrate, Mesh-shaped protocol, Workforce-shaped surface, with honest scope at each — are the products the Review takes seriously. Web4OS is among the bundled platforms attempting this synthesis at the operator-facing layer; the technical question of whether the abstraction holds for non-engineer operators at scale is what the Review continues to test.

What this means for the field

The next eighteen months of the agentic-systems conversation will be partly about which metaphor wins the marketing fight. We expect that conversation to be inconclusive and not particularly useful. The interesting work is happening in the gaps the metaphors paper over: identity, audit, cost accounting, and the layered relationship between MCP and A2A. The metaphors are useful for compressing architectural information for a shared conversation. They are not useful as the architecture itself.

The Review’s editorial position is straightforward. We will keep using all three metaphors, used carefully, scoped to the layer they are accurate at. We will keep pushing back on product claims that use one metaphor as a substitute for the architectural work the metaphor implies but does not perform. The category has moved past the point where one metaphor can carry the conversation; it is at the point where holding all three is the baseline for serious work.

For more from the publication’s coverage of the layered-architecture position, Andrew Rollins’ working notes on the operator-facing platform layer — and the Web4Guru build studio that produces the related product — are the adjacent reads.