AI Agent Ecosystem W29: Control Plane Divergence as Mozilla Otari, Google Genkit Agents, and Vercel Eve Reshape the Infrastructure Layer While Code Graph MCPs Attack the Token Cost Spiral

TL;DR: Three distinct control plane architectures for AI agent infrastructure emerged simultaneously in July 2026 — gateway-centric (Mozilla Otari), framework-centric (Google Genkit Agents), and sandbox-centric (Vercel Eve) — each solving a different production failure mode. Meanwhile, Code Graph MCP tools are achieving 8-120x token reduction by pre-indexing codebases into persistent knowledge graphs, and a longitudinal study of 802 developers reveals that while AI coding throughput has reached 2.09x, the review bottleneck has become the new structural constraint.

Executive Summary

The week of July 7-13, 2026, saw an unprecedented density of agent infrastructure releases: five or more major announcements in three days, signaling that the market has reached a critical mass where vendors must ship or risk being locked out of the emerging standard. But the most significant structural change is not the volume of releases — it is the architectural divergence within the control plane layer itself.

Mozilla’s Otari, Google’s Genkit Agents, and Vercel’s Eve represent three fundamentally different philosophies for managing agent infrastructure. Otari positions itself as a gateway-centric control plane that sits between applications and LLM providers, managing routing, budgets, and governance. Genkit Agents takes a framework-centric approach, packaging the entire agent lifecycle — sessions, streaming, persistence, human approval — into a single application primitive. Eve adopts a sandbox-centric model, using filesystem conventions and isolated execution environments to enforce data control and audit compliance.

This divergence is the opposite of the consolidation pattern that W28 identified for agent frameworks. Rather than converging on a dominant architecture, the control plane layer is splitting into specialized camps, each optimized for a different slice of the production reliability problem. Enterprise adopters face a new decision: which failure mode matters most, and which architecture addresses it?

Simultaneously, a new category of Code Graph MCP tools — Skeletree, code-review-graph, and Codebase-Memory — is attacking the token cost spiral from a different angle. Rather than throttling token consumption at the runtime layer (as CLRK/Restate flow control does), these tools reduce context at the source by pre-indexing codebases into persistent knowledge graphs that agents query instead of reading entire files. The claimed reductions range from 8x to 120x, and early benchmarks suggest real but architecture-dependent savings.

The 2x throughput longitudinal study from arXiv (802 developers, 196,212 PRs, 28 months) validates the production shift that both control planes and Code Graphs are responding to. Per-capita throughput reached 2.09x — but per-reviewer load also roughly doubled, and automated review overtook human review. The bottleneck has moved from generation to review, and infrastructure must now address review throughput, not just generation speed.

Background

Last week’s W28 analysis identified three structural shifts: framework consolidation, protocol convergence, and the emergence of the gateway control plane as a distinct infrastructure layer. The gateway control plane — exemplified by CLRK/Restate’s flow control for agent runtime management — was positioned as the next layer to mature after frameworks and protocols.

W29 reveals that the control plane layer is maturing, but not through convergence. Instead, it is diverging into three architectural camps, each with a different mental model for what “control” means in the context of agent infrastructure. This divergence is healthy — it means the market is exploring the solution space rather than locking into a premature standard — but it creates a new challenge for enterprise adopters who must now evaluate not just which product to use, but which architectural philosophy aligns with their production failure modes.

The timing is significant. July 7-9 saw five major agent infrastructure releases in three days: SnapLogic MCP Builder GA, JetBrains AI for Teams, Harness Autonomous Worker Agents, IBM Bob multi-agent with Bobalytics, and Couchbase AI Data Plane. This density signals that the market has reached an inflection point where the question is no longer “should we build agent infrastructure?” but “which architecture should we adopt?”

Analysis

Control Plane Divergence: Three Camps, Three Failure Modes

The three control plane architectures that emerged this week are not competing implementations of the same design — they are fundamentally different approaches to the same problem, each optimized for a different production failure mode.

Gateway-Centric: Mozilla Otari

