On September 28, 2026, Manus shipped version 2.0. It was the company’s first major release since resuming independent operations on September 1, and it arrived in a market that had just watched Meta’s personal agent Muse top the U.S. App Store free charts. The launch was not a feature drop — it was a statement that the next phase of AI agents is not about bigger single models. It is about multiple agents collaborating.
Manus 2.0 introduced four things: the Cascade agent harness, the Cloud Computer, Manus Studio for professional creation, and Cue — a standalone personal-agent app where every agent receives its own email address, phone number, wallet, and virtual computer, and where multiple agents can be placed in a shared group chat to hand work to one another.
The Cue feature that has drawn the most attention is the last one: multi-agent collaboration. Put several agents in a group chat with a shared goal, and they divide the labor — one researches venues, another compiles a shortlist, a third drafts the deck. The user sets direction and makes the final call.
This is the future every agent lab is now building toward. And it raises an architectural question that the agent world has not yet answered: how do you make multi-agent collaboration reliable, observable, and safe at scale?
The answer, increasingly, looks like something the microservices world solved a decade ago: the service mesh. The patterns that Envoy pioneered for routing, load balancing, circuit breaking, and observability between microservices are now converging with agent orchestration. This convergence — call it EnvoyMesh for agents — is the infrastructure layer the multi-agent era will run on.
Manus 2.0: What Cascade Actually Does
Before mapping the mesh pattern, it helps to understand what Manus built.
Cascade is the new in-house agent harness. Its design principle is “light from the start, specialized capabilities only when the work needs them.” A project stays lean — the brief, the page, the video, and the automation remain part of one connected project — and Cascade brings in heavier capabilities dynamically as the task demands.
The efficiency gains are concrete. In one tested configuration, Cascade used 23.2% fewer tokens, finished tasks in 28.2% less time, and cost 32% less to run than the previous system. Those are not marginal wins. They are the kind of improvements that change what agent workloads become economically viable.
Cascade also expanded automation from scheduled execution to event-triggered workflows. A new email, a change in ad performance, a calendar event, a Slack message, a Notion update — any of these can now trigger a task. Tell Manus in a single prompt what to watch and what to do, and it sets up and runs the workflow.
Cue: Agents With Digital Identities
The Cue app is where multi-agent collaboration becomes literal. Each agent in Cue has:
- Its own email address — so it can send messages externally
- Its own phone number — so it can make and receive calls, leave call summaries
- Its own wallet — so it can pay within a user-set budget
- Its own virtual computer — so it can execute tasks on its own machine
This is the “digital identity” pattern. An agent is no longer a stateless function call. It is an autonomous entity with resources, permissions, and the ability to transact. When you put several such agents in a shared group chat with a shared goal, they hand work to one another: one researches, one shortlists, one drafts. The user stays in the loop as the final decision-maker.
This is the multi-agent collaboration era. And it is exactly the regime where service-mesh patterns become essential.
Why Multi-Agent Needs a Mesh
A service mesh exists to solve five problems that emerge whenever many independent programs must talk to each other reliably:
| Problem | What It Means in Microservices | What It Means in Agents |
|---|---|---|
| Discovery | Which service is where? | Which agent has which capability and is currently available? |
| Routing | Send this request to the right upstream | Send this subtask to the agent best suited to execute it |
| Load balancing | Spread traffic across replicas | Spread subtasks across agent instances, avoid overloading one |
| Circuit breaking | Stop calling a failing service | Stop delegating to an agent that is erroring or hallucinating |
| Observability | Trace every hop, measure latency | Trace every agent handoff, measure token cost and quality |
In microservices, the solution is a sidecar — a small proxy that sits next to every service instance, intercepts all its traffic, and applies these policies uniformly. Envoy is the canonical sidecar. When every service in an infrastructure routes its traffic through an Envoy sidecar, the result is an Envoy mesh: a uniform layer that handles discovery, routing, load balancing, circuit breaking, and observability without any service having to implement those concerns itself.
The multi-agent world is converging on the same shape. Here is why.
1. Agents Are Becoming Independent Services
In Cue, each agent has its own email, phone, wallet, and computer. That is the definition of an independent service. When one agent sends a subtask to another, it is a service-to-service call — and service-to-service calls need a mesh to be reliable.
2. Agent-to-Agent Communication Is Unreliable by Default
LLM agents hallucinate, loop, and fail in ways traditional services do not. A mesh layer between them can apply circuit breaking — if an agent has produced three consecutive failed responses, stop routing subtasks to it and fall back to another. This is exactly the pattern Envoy applies to a failing upstream microservice.
3. Agent Workflows Need Distributed Tracing
A single user prompt in Cue can trigger a chain of agent-to-agent handoffs across multiple specialized agents. When the final output is wrong, you need to know which agent in the chain introduced the error. This is distributed tracing — the same problem Envoy solves for microservices with tools like OpenTelemetry. The agent world is reinventing it from scratch. It does not need to.
4. Token Cost Is the New Latency
In microservices, latency is the metric you optimize. In agents, token cost is the metric you optimize. Cascade’s 23.2% token reduction is the equivalent of cutting p99 latency by 23% — a meaningful efficiency win that compounds across every request. A mesh layer can enforce token budgets per agent, per workflow, and per user — the same way a service mesh enforces rate limits and latency SLOs.
The EnvoyMesh-for-Agents Pattern
Mapping the convergence explicitly, here is what an EnvoyMesh-for-agents architecture looks like:
┌─────────────────────────┐
│ Orchestrator / Planner │
│ (Cascade-style harness) │
└────────────┬─────────────┘
│ delegates subtasks
┌────────────────────────────┼────────────────────────────┐
│ │ │
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ Agent A │ │ Agent B │ │ Agent C │
│ (researcher) │ │ (analyst) │ │ (drafter) │
│ │ │ │ │ │
│ ┌───────────┐ │ │ ┌───────────┐ │ │ ┌───────────┐ │
│ │ Sidecar │◄┼────────────┼─│ Sidecar │◄┼────────────┼─│ Sidecar │ │
│ │ (proxy) │ │ │ │ (proxy) │ │ │ │ (proxy) │ │
│ └─────┬─────┘ │ │ └─────┬─────┘ │ │ └─────┬─────┘ │
│ │ │ │ │ │ │ │ │
│ ▼ │ │ ▼ │ │ ▼ │
│ [Wallet] │ │ [Wallet] │ │ [Wallet] │
│ [Email] │ │ [Email] │ │ [Email] │
│ [VM] │ │ [VM] │ │ [VM] │
└───────────────┘ └───────────────┘ └───────────────┘
│ │ │
└────────────────────────────┼────────────────────────────┘
│
▼
┌─────────────────────────┐
│ Observability / Tracing │
│ Token-budget enforcement│
│ Circuit-breaking policy │
│ Reward-hacking guardrails │
└─────────────────────────┘
The sidecar intercepts every agent-to-agent call. It enforces:
- Discovery — which agents are available, which capabilities they advertise
- Routing — which agent should receive this subtask
- Circuit breaking — stop delegating to an agent whose last N outputs failed quality checks
- Token budgeting — cap per-agent and per-workflow token spend
- Tracing — record every handoff, the input, the output, the cost, the latency
- Guardrails — detect and block reward-hacking or agentic misbehavior patterns
None of these are exotic. They are exactly what Envoy does for microservices, re-cast for agents.
Why This Convergence Is Happening Now
Three things in 2026 make the EnvoyMesh-for-agents convergence imminent.
First, Envoy itself is going AI-native. The Envoy project now positions itself as “the engine behind modern infrastructure — the same battle-tested performance, reliability, and observability powering microservices, edge, and AI workloads alike.” Envoy AI Gateway is a first-class concern. Streaming LLM responses and agentic workloads are now in scope. The infrastructure is already moving.
Second, DeepSeek’s DSec paper formalized the agent-sandbox abstraction. DSec (DeepSeek Elastic Compute), published September 19, 2026, treats every agent execution environment — FnCall, container, microVM, full-VM — as a versioned, lifecycle-managed, resource-bounded unit. That is the same abstraction a service mesh applies to a service instance. DSec is, in effect, the agent-side counterpart to the mesh-side abstraction.
Third, multi-agent orchestration frameworks are converging on mesh-like primitives. Manus Cascade, OpenAI’s agent harness, and DeepSeek’s Harness Desktop all now implement some subset of: dynamic capability routing, token-budget enforcement, agent lifecycle management, and tracing. Each implements its own version. The natural next step is a unified layer — exactly the role Envoy plays for microservices.
What It Means for DeepThink
DeepThink’s reasoning engine is positioned to be the kernel of the agentic OS — the reasoning core that every agent, regardless of harness, embeds. That positioning matters for the mesh convergence in two ways.
1. The mesh is harness-agnostic. An EnvoyMesh-for-agents layer does not care whether an agent runs under Manus Cascade, DeepSeek Harness, or Microsoft Copilot’s shell. It sits between agents and applies uniform policy. That means DeepThink-powered agents can interoperate with agents on other harnesses, so long as both sides speak the mesh protocol.
2. The reasoning engine is the place where quality is enforced. A mesh can circuit-break a hallucinating agent, but it cannot make a weak model smarter. The reasoning engine underneath still determines the ceiling on output quality. DeepThink’s position — frontier-class reasoning at efficiency-tier cost — is what makes it the natural reasoning core for mesh-orchestrated multi-agent systems. A mesh of weak agents is still weak. A mesh of DeepThink-powered agents, each running V4.1 Flash, is something else entirely.
The Multi-Agent Era’s Infrastructure Question
Manus 2.0 made multi-agent collaboration a consumer feature. Cue lets you put agents in a group chat and watch them hand off work. That is the user-facing surface.
The infrastructure question underneath — how to make those handoffs reliable, observable, budgeted, and safe — is the question that will determine whether the multi-agent era scales beyond demos. The microservices world answered that question a decade ago with the service mesh. The agent world is about to answer it the same way.
EnvoyMesh for agents is not a prediction. It is the natural shape of the problem. The agents are already becoming services. The services already need a mesh. The mesh already exists. The only thing left is the integration — and that integration is the most important infrastructure bet of 2027.