Agentic Index
Letta vs Zep (2026)
Both vendors last verified
Choose Zep for a temporal knowledge graph memory service behind your existing agents. That verdict is the Agentic Index coverage score, graded from each vendor's own published materials.
Choose Letta for a stateful agent platform where memory persistence is built into the runtime. Zep offers a free tier with 10,000 credits a month and Flex from $125 a month, while Letta has a free tier, a $20 Pro plan, an API plan billed by usage on top of $20, and free self hosting. Zep's graph tracks how facts change over time, which suits assistants grounded in evolving user data, and Letta suits teams betting on stateful agents as the architecture.
On the Agentic Index agent infrastructure ranking, neither Letta nor Zep clears the bar, which asks for all five production contract capabilities documented in full. Letta documents two of the five in full; Zep does not document testing, debugging and optimization in full, nor observability and auditability. 33 of the 186 vendors in the lane clear it. See the agent infrastructure ranking
This comparison is published by Agentic Index, an independent agentic AI vendor research platform. Letta and Zep are each graded against the same 14 capability Agentic Index taxonomy, from the vendor's own public materials under the Agentic Index verification standard, alongside 1,165 researched vendors. No vendor pays for placement and no vendor has reviewed this page. How this evidence is graded
Choose Letta if
- You want the whole agent lifecycle, including memory, in one open source runtime
- Editing and inspecting agent memory directly is part of your workflow
- A $20 a month entry point for hands on use fits early experimentation
Choose Zep if
- Facts about your users change over time and your memory layer must model that
- You want a managed memory service with a knowledge graph, not a new runtime
- Keeping your current framework while upgrading recall is the goal
| Feature | L Letta |
Z Zep |
|---|---|---|
| Action & orchestration | ||
|
Integrations & Tool Calling Ability to connect agents to real systems through native integrations, OAuth-authenticated actions, custom tools, APIs, webhooks, or MCP-compatible tools. |
||
|
LettaIntegrations & Tool Calling Agents connect to stdio, HTTP and SSE MCP servers, take controller-owned external tools registered on the App Server, use reusable skills, and reach GitHub repositories and Slack through native integrations. SourceLetta, docs.letta.com/agent-sdk/mcp and self-hosting/app-server/external-toolsread 2026-09-21 |
||
|
ZepIntegrations & Tool Calling Zep plugs into agent frameworks and exposes an agent tool for retrieving from a Context Graph, with webhooks notifying other systems of memory events and a Memory MCP Server for MCP clients. These connect Zep to agents, but Zep does not give agents authenticated read and write actions in outside systems. SourceZep, help.getzep.com concepts and memory-for-agent-frameworksread 2026-09-21 |
||
|
Workflow Orchestration Ability to sequence, branch, retry, route, and combine deterministic workflow nodes with autonomous agent steps. |
||
|
LettaWorkflow Orchestration Agents delegate to specialized subagents for task breakdown and parallel execution, agents in an organization communicate and collaborate, and agents share memory files backed by Git, so work runs across several steps and agents. SourceLetta, docs.letta.com/configuration/subagents, concepts/shared-memory and pricingread 2026-09-21 |
||
|
ZepWorkflow Orchestration Agents query Zep as a memory and context layer. Zep does not orchestrate agent workflows, sequencing or branching itself. Sourcegetzep.comread 2026-09-21 |
||
|
Triggers & Channel Coverage How agents wake up and where they work: schedules, webhooks, message events, CRM events, inbox events, chat, email, voice, and collaboration tools. |
||
|
LettaTriggers & Channel Coverage Schedules send one time or recurring prompts, such as daily briefings or hourly triage, without anyone asking, and agents can create their own schedules. Agents also run as Slack, Discord, Telegram, WhatsApp and Signal bots and through a GitHub action. SourceLetta, docs.letta.com/configuration/schedules and self-hosting/channelsread 2026-09-21 |
||
|
ZepTriggers & Channel Coverage Webhooks fire on memory events. Zep has no agent invocation, scheduling or conversational channels of its own. Sourcegetzep.comread 2026-09-21 |
||
| Knowledge & context | ||
|
Knowledge Grounding & RAG Ability to ground agent behavior in company data through document ingestion, retrieval, external knowledge APIs, semantic search, or RAG layers. |
||
|
LettaKnowledge Grounding & RAG Agents read the customer's files on the computers they run on and the GitHub repositories they are given access to, so knowledge comes in through tools on each run. There is no document index or retrieval store over the customer's knowledge apart from the agent's own memory. SourceLetta, docs.letta.com/platform/cloud-agents/github and platform/computersread 2026-09-21 |
||
|
ZepKnowledge Grounding & RAG Standalone Context Graphs store up to date knowledge about an object or system, separate from per user memory. Business data, JSON and document chunks are added with graph.add and grouped by document. Zep turns them into entities and temporal facts that are invalidated when superseded, and agents retrieve them with graph.search or as an agent tool. The graph over the customer's knowledge is maintained, persists, refreshes as new data arrives and stays queryable. SourceZep, help.getzep.com/conceptsread 2026-09-21 |
||
|
Memory & State Persistence Ability to persist context across a run, conversation, workflow, user, team, or longer-term memory layer. |
||
|
LettaMemory & State Persistence Each agent keeps memory blocks and MemFS, a Git versioned memory filesystem it reads, writes and reorganizes itself. Memory is shared across all of that agent's conversations and optionally with other agents, and background dreaming reflects on it and improves it. SourceLetta, docs.letta.com/concepts/memfs and configuration/memoryread 2026-09-21 |
||
|
ZepMemory & State Persistence Each application user has a user graph and thread history. Messages added to any of that user's threads are ingested into a temporal Context Graph of entities and facts. When new data supersedes a fact, Zep marks the time it became invalid, and it generates user summaries on the customer's instructions. Memory belongs to one user, and each fact carries the window of time in which it held true. SourceZep, help.getzep.com/conceptsread 2026-09-21 |
||
| Control & trust | ||
|
Human Oversight & Guardrails Approval steps, consent checkpoints, escalation rules, structured guardrails, policy constraints, and pause/resume controls. |
||
|
LettaHuman Oversight & Guardrails Permissions give allowlist and approval controls over which tools an agent may run, and the Agent SDK exposes permission modes with interactive tool approvals, so a person approves a gated call before it executes. SourceLetta, docs.letta.com/configuration/permissions and agent-sdk/permissionsread 2026-09-21 |
||
|
ZepHuman Oversight & Guardrails The product stores and retrieves memory. It offers no human review, approval workflow or content guardrails. Sourcegetzep.comread 2026-09-21 |
||
|
Security, Identity & Governance RBAC, SSO, auditability, encryption, least-privilege tool access, compliance posture, and data handling policy. |
||
|
LettaSecurity, Identity & Governance Organization permissions control who can access agents and conversations, alongside API key authentication, secrets storage, and role based access control with SAML or OIDC SSO on Enterprise. Letta publishes no attestation, certification or trust center. SourceLetta, docs.letta.com/pricing and teams/permissionsread 2026-09-21 |
||
|
ZepSecurity, Identity & Governance Controls and live status for Zep's SOC 2 Type II certification sit on its Trust Center. Enterprise adds a HIPAA BAA and a year of audit logs. Customers can bring their own encryption keys, and governance controls cover account management and agents' access to context. Some of these controls are available only on Enterprise. SourceZep, getzep.com/pricing and help.getzep.com/conceptsread 2026-09-21 |
||
|
Observability & Auditability Traces, logs, execution histories, metrics, audit events, and debugging detail for production agent behavior. |
||
|
LettaObservability & Auditability Each turn streams the agent's reasoning, assistant messages, tool calls and results for inspection, and MemFS keeps a Git history of every memory change. There is no audit log separate from runtime traces, trace export or retention by plan. SourceLetta, docs.letta.com/agent-sdk/messages and concepts/memfsread 2026-09-21 |
||
|
ZepObservability & Auditability API logs are kept for a day on Flex, seven days on Flex Plus and a year on Enterprise. Enterprise adds audit logs and Flex Plus adds analytics. A time limited debug mode captures per episode workflow logs and reasoning traces for Zep's own ingestion steps. These logs cover calls to Zep and Zep's own processing, not the steps an agent took or the tools it called during a run. SourceZep, getzep.com/pricing and help.getzep.com/conceptsread 2026-09-21 |
||
|
Deployment & Data Residency Deployment modes and options, including SaaS, dedicated cloud, VPC, on-prem, hybrid, local runtime, and self-hosting. |
||
|
LettaDeployment & Data Residency Letta runs fully locally or on the customer's own infrastructure through a self hosted App Server, with no Letta account required. Agents can also run in Letta managed cloud sandboxes or on the customer's own laptop, workstation or cloud VM. SourceLetta, docs.letta.com/self-hosting and platform/computersread 2026-09-21 |
||
|
ZepDeployment & Data Residency Zep runs as a managed cloud, as the managed cloud with the customer's own encryption keys, or on Enterprise as a BYOC deployment inside the customer's own VPC on AWS, GCP or Azure. The open source Graphiti engine can also be self hosted. SourceZep, getzep.com/pricing and github.com/getzep/graphitiread 2026-09-21 |
||
| Solution readiness | ||
|
Prebuilt Agents, Templates & Packs Ready-made workflows, packaged employees, templates, blueprints, industry solutions, and role-specific agents that reduce time-to-value. |
||
|
LettaPrebuilt Agents, Templates & Packs Letta's site hosts a catalog of 22 installable Mods, official and community, each with a letta install command, alongside bundled skills, and Letta ships Letta Agent as a ready agent through the app and CLI. Sourceletta.com mod catalogread 2026-10-25 |
||
|
ZepPrebuilt Agents, Templates & Packs Customers can configure custom entity and edge types and extraction instructions. Zep offers no prebuilt agents, templates or installable packs. Sourcegetzep.comread 2026-09-21 |
||
| Platform extensibility | ||
|
Model Flexibility & Routing Ability to work across multiple foundation models, route tasks to different models, or let buyers bring their own providers and keys. |
||
|
LettaModel Flexibility & Routing The customer connects model providers with their own keys or coding plans and switches an agent's model at any time, with Letta Auto as an optional routed choice, so model choice sits with the customer. SourceLetta, docs.letta.com/configuration/models and pricingread 2026-09-21 |
||
|
ZepModel Flexibility & Routing The open-source Graphiti engine behind Zep runs on the LLM and embedding providers and keys the customer configures, so the customer controls which model builds and queries the graph. Zep itself is not a model routing gateway. SourceZep, github.com/getzep/graphiti and help.getzep.com Graphiti docs (indexed in llms.txt)read 2026-09-21 |
||
|
APIs, SDKs & MCP Extensibility Composability layer: stable APIs, SDKs, MCP tool consumption/serving, custom tools, and integration into internal systems. |
||
|
LettaAPIs, SDKs & MCP Extensibility The Letta Agent SDK embeds stateful agents in the customer's own applications, with a published reference. The App Server has a WebSocket protocol and remote client API, the API plan gives API key access for automated workloads, and agents connect to editors over the Agent Client Protocol. SourceLetta, docs.letta.com/agent-sdk, self-hosting/app-server and pricingread 2026-09-21 |
||
|
ZepAPIs, SDKs & MCP Extensibility Python, TypeScript and Go SDKs over Zep's API add messages and business data, search graphs and retrieve user context. A Memory MCP Server comes with seats per plan, webhooks are available, and the Graphiti engine is open source. SourceZep, help.getzep.com concepts and sdk-reference, and getzep.com/pricingread 2026-09-21 |
||
|
Testing, Debugging & Optimization Testing, debugging, scoring, retries, fallbacks, quality gates, and optimization loops for improving agent workflows before and after deployment. |
||
|
LettaTesting, Debugging & Optimization Letta documents an evaluation harness for Letta Cloud agents, with datasets, rubric and tool graders, and pass or fail gates that set the exit code. Every page of it is marked legacy, and none appears in the current docs index. Sourcedocs.letta.com/v1-sdk/evalsread 2026-10-25 |
||
|
ZepTesting, Debugging & Optimization A research paper from Zep publishes memory retrieval benchmarks. Zep offers no product for customers to test, debug or optimize their agents. Sourcearxiv.org/abs/2501.13956read 2026-09-21 |
||
| Specialist automation | ||
|
Browser & Computer Use Browser, desktop, or remote/local computer control for workflows that cannot be handled through stable APIs alone. |
||
|
LettaBrowser & Computer Use An agent's computer is a Letta cloud sandbox or the customer's own machine, where it runs code and handles files. The 0.31.8 changelog lists a built in browser-use skill. What that skill controls, and how, is not described in the docs. Sourcedocs.letta.com reference/changelogread 2026-10-25 |
||
|
ZepBrowser & Computer Use As a memory and knowledge graph layer, Zep provides no browser automation or computer use. Sourcegetzep.comread 2026-09-21 |
||
Pricing snapshot
Sourced from the Index pricing dataset · open each vendor's profile for full detail.
| Pricing | L Letta |
Z Zep |
|---|---|---|
|
Entry price Lowest public entry point |
Pro at $20/mo, and the API plan at $20/mo plus usage. A free tier exists, Enterprise is custom, and self hosting is free. | Free (10,000 credits/mo) · Flex $125/mo · Flex Plus $375/mo · Enterprise custom |
|
Pricing confidence How public the numbers are |
Public, exact | Public, exact |
|
Billing Primary billing axis |
Usage on top of flat monthly plans. Pro and Teams Pro, the latter per seat, carry a Letta Auto quota with pay as you go overage beyond it, and the API plan bills per active agent, per second of tool execution and for model usage. | Subscription tiers plus credits consumed by data ingestion (1 credit per Episode up to 350 bytes, +1 per additional 350 bytes); retrieval, storage, threads, users, and graph storage consume zero credits |
|
Variable cost Workload / overage exposure |
High variable cost | Low variable cost |
|
Free tier / trial Try before you buy |
Free tier
|
Free tier
|
|
Buying motion Self-serve vs sales call |
Mixed | Self-serve |
|
Pricing verified When this pricing was last checked |
Product updates
Newest first, each linked to its source.
Letta
-
· Agent capability
Agents running apps inside a Letta Code sandbox can now expose those apps' ports, so a service the agent starts can be reached from outside the sandbox.
Source -
· Workflow orchestration
Letta Code v0.34.40 extends its subagents with one setting that picks the runner for each subagent, either Letta or an outside coding worker such as Claude Code or Codex.
Source -
· Observability / auditability
Every subagent task in Letta Code v0.34.38 now writes a full JSONL event log, including tasks run by remote workers on connected computers.
Source
Zep
-
· Security / enterprise
Zep accounts can now have their Members and Groups provisioned from an identity provider over SCIM, with each identity provider group mapped to a Zep role.
Source -
· MCP / tool calling / API
Zep's v4 API is generally available, with v4.0.0 SDKs for Python, TypeScript and Go, and v4 is now the default documentation.
Source
More comparisons with Letta or Zep
Other matchups in agent infrastructure platforms
Not the pairing you were after? These compare a different set of agent infrastructure platforms on the same 14 capabilities.