Letta · Controlled Vocabulary

letta-vocabulary

Domain vocabulary for Letta — the stateful AI agents platform (formerly MemGPT). Captures the canonical nouns, verbs, classifications, and operational dimensions used across the Letta API, ADE (Agent Development Environment), Letta Code, and the open-source Letta server.

25 Terms 2 Groups 1 With Aliases Updated 2026-05-22
View Vocabulary File View on GitHub

Letta Vocabulary is a controlled vocabulary published by Letta on the APIs.io network, defining 25 terms.

The terms are organized into 2 groups — entities and concepts.

Defined terms include Agent, Memory Block, Archive, Passage, and Source.

1 term carry alternate labels, so a consumer can resolve the synonyms Letta accepts to the canonical term.

A controlled vocabulary pins the words an API’s schemas, parameters and documentation use to one agreed definition each — the shared language a human or an agent needs to read the API the same way its authors do.

Term Groups

entities 16 concepts 9

Terms

Agent agent
A stateful AI agent with persistent memory, tools, and a deterministic step-loop. Every conversation, tool call, and memory edit is anchored to a specific agent record.
MemGPT agentstateful agent
Memory Block block
A labeled, character-limited chunk of in-context "core" memory (e.g., `persona`, `human`). Blocks are first-class objects and can be shared across agents to coordinate multi-agent state.
Archive archive
A long-term archival memory store. Agents read/write Passages here when core memory is too small. Powers RAG-style recall over historical conversations and ingested Sources.
Passage passage
An individual chunk of archival memory — a vector-indexed snippet retrievable by semantic search.
Source source
A document ingestion surface (file, URL, dataset). Uploaded files are chunked into Passages and attached to agent archives for RAG.
Tool tool
A callable function an agent can invoke. Three execution modes — `sandboxed` (Letta-hosted Python), `client-side` (your app executes), and `MCP` (delegated to a registered MCP server).
MCP Server mcp_server
A registered external Model Context Protocol server. Letta consumes its tools and lets agents invoke them as first-class tools without owning the execution.
Group group
A multi-agent collective. Manager configs include `supervisor`, `round_robin`, `dynamic`, and `sleep_time`. Groups can share memory blocks for collective state.
Identity identity
A mapping between an external end-user and per-user agents and memory contexts. Lets one Letta deployment serve many distinct users with isolated state.
Run run
One agent execution — the trace from a user message through tool calls, memory edits, and the final assistant reply. Bounded by step count and token usage.
Job job
A long-running background task (e.g., source file ingestion, agent export).
Message message
A single utterance — user, assistant, system, reasoning, tool_call, or tool_return — inside a run or conversation history.
Scheduled Message scheduled_message
A one-time or cron-recurring message that drives an agent at a future time without a human in the loop.
LLM Config llm_config
Per-agent language model selection — endpoint type, model name, context window, temperature, max tokens.
Embedding Config embedding_config
Per-agent embedding model selection — dimensionality and endpoint.
Provider provider
An LLM provider credential record — OpenAI, Anthropic, Azure, Google AI, Ollama, vLLM, etc. Letta routes model calls through these.
Stateful Agent stateful_agent
An agent whose identity persists across runs — its memory, tools, and configuration outlive any single LLM context window. Differentiator vs. stateless agent frameworks.
Sleep-Time Agent sleep_time_agent
A background agent that shares memory with primary agents and runs asynchronously to clean, consolidate, and rewrite their memory. Enabled via `enable_sleeptime: true`.
MemGPT memgpt
The original 2023 academic paper / project that introduced virtual-context-management for LLM agents. Letta is the production framework that grew out of MemGPT.
Agent File (.af) agent_file
Open file format for serializing a stateful agent (memory + tools + config) for export, sharing, version control, and migration between self-hosted and cloud. Repo: github.com/letta-ai/agent-file.
Agent Development Environment (ADE) ade
Letta's web UI for inspecting an agent's context window, memory blocks, archival memory, tool calls, and run history — "the ADE bridges the gap between development and deployment, providing complete transparency, state control, rapid prototyping, and robust debugging."
Letta Code letta_code
Letta's memory-first coding agent (CLI + desktop app) — analogous to Claude Code but with persistent agent memory and skill learning.
Continual Learning continual_learning
Letta's framing for agents that improve over time by rewriting their own memory and adding learned skills, rather than being fine-tuned.
Context Constitution context_constitution
A Letta primitive (Apr 2026) defining invariants and policies the agent must respect when editing its own memory and context.
Skills skills
Reusable agent capabilities packaged for sharing across Letta Code, Claude Code, Codex CLI, and other agents. Repo: github.com/letta-ai/skills.