Mozilla.ai launched Otari on July 6 as an open-source LLM control plane. Otari sits between applications and LLM providers, providing a single layer for routing, budgets, governance, deployment, and reliability. Its key differentiator is the explicit distinction between a “gateway” and a “control plane”: a gateway handles execution and connectivity with static routing and post-call token tallying; a control plane handles policy and decision-making with dynamic routing, pre-request budget enforcement, and global policy across all applications.

Otari’s architecture addresses the cost governance and provider reliability failure mode. When an organization runs multiple LLM providers across multiple applications, the operational complexity of managing routing logic, API keys, usage tracking, budget enforcement, and failover independently for each application becomes unsustainable. Otari centralizes these concerns into a dedicated control plane that sits between the application and the provider.

The Agent Harnesses feature is particularly notable — it provides built-in tools and orchestration for building agent-ready applications, positioning Otari not just as a passive gateway but as an active agent infrastructure layer. The open-source strategy (Python 98.4%, v0.2.0, 333 commits on GitHub) challenges proprietary gateways like Portkey and Helicone with a community-driven alternative.

Framework-Centric: Google Genkit Agents

Google shipped the Genkit Agents API in preview on July 1, taking a fundamentally different approach. Rather than sitting between applications and providers, Genkit Agents packages the entire agent lifecycle into a single application primitive. The chat() interface abstracts away message history, tool loops, streaming, session persistence, and HTTP serving — everything a conversational AI feature needs, behind one API.

Genkit’s architecture addresses the developer experience and full-stack integration failure mode. When a team needs to build a conversational AI feature — a support assistant, an approval workflow, a task copilot — the plumbing of message history, tool execution loops, streaming updates, session persistence, and frontend wire protocols repeats on every project. Genkit eliminates this repetition by packaging it all into a framework-level primitive.

Google’s positioning is instructive: Genkit is for “adding agentic features to existing apps,” while the Agent Development Kit (ADK) is for “complex standalone multi-agent systems.” This distinction maps to the framework-centric vs. platform-centric divide — Genkit embeds agents into applications, while ADK builds applications out of agents.

The Agents API supports sessions with custom state and artifacts, streaming of text and state patches and tool interruptions, persistence through session stores, human approval workflows, and HTTP serving with route helpers. The remoteAgent() client provides the same chat() interface for both local and remote agents, eliminating the need to design separate request/response protocols.

Sandbox-Centric: Vercel Eve

Vercel’s Eve, announced at the Ship conference on June 17 and detailed in an enterprise security deep-dive on July 6, takes yet another approach. Eve is filesystem-first: an agent is a directory of files, a tool is one TypeScript file, and a skill is one Markdown file. The filesystem is the authoring interface, and Vercel’s cloud services power the backend.

Eve’s architecture addresses the data isolation and audit compliance failure mode. When agents execute code and access data in production, the risk of unauthorized access, data exfiltration, and compliance violations becomes the primary concern. Eve addresses this through sandboxed code execution — each agent runs in an isolated environment (Docker locally, Vercel Sandbox in production) with strict data-access policies and audit trails.

The durable execution model is a key differentiator: each conversation is stored as a durable workflow that can pause, survive failures or deployments, and resume from the last completed step. This makes Eve particularly suited for long-running autonomous tasks where reliability is critical. The Apache 2.0 license makes the framework itself free, while Vercel’s orchestration, state management, and sandbox features cost $20/month.

Vercel’s scale gives Eve credibility: the platform processes over 6 million daily deployments and more than 1 trillion AI tokens per day through its gateway. Half of those deployments are now driven by AI coding agents.

Architecture Comparison Matrix

Dimension	Otari (Gateway)	Genkit Agents (Framework)	Eve (Sandbox)
Primary failure mode	Cost governance, provider reliability	Developer experience, full-stack integration	Data isolation, audit compliance
Control mechanism	Policy-driven routing, pre-request budgets	Framework-level abstraction, session management	Filesystem conventions, sandbox isolation
Position in stack	Between app and provider	Inside the application	Around the agent
Agent model	Agent Harnesses (tools + orchestration)	Application primitive (chat() interface)	Filesystem directory (convention over config)
Open source	Yes (Python, v0.2.0)	Yes (TypeScript/Go, Beta)	Yes (Apache 2.0, paid add-ons)
Best for	Multi-provider cost management	Conversational AI features	Long-running autonomous tasks
Weakness	No application-level primitives	No cross-app policy layer	Vercel ecosystem dependency

