All 20 Criteria
P1-A Structured Data — 0/5
No evidence of schema.org markup, JSON-LD, or Organization/Product/Offer schema on letta.com. Homepage is a marketing site with no detectable structured data. robots.txt references a sitemap but contains no signals of schema implementation. Search result queries for Letta + schema.org returned no relevant results.
P1-B Machine-Readable Pricing — 3/5
Letta's pricing page is functional and detailed, with clean HTML tiers: Free (base), Pro ($20/mo, up to 20 stateful agents), Max Lite ($100/mo, 50 agents), Max ($200/mo, personal use only), and API Plan ($20/mo base + $0.10/active agent/mo + $0.00015/sec tool execution). Per-unit costs are explicit. However, no schema.org Offer markup or JSON pricing structure — pricing is human-readable HTML only, not machine-tagged.
P1-C llms.txt / Agent Layer — 0/5
No /llms.txt found at letta.com/llms.txt (404). No agent-facing identity layer or LLM-readable overview document at the root domain. Letta's docs are extensive but not surfaced in an LLM-consumable index format.
P1-D API / MCP Availability — 5/5
Letta has a full REST API (docs.letta.com/api/), Python SDK, TypeScript SDK, and native MCP support with three transport types (Streamable HTTP recommended, SSE for backward compatibility, stdio for local dev). MCP server management is exposed via API endpoints (list_mcp_servers, add_mcp_server). A community-built MCP server for Letta itself exists (oculairmedia/Letta-MCP-server) with 28 agent operations, 24 memory operations, and 13 tool operations. This is among the strongest API/MCP postures audited to date.
P1-E Discoverability (GEO) — 3/5
Strong GitHub presence (letta-ai/letta), developer documentation, active blog (stateful-agents, AI agents stack), and citations in AI agent directories and developer communities. Some AI retrieval optimization via developer content, but no structured GEO-specific content or AI answer engine optimization detected.
P2-A Offer Completeness — 4/5
Pricing page clearly states what is included in each tier, agent limits, model quota differences, and overage pricing. The API Plan explicitly breaks out per-unit costs ($0.10/active agent/mo, $0.00015/sec tool execution). An AI agent evaluating Letta's costs could derive a reasonable estimate from the pricing page alone. Loses 1 point because "usage quota for open-weights models and Letta Auto" is not quantified — the specific quota amounts are absent.
P2-B Scope & Limits — 3/5
Agent count limits per tier are explicit (20, 50, unlimited). Tool execution costs per second are stated. Built-in tools are labeled as free. Remote MCP tools noted as free (executed externally). However, no explicit rate limits for API calls, no documented request-per-second caps, and no clear ceiling on memory block storage.
P2-C Substitution & Fallback Rules — 0/5
No documented guidance on what happens when the Letta Cloud service is unavailable. No SLA fallback, no compensation policy, no documented failover behavior. The self-hosted Docker option exists as an implicit fallback but is not framed as a formal substitution path.
P2-D Conditional Logic Transparency — 3/5
Most pricing conditions are visible and stated on the pricing page (Max plan is "limited to personal use only" — explicitly stated). No "contact sales" obscuring for main tiers. Loses 2 points because model quota amounts are undisclosed, and "pay-as-you-go for additional models/overage" lacks explicit overage rates.
P2-E Semantic Precision — 4/5
Language is notably precise: "Up to 20 stateful agents," "$0.10/active agent/mo," "$0.00015/sec tool execution," "Streamable HTTP (recommended): Supports auth headers." Product descriptions use technical terminology accurately. Minor vagueness: "usage quota" without a number, and "early access to new features" is undefined. No "best-in-class" or similar hollow claims detected.
P3-A Verifiable Performance Data — 0/5
No public status page confirmed (no status.letta.com found). No third-party verified uptime data (no G2, Trustpilot, or Capterra reviews found). No published SLA with uptime guarantees. While Letta is backed by Felicis Ventures (seed funding confirmed), no verifiable operational performance data is publicly available.
P3-B Scoped Permission Model — 3/5
Per-agent credential management exists: templated variable syntax (e.g., `{{USER_API_KEY | default_key}}`) allows per-agent scoped authentication for MCP tools. API key authentication is standard. Agent-specific tool permissions can be configured. Loses 2 points because there are no time-bounded keys, no amount-capped access, and no formal agent-scoped permission roles documented at the platform level.
P3-C Audit Trail / Transaction Log — 2/5
All agent state (memories, messages, reasoning, tool calls) is persisted in a database and accessible via REST API. Developers can inspect full agent history. However, this is a history of what agents HAVE done — not a machine-accessible audit log in the traditional transactional sense. No formal logging API for compliance, no structured audit trail export for external agent systems evaluating Letta as a vendor.
P3-D Behavioral Consistency Signals — 1/5
Letta is open-source (GitHub) with visible version history for the SDK and framework. However, no formal SLA, no documented change notice period, no published API versioning policy, and no deprecation timeline for current APIs. The cloud platform's behavioral consistency is entirely undocumented. Open-source transparency helps but is not a substitute for cloud platform commitments.
P4-A Friction-Free Activation — 3/5
The API Plan ($20/mo) is the primary programmatic access path, requiring a credit card and account creation. Python SDK (`pip install letta-client`) is available. The platform has a quickstart guide (docs.letta.com/quickstart/). Activation is self-serve with no sales call required — lower friction than enterprise tools. Loses 2 points because unlike AgentOps, there is no instant API key without a payment method, and the free tier is a personal-use product, not an API-accessible trial.
P4-B Agent Decision Signals — 3/5
Per-agent pricing ($0.10/active agent/mo) creates a directly agent-legible cost signal — an autonomous agent managing infrastructure can calculate costs proportionally to deployment scale. Free vs paid tier distinction provides a clear signal for when to upgrade. Loses 2 points because there are no explicit programmatic threshold alerts (e.g., "you've reached 80% of your agent quota") accessible via API, and no agent-readable signal for when compounding memory value has been achieved.
P5-A Integration Depth / Switching Cost — 4/5
Letta agents accumulate memory blocks (in-context), archival memory (long-term storage), and recall memory (message history) — all persisted in Letta's database. MCP tool integrations, per-agent credentials, and skills (dynamically loaded) create meaningful operational depth. Switching away from Letta means migrating all agent memory state. The community MCP server exposing 65 operations creates additional integration surface. Loses 1 point because memory is portable by design (Letta explicitly supports cross-model and cross-machine agent migration).
P5-B Agent Memory / Personalization Layer — 5/5
This is Letta's core offering and its strongest signal. The platform is purpose-built as an agent memory infrastructure: persistent memory blocks (in-context), archival memory (searchable long-term), recall memory (full conversation history), and background memory subagents that continuously optimize prompts and context. Memory is API-accessible, agent-editable, and persists across model providers. White-box memory design means agents can directly read and modify their own memory state. This is the highest possible score — Letta IS the agent memory layer.
P5-C Programmatic Renewal Signals — 1/5
The API Plan's per-agent billing ($0.10/active agent/mo) suggests automatic billing scaling as agents are added, which is a weak programmatic renewal signal. However, no documented agent-accessible renewal API, no programmatic billing management endpoints, and no autonomous upgrade/downgrade capability was found.
P5-D Compounding Value Signal — 4/5
Compounding value is explicit and central to Letta's product: agents learn over time via background memory subagents that continuously improve prompts, context, and skills. The Letta Filesystem enables agents to build and reference growing content libraries. Agent memory improves with every interaction. These are agent-visible compounding signals — an agent can directly observe and leverage its own accumulated memory. Loses 1 point because there is no agent-readable API endpoint or metric that quantifies "memory richness" or "accumulated value" over time.
Rubric v1 (April 2026). Scores reflect the company's state on the audit date and may have improved since.