Controlled Vocabulary

Raw ↑
vocabulary: "0.1"
name: letta-vocabulary
title: Letta Vocabulary
description: >-
  Domain vocabulary for Letta — the stateful AI agents platform (formerly MemGPT).
  Captures the canonical nouns, verbs, classifications, and operational dimensions
  used across the Letta API, ADE (Agent Development Environment), Letta Code,
  and the open-source Letta server.
source:
  openapi: openapi/letta-openapi.json
  docs: https://docs.letta.com/
  github: https://github.com/letta-ai/letta
modified: "2026-05-22"

# --- Core nouns (Letta domain entities) ---
entities:
  - id: agent
    label: Agent
    definition: >-
      A stateful AI agent with persistent memory, tools, and a deterministic
      step-loop. Every conversation, tool call, and memory edit is anchored to
      a specific agent record.
    schema: json-schema/letta-agent-schema.json
    synonyms: [MemGPT agent, stateful agent]

  - id: block
    label: Memory Block
    definition: >-
      A labeled, character-limited chunk of in-context "core" memory
      (e.g., `persona`, `human`). Blocks are first-class objects and can be
      shared across agents to coordinate multi-agent state.
    schema: json-schema/letta-block-schema.json

  - id: archive
    label: Archive
    definition: >-
      A long-term archival memory store. Agents read/write Passages here when
      core memory is too small. Powers RAG-style recall over historical
      conversations and ingested Sources.
    schema: json-schema/letta-archive-schema.json

  - id: passage
    label: Passage
    definition: >-
      An individual chunk of archival memory — a vector-indexed snippet
      retrievable by semantic search.
    schema: json-schema/letta-passage-schema.json

  - id: source
    label: Source
    definition: >-
      A document ingestion surface (file, URL, dataset). Uploaded files are
      chunked into Passages and attached to agent archives for RAG.
    schema: json-schema/letta-source-schema.json

  - id: tool
    label: Tool
    definition: >-
      A callable function an agent can invoke. Three execution modes —
      `sandboxed` (Letta-hosted Python), `client-side` (your app executes),
      and `MCP` (delegated to a registered MCP server).
    schema: json-schema/letta-tool-schema.json

  - id: mcp_server
    label: MCP Server
    definition: >-
      A registered external Model Context Protocol server. Letta consumes its
      tools and lets agents invoke them as first-class tools without owning
      the execution.
    transports: [streamable_http, sse, stdio]

  - id: group
    label: Group
    definition: >-
      A multi-agent collective. Manager configs include `supervisor`,
      `round_robin`, `dynamic`, and `sleep_time`. Groups can share memory
      blocks for collective state.
    schema: json-schema/letta-group-schema.json

  - id: identity
    label: Identity
    definition: >-
      A mapping between an external end-user and per-user agents and memory
      contexts. Lets one Letta deployment serve many distinct users with
      isolated state.
    schema: json-schema/letta-identity-schema.json

  - id: run
    label: Run
    definition: >-
      One agent execution — the trace from a user message through tool calls,
      memory edits, and the final assistant reply. Bounded by step count and
      token usage.
    schema: json-schema/letta-run-schema.json

  - id: job
    label: Job
    definition: >-
      A long-running background task (e.g., source file ingestion, agent
      export).
    schema: json-schema/letta-job-schema.json

  - id: message
    label: Message
    definition: >-
      A single utterance — user, assistant, system, reasoning, tool_call,
      or tool_return — inside a run or conversation history.
    schema: json-schema/letta-message-schema.json
    message_types: [user_message, assistant_message, reasoning_message, tool_call_message, tool_return_message, system_message]

  - id: scheduled_message
    label: Scheduled Message
    definition: >-
      A one-time or cron-recurring message that drives an agent at a future
      time without a human in the loop.

  - id: llm_config
    label: LLM Config
    definition: >-
      Per-agent language model selection — endpoint type, model name,
      context window, temperature, max tokens.
    schema: json-schema/letta-llm-config-schema.json

  - id: embedding_config
    label: Embedding Config
    definition: >-
      Per-agent embedding model selection — dimensionality and endpoint.
    schema: json-schema/letta-embedding-config-schema.json

  - id: provider
    label: Provider
    definition: >-
      An LLM provider credential record — OpenAI, Anthropic, Azure, Google
      AI, Ollama, vLLM, etc. Letta routes model calls through these.
    schema: json-schema/letta-provider-schema.json