Code Graph MCPs: The Context Optimization Layer

While control planes manage token consumption at the routing and budget layer, a new category of tools is attacking the problem at the source: Code Graph MCPs that pre-index codebases into persistent knowledge graphs, allowing agents to query only what they need instead of reading entire files.

This is a complementary approach to the runtime flow control that W28 identified (CLRK/Restate). Flow control throttles token consumption at the execution layer; Code Graphs reduce the tokens that need to be consumed in the first place. Together, they address the token cost spiral from both ends.

code-review-graph provides local-first code intelligence through MCP and CLI, achieving 8.2x average context reduction with 22-87% savings across different prompt types. It offers 30 MCP tools and has added context_savings estimates (v2.3.4) and tokenizer cross-checking (v2.3.5) for verified savings measurement.

Codebase-Memory (arXiv 2603.27277) uses Tree-Sitter to parse 66 languages into persistent knowledge graphs. Evaluated across 31 real-world repositories, it achieves 83% answer quality versus 92% for a file-exploration agent — a 9 percentage point quality trade-off — but at 10x fewer tokens and 2.1x fewer tool calls. The multi-phase pipeline includes parallel worker pools, call-graph traversal, impact analysis, and community discovery.

Skeletree takes a different architectural approach, leveraging the TypeScript compiler’s type information for precise code navigation. By using the compiler rather than Tree-Sitter, it gains deeper semantic understanding of TypeScript codebases but sacrifices the multi-language breadth that Tree-Sitter provides.

codebase-memory-mcp (DeusData) claims 99% token reduction with millisecond indexing across 158 languages, exposed through 14 MCP tools. The claim is aggressive, and independent verification is needed, but the architecture — static binary, high-speed indexing, comprehensive language support — addresses the practical deployment concerns that limit adoption of more academic approaches.

Code Graph MCP Benchmark Comparison

Tool	Architecture	Languages	Token Reduction	Answer Quality	MCP Tools
code-review-graph	Multi-language graph	257	8.2x avg (22-87%)	Not reported	30
Codebase-Memory	Tree-Sitter	66	10x fewer tokens	83% (vs 92% baseline)	14+
Skeletree	TypeScript compiler	TypeScript only	Significant (claimed)	Not reported	Not reported
codebase-memory-mcp	Static binary	158	99% (claimed)	Not reported	14

The key architectural trade-off is language depth vs. breadth: TypeScript-compiler-based tools (Skeletree) gain deeper semantic understanding for one language, while Tree-Sitter-based tools (Codebase-Memory) cover more languages with shallower analysis. The multi-language graph approach (code-review-graph) prioritizes breadth and tool count over per-language depth.

The 2x Throughput Paradox: Review Bottleneck as Structural Constraint

The arXiv paper “AI Writes Faster Than Humans Can Review” (2607.01904) provides the most rigorous longitudinal evidence to date on the impact of AI coding tools in an enterprise setting. The study tracked 802 developers and 196,212 pull requests from January 2024 to April 2026 at a mid-sized B2B software company that publicly committed to a “2x mandate” in June 2025.

The headline finding — per-capita throughput reached 2.09x the pre-mandate baseline in April 2026 — is among the largest gains reported from a field deployment of AI coding tools. But the structural finding is more important: adoption restructured code review around automation. Per-reviewer load roughly doubled, and automated review overtook human review in volume, while merge and revert rates held steady.

This means the bottleneck has shifted from code generation to code review. AI can write code faster than humans can review it, and the organization compensated by automating review — but automated review is not a substitute for human review with different failure modes. The merge and revert rates holding steady suggests that automated review is maintaining quality, but the per-reviewer load doubling suggests that human reviewers are being squeezed.

