White paper · Mentat
Why Every Agentic Framework Hits a Ceiling.
Every agentic framework solves the same problem — and hits the same wall. The moment you need agents that improve over time, grow into new responsibilities, and teach each other, the data model underneath gives out. This is the argument for building on a graph instead.
The Problem
Every agentic AI framework today solves the same problem: "How do I get an LLM to use tools and follow instructions?" LangGraph gives you workflow graphs. CrewAI gives you role-playing agents. AutoGen gives you multi-agent conversations. OpenAI's Agents SDK gives you handoffs and guardrails.
They all work. For simple agents.
But when you try to build agents that improve over time, that grow into new responsibilities, that teach each other — every framework hits the same wall. They weren't designed for it. Their data model can't support it. And bolting it on after the fact creates the kind of architectural debt that makes senior engineers quit.
"We built Mentat because we hit that wall ourselves."
The field, March 2026
The Landscape
Seven frameworks define the field today. Each is strong somewhere — and each shares the same blind spot. Read each on three axes: what it does well, where it falls short, and how it's built.
LangGraph · LangChain
34.5M downloads / moWhat it does wellState machine workflows with checkpointing. The most mature framework with the largest ecosystem. If you need a directed graph of operations with persistent state, LangGraph is solid.
Where it falls short"Graph" means workflow graph, not knowledge graph. Memory is serialized state snapshots — checkpoint blobs that capture what happened, not why or how things relate. No concept of agent identity, growth, or specialization. Every agent starts from zero on every deployment. And there's a documented SQL injection vulnerability in the SQLite checkpoint implementation.
ArchitectureNodes are functions, edges are transitions. State is immutable and checkpointed. Compile-time graph definition.
CrewAI
45.9K GitHub starsWhat it does wellRole-based metaphor that's intuitive for non-technical stakeholders. "Here's a Researcher, a Writer, and a Reviewer working together." Native MCP support.
Where it falls shortMemory is broken in production. ChromaDB locking errors under concurrent access. EnhanceLongTermMemory and LTMSQLiteStorage have implementation bugs — they don't work as documented. No per-user memory isolation. Machine-local storage loses data on redeploy. Python-only.
ArchitectureCrews (teams) + Flows (event-driven orchestration). Built from scratch, no LangChain dependency.
AutoGen · Microsoft
What it does wellActor-model multi-agent communication. Strong research foundation. Good for code execution with Docker sandboxing.
Where it falls shortMemory is the biggest weakness — message lists only, no built-in persistence. Being merged into Microsoft Agent Framework, creating uncertainty about its standalone future. The v0.4 rewrite broke backward compatibility with the large v0.2 ecosystem.
ArchitectureActor model with asynchronous message passing. Three-layer design: Core, AgentChat, Extensions.
OpenAI Agents SDK
What it does wellClean handoff protocol. Built-in guardrails — input/output validation running in parallel with agent execution. Deliberately simple: five primitives only.
Where it falls shortOpenAI-first. No built-in planning for long-horizon tasks. Memory summarization loses subtle constraints ("context poisoning"). Deliberately minimal — you build everything beyond the five primitives yourself. No graph-based data modeling.
ArchitectureFive primitives: Agents, Handoffs, Guardrails, Sessions, Tracing.
Claude Agent SDK · Anthropic
What it does wellMCP-native. Rich built-in toolset. Context management with compaction. Strong developer experience.
Where it falls shortClaude-only — locked to Anthropic models. All agents run the same model. Subagent limit of 3–4 before coordination overhead dominates. No built-in persistent memory. Multi-agent "Swarms" is experimental (feature flag, not officially released).
ArchitectureAgent harness around Claude. Host / Client / Server MCP pattern.
Mastra
22.3K GitHub starsWhat it does wellTypeScript-first — the only major framework that leads with TS. Created by the Gatsby team. Four pillars: Agents, Workflows, RAG, Memory.
Where it falls shortNewer framework with fewer enterprise references. Model support has rough edges (Gemini compatibility issues). Durability semantics weaker than LangGraph. Multi-agent orchestration less mature. No graph-based knowledge store.
ArchitectureModular composition of AI primitives. Workflow DAGs with agent nodes.
Semantic Kernel · Microsoft
What it does wellEnterprise .NET integration. Plugin system for reusable function packages. Strong Azure ecosystem.
Where it falls short.NET-first with feature gaps in the Python/Java SDKs. Heavy abstractions complicate debugging. Being merged into Microsoft Agent Framework. Not suited for startups or indie developers.
ArchitecturePlugin-based orchestration with AI planners.
Eleven capabilities, eight frameworks
The Comparison
The same eleven capability questions, asked of all seven frameworks and Mentat. The rightmost column is the payoff.
| Capability | LangGraph | CrewAI | AutoGen | OpenAI SDK | Claude SDK | Mastra | Mentat |
|---|---|---|---|---|---|---|---|
| Data layer | Checkpoints | ChromaDB (broken) | Message lists | Sessions (SQLite) | File system | Basic DB | Graph DB (all data) |
| Agent growth | None | None | None | None | None | None | Trust → promote → spawn → mentor |
| Memory model | Serialized state | Vector + SQLite | Chat history | Summarization | Context window | Conversation DB | Edges ARE relationships |
| Multi-agent | Static graph edges | Role-based crews | Message passing | Handoff protocol | Subagents (3–4) | Workflow DAGs | Graph-scored coordination + delegation |
| Classification | Developer-defined | Developer-defined | Developer-defined | Developer-defined | Developer-defined | Developer-defined | Graph-driven LLM + keyword fallback |
| Guardrails | None | None | None | I/O validation | None | None | Behavioral (graph) + runtime (code) |
| Multimodal | Text-first | Text-first | Text + code | Text-first | Vision via API | Text + RAG | ContentPart[] everywhere |
| Training data | External (LangSmith) | External | External | External | External | External | Auto-generated + exportable |
| Per-request isolation | Immutable state (overhead) | Broken (ChromaDB locks) | Not addressed | Not addressed | Not addressed | Not addressed | Prototype clone pattern |
| Model selection | Manual | Manual | Manual | OpenAI only | Claude only | Provider config | Per-agent with A/B testing |
| TypeScript | Secondary | None (Python) | Secondary (.NET) | Secondary (Python) | Both | Primary | Primary |
Every cell except the Mentat column describes a documented limitation or a "build-it-yourself" gap. The pattern is the argument.
The core of the argument
What Mentat Actually Does Differently
The Graph IS the Operating System
Every framework treats data storage as someone else's problem. "Use LangSmith for tracing." "Bring your own vector store for memory." "Checkpoint to SQLite." Mentat stores everything in a graph database:
This isn't a preference. It's a structural advantage. When you ask "which agent is best for this task?", Mentat runs a multi-factor graph query that scores agents by pattern match, capability coverage, effectiveness history, and availability — in one query. Every other framework requires you to build and maintain that scoring infrastructure yourself.
Agents That Grow
In every other framework, an agent is a static configuration. It has the same capabilities on day 1 as it does on day 1,000. To improve it, you retrain the model, rewrite the prompts, or add more tools. Mentat agents have careers:
Trust is computed from five signals: correction rate, user satisfaction, task success rate, complexity handled, and mentorship effectiveness. The system promotes agents automatically when trust crosses thresholds. Senior promotions trigger junior spawning — the framework uses an LLM to generate the junior's identity and synthesize mentorship wisdom from the senior's correction history.
This isn't a gimmick. It solves a real problem: as your system handles more users and more task types, you need more specialized agents. Instead of manually configuring each one, the system grows them.
The Self-Improving Loop
Every message that flows through Mentat generates training data as a side effect:
Prompt Snapshots — SHA-256 deduped. Every response links to the exact prompt that produced it.
Context Versions — full configuration snapshot per message (model, tools, guardrails, brand).
Classification Decisions — every routing decision stored with method, confidence, and prompt used.
This means:
No framework generates training data. They all expect you to build a pipeline for it. Mentat builds the pipeline into the framework.
Dual Guardrails
OpenAI's Agents SDK has guardrails — input/output validation functions that run in parallel with the agent. If the guardrail triggers, the response is blocked. Mentat has two types:
Injected into the agent's system prompt as constraints. "Never share internal ticket IDs." "Cannot access external APIs without tools." They shape behavior rather than catching bad output.
Functions registered on brains. They validate input (before the LLM call) or output (after generation, before the user sees it). They can block, warn, or redact.
The combination means behavioral guardrails prevent most violations by constraining the agent's thinking, and runtime guardrails catch what slips through. No parallel racing — output guardrails run on complete content before content.done, so partial responses never leak past the filter.
Multimodal-First
Most frameworks treat multimodal as an afterthought: content: string with an optional attachments array. Images are pre-analyzed into text descriptions before the agent sees them. Mentat uses ContentPart[] as the universal unit. Messages, responses, tool results, and stream chunks are all typed content arrays. An image from a screenshot tool feeds directly to the LLM as an image part — no pre-analysis needed if the model supports vision.
If the model doesn't support vision, a ContentPreprocessor pipeline handles it automatically (OCR, transcription, compression). If no preprocessor is available, the content degrades gracefully with a typed event so the client knows.
This matters because agents are increasingly multimodal. A tool that screenshots a webpage should return an image, not a text description of an image. A tool that generates a chart should return the chart, not a summary.
Honest positioning
When NOT to Use Mentat
The honest part of the argument. Mentat is the wrong tool more often than the marketing of most frameworks would ever admit.
You need a single agent with no persistence. Use the OpenAI SDK or call the API directly. Mentat's graph layer is overhead you don't need.
You're still prototyping your agent architecture. Use LangGraph — its workflow graph lets you iterate on structure fast. Come to Mentat when you know what you're building and need it to grow.
You need 50+ out-of-box tool integrations. CrewAI and LangChain have the ecosystem. Mentat is bring-your-own-tools — it provides the orchestration, not the integrations.
You're building in Python or .NET. Mentat is TypeScript-first. There's no Python SDK.
The request lifecycle
Architecture at a Glance
One request, end to end. Every node on this path reads from and writes to the same graph.
How to get in
Getting Started
Mentat isn't a public install yet. A one-line npm install mentat is on the way — but right now the way in is a conversation. We're working directly with a small number of teams building agents that need to grow, and we'll get you running against a real graph.
# public package — coming soon $ npm install mentat # until then, get started by reaching out ↓
Tell us what you're building and where your current framework is hitting the wall. We'll walk you through the architecture, share the quickstart, and set you up with early access.
Built by the team behind Ziggy. Extracted from a production system handling real agent orchestration, not a weekend hackathon.