Building AI-Native: Inside the Stacks Powering Cognition, Gamma, and Harvey

Key Takeaways

• Multi-agent is the default, not the exception — All three teams run hierarchical agent systems in production; single-agent flows are the exception for complex tasks
• MCP in production requires careful scope design — The teams agree MCP is powerful but require disciplined tool scoping to avoid context explosion
• Failure handling is the hardest part — Graceful degradation, retry logic, and partial-completion semantics are where most production complexity lives
• Evaluation before deployment is non-negotiable — All three teams have eval pipelines; none would ship a model update without clearing them
• Different domains, different trust models — Harvey (legal) operates with much stricter output verification than Gamma (creative); the trust model shapes architecture
• Context isolation matters at scale — Cognition's lesson: don't let agents share context unless you explicitly want bleedthrough; default to isolation

Summary

Cognition's Architecture

Cognition runs a hierarchical agent system for Devin where a planning agent breaks down tasks, dispatches to execution agents, and a verification agent checks outputs before they're accepted. The key design decision was context isolation — execution agents don't share context with each other, only with the planner via structured messages. This prevents task bleedthrough and makes failures attributable.

Gamma's Creative Stack

Gamma uses Claude for end-to-end presentation generation — from brief to finished deck. Their architecture is less hierarchical and more pipeline-oriented: a planning pass produces a structured outline, a content pass fills it in, a design pass applies visual logic. MCP integrates their design token system so Claude has access to brand constraints during generation rather than as a post-processing step.

Harvey's Legal Stack

Harvey operates in legal — high-stakes, output-verified, every claim needs attribution. Their multi-agent system uses a research agent (retrieval and synthesis), a drafting agent (structured legal writing), and a review agent (checking for unsupported claims, jurisdictional accuracy, formatting compliance). The trust model is strict: no output ships without the review agent's sign-off.

MCP in Production

All three teams have MCP in production, and all three have opinions about where it shines and where it struggles. The consensus: MCP is excellent for giving agents access to structured external systems (databases, APIs, design tokens) but requires careful tool scope design. An agent with 50 tools doesn't perform better than one with 10 well-chosen tools — it performs worse, because the model spends context deciding which tool to use.

The Lessons

In the final segment, each team names their biggest architectural regret and the decision they'd repeat. Cognition's regret: not building context isolation into the base layer from day one. Harvey's regret: building custom orchestration before trying the Managed Agents layer. Gamma's repeat: designing their eval pipeline before their production stack, not after.

Notable Quotes

"The hardest part of multi-agent isn't the routing. It's the failure handling. What does your product do when one agent in a five-agent chain returns something that doesn't parse?"

"MCP doesn't make tools free. Every tool you give an agent is context you're spending. Scope tightly."

"We built our eval suite before we had a product. Seemed wasteful at the time. Best decision we made."

Companies Featured