# --- Concepts (Letta-specific patterns) ---
concepts:
  - id: stateful_agent
    label: Stateful Agent
    definition: >-
      An agent whose identity persists across runs — its memory, tools, and
      configuration outlive any single LLM context window. Differentiator
      vs. stateless agent frameworks.

  - id: sleep_time_agent
    label: Sleep-Time Agent
    definition: >-
      A background agent that shares memory with primary agents and runs
      asynchronously to clean, consolidate, and rewrite their memory. Enabled
      via `enable_sleeptime: true`.

  - id: memgpt
    label: MemGPT
    definition: >-
      The original 2023 academic paper / project that introduced
      virtual-context-management for LLM agents. Letta is the production
      framework that grew out of MemGPT.

  - id: agent_file
    label: Agent File (.af)
    definition: >-
      Open file format for serializing a stateful agent (memory + tools +
      config) for export, sharing, version control, and migration between
      self-hosted and cloud. Repo: github.com/letta-ai/agent-file.

  - id: ade
    label: Agent Development Environment (ADE)
    definition: >-
      Letta's web UI for inspecting an agent's context window, memory blocks,
      archival memory, tool calls, and run history — "the ADE bridges the gap
      between development and deployment, providing complete transparency,
      state control, rapid prototyping, and robust debugging."

  - id: letta_code
    label: Letta Code
    definition: >-
      Letta's memory-first coding agent (CLI + desktop app) — analogous to
      Claude Code but with persistent agent memory and skill learning.

  - id: continual_learning
    label: Continual Learning
    definition: >-
      Letta's framing for agents that improve over time by rewriting their
      own memory and adding learned skills, rather than being fine-tuned.

  - id: context_constitution
    label: Context Constitution
    definition: >-
      A Letta primitive (Apr 2026) defining invariants and policies the
      agent must respect when editing its own memory and context.

  - id: skills
    label: Skills
    definition: >-
      Reusable agent capabilities packaged for sharing across Letta Code,
      Claude Code, Codex CLI, and other agents. Repo: github.com/letta-ai/skills.

# --- Operational dimensions ---
dimensions:
  deployment:
    - cloud
    - self_hosted
  pricing_meters:
    - per_active_agent_per_month
    - per_second_tool_execution
    - llm_passthrough_tokens
  manager_types:
    - supervisor
    - round_robin
    - dynamic
    - sleep_time
  agent_types:
    - memgpt_agent
    - split_thread_agent
    - sleeptime_agent
    - workflow_agent
  mcp_transports:
    - streamable_http
    - sse
    - stdio
  run_statuses:
    - queued
    - running
    - completed
    - failed
    - cancelled

# --- Cross-reference vocabularies ---
crossReferences:
  - vocab: schema.org
    mappings:
      Agent: schema:SoftwareApplication
      Tool: schema:Action
      Source: schema:DataDownload
      Message: schema:Message
  - vocab: Naftiko
    mappings:
      capability: capabilities/letta-*.yaml
      mcpServer: letta:MCPServer

Work with this as data

Every vocabulary here is available over the APIs.io API and to AI agents over MCP. Vocabularies is not yet its own endpoint on the v1 API. Reach it through catalog search and the tag graph, or the MCP server.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for vocabularies

3 MCP tools reach this
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
Search the catalog
curl "https://apis.io/api/v1/search?q=letta-vocabulary&limit=10"
Everything under a tag
curl "https://apis.io/api/v1/tags/letta-vocabulary"

Calls without X-API-Key need no key. Calls with it need a paid plan — get a key.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. By signing up you are subscribing to the APIs.io and API Evangelist newsletters — you can unsubscribe from any issue. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.