The implications for infrastructure are direct:

1. Control planes must address review throughput, not just generation throughput. Otari’s budget enforcement, Genkit’s human approval workflows, and Eve’s audit trails all touch review, but none is optimized for it.

2. Code Graph MCPs may accelerate review as well as generation. If a reviewer can query a persistent code graph instead of reading entire files, review throughput could increase proportionally to generation throughput.

3. The 180% code output vs. 30% shipping gap (Forbes, June 2026) is a review bottleneck problem, not a generation problem. More code is being written than can be reviewed and integrated, and the gap will widen until infrastructure addresses review specifically.

The study also found that the gain is “broadly shared across seniority yet concentrated in newer code and not separable across model generations.” This suggests that the throughput improvement comes from AI adoption patterns rather than model capability jumps — a finding that has implications for how organizations should invest in AI tooling.

MCP Tooling Democratization: Closing the Server Gap

The MCP protocol has achieved broad adoption as the standard for agent-tool communication, but a persistent gap exists between protocol adoption and practical tool availability. Building MCP servers requires specialized knowledge, and most enterprise integrations are not yet exposed as MCP tools.

SnapLogic MCP Builder GA, released on July 7, addresses this gap directly. The template-based capability automatically converts existing integration pipelines into agent-ready MCP tools, making SnapLogic’s 1000+ existing Snap connectors accessible to AI agents without custom MCP server development. This is a significant bridge: instead of building new MCP-native tools, enterprises can expose their existing integration investments to agents.

The pattern extends beyond SnapLogic. RainFocus launched MCP Profiles with enterprise-grade OAuth security for event data, providing per-event scoping, OAuth-secured authentication, and bidirectional actions. Perforce Intelligence added an MCP-agnostic agentic gateway. JetBrains AI for Teams supports both MCP and the Agent Client Protocol (ACP) for vendor-agnostic agent orchestration.

The common thread: existing enterprise integration vendors are adding MCP as an output format rather than building new MCP-native tools. This dramatically expands the available tool surface for agents without requiring enterprises to rebuild their integration infrastructure.

Enterprise Release Wave: What Five Releases in Three Days Signals

The density of agent infrastructure releases from July 7-9 is unprecedented:

• SnapLogic MCP Builder GA (Jul 7): Auto-converts integration pipelines to MCP tools
• JetBrains AI for Teams (Jul 7): Vendor-agnostic agentic development with MCP + ACP
• Harness Autonomous Worker Agents (Jul 7): After-code DevOps automation
• IBM Bob multi-agent + Bobalytics (Jul 9): Multi-agent coordination with cost analytics
• Couchbase AI Data Plane (Jul 8): Unified data infrastructure for agent workloads

This density signals three things:

1. The market has reached critical mass. Vendors are shipping now because the window for establishing a position in the agent infrastructure stack is closing. The MCP protocol has provided enough standardization that vendors can build on a shared foundation.

2. The stack is layering. Each release occupies a different layer: SnapLogic at the tool/integration layer, JetBrains at the IDE/development layer, Harness at the DevOps/delivery layer, IBM at the orchestration/coordination layer, Couchbase at the data/persistence layer. The agent infrastructure stack is becoming as layered as the web stack.

3. Enterprise readiness is the differentiator. Every release emphasizes governance, security, observability, or cost management — not agent capability. The market has moved past “can agents do things?” to “can agents do things safely and at scale?”

Data Points

Metric	Value	Source	Date
Otari version	v0.2.0	GitHub (mozilla-ai/otari)	2026-07-03
Vercel daily deployments	6M+	Vercel/TechCrunch	2026-07-06
Vercel daily AI tokens	1T+	Vercel/SaaS Rise	2026-07-06
code-review-graph context reduction	8.2x avg	code-review-graph.com	2026-07
Codebase-Memory token reduction	10x fewer tokens	arXiv 2603.27277	2026-03
Codebase-Memory answer quality	83% (vs 92% baseline)	arXiv 2603.27277	2026-03
Enterprise 2x throughput	2.09x	arXiv 2607.01904	2026-07
Per-reviewer load change	~2x	arXiv 2607.01904	2026-07
AI code output vs shipping gap	180% vs 30%	Forbes	2026-06
SnapLogic connectors	1000+	SnapLogic	2026-07-07
Genkit Agents API status	Beta (TypeScript + Go)	Google Developers Blog	2026-07-01
Eve license	Apache 2.0 ($20/mo add-ons)	Vercel	2026-06-17

🔺 Scout Intel: What Others Missed

Confidence: high | Novelty Score: 82/100

The control plane divergence is not fragmentation — it is specialization. Each architecture solves a different production failure mode, and enterprise adopters will likely need multiple layers rather than choosing one. The real insight: Code Graph MCPs represent a new “context optimization” layer that reduces the load on all three control plane architectures by cutting token consumption at the source. The 2x throughput study’s review bottleneck finding connects all three threads — control planes must address review throughput, Code Graphs can accelerate review, and the 180%-vs-30% output-shipping gap is a review problem, not a generation problem. The next infrastructure innovation will be review-specific: tools that make human review of AI-generated code as fast as AI generation itself.

Key implication for engineering leaders: Evaluate control plane architectures against your dominant failure mode (cost governance → Otari, developer experience → Genkit, data isolation → Eve), and invest in Code Graph MCPs as a complementary layer that reduces the load on whichever control plane you choose. The review bottleneck is your next scaling constraint.

Outlook

Short-term (3-6 months)

The control plane divergence will intensify before any convergence signals appear. Expect at least two more gateway-centric entrants (likely from cloud providers) and one more sandbox-centric framework. Code Graph MCP tools will consolidate around two or three dominant implementations as benchmarks mature. The MCP tooling democratization pattern (existing integrations adding MCP as output format) will accelerate as SnapLogic’s approach proves viable.

Medium-term (6-18 months)

A “review infrastructure” category will emerge, combining elements of control planes (approval workflows, audit trails) with Code Graph context optimization (faster review through pre-indexed codebases). The 2x throughput study will be replicated at larger scale, and the review bottleneck will become the dominant narrative in AI coding productivity. Expect at least one major cloud provider to launch a review-specific agent infrastructure product.

Long-term (18+ months)

The agent infrastructure stack will stabilize into distinct layers: context optimization (Code Graphs), control plane (gateway/framework/sandbox), orchestration (multi-agent coordination), and data (persistence/memory). The current divergence is the market exploring the solution space; convergence will come through standardization at the protocol layer (MCP, A2A) rather than at the architecture layer. Enterprise adopters who invest in protocol-compatible tools rather than architecture-specific platforms will have the most flexibility as the stack matures.

Sources

• Mozilla.ai: Introducing Otari, the Open-Source LLM Control Plane
• Mozilla.ai: What is an LLM Control Plane?
• Mozilla.ai Otari Product Page
• Google Developers Blog: Build Agentic Full-Stack Apps with Genkit
• Genkit Docs: Full-Stack Agents
• InfoQ: Google Introduces Middleware Architecture for Genkit Applications
• InfoQ: Vercel Introduces Eve, an Open-Source Framework for Building AI Agents
• Techstrong.ai: Vercel Eve, a Filesystem-First Framework for Building Agents
• Vercel Eve Documentation
• SaaS Rise: Vercel CEO Charts Path to Split AI Models from Deployment Agents
• code-review-graph: Local Code Intelligence for MCP
• arXiv: Codebase-Memory (2603.27277)
• arXiv: AI Writes Faster Than Humans Can Review (2607.01904)
• Forbes: AI Coding Agents Write 180% More Code But Ship Only 30% More Software
• DEVOPSdigest: IBM Bob Updated with Multi-Agent Capabilities
• InfoWorld: JetBrains to Roll Out AI Capabilities for Software Development Teams
• Deepsense.ai: The 5 Control Planes of Agentic AI Infrastructure
• Google AX: Distributed Agent Runtime
• AlphaSignal: Google’s Genkit Ships Agents API