Context Constitution

Type: ../types/agent-memory-system-review.md · Status: current

Context Constitution, from letta-ai, is an authored policy repository for Letta agents rather than an executable memory system. At the reviewed commit it contains a README, the Constitution, an affordances document, license/editor metadata, and a trailing-whitespace GitHub Actions check. The repository describes Letta's intended context-management doctrine and Letta Code affordances, but it does not implement MemFS, message search, compaction, subagents, prompt mutation, or model training inside this checkout.

Repository: https://github.com/letta-ai/context-constitution

Reviewed commit: 0f0a23b66c262f41ce7e060a4da628dc983fb24f

Last checked: 2026-06-04

Core Ideas

The central artifact is doctrine for agent self-management. The README says the Constitution is a set of principles for how agents manage context and is used internally as a foundation of prompting and for training memory-native models, while CONSTITUTION.md is written directly to Letta agents as behavioral guidance (README.md, constitution/CONSTITUTION.md). That makes the repository primarily a system-definition artifact: it shapes future agent behavior through instruction when a host loads it.

The memory theory is token-space learning. The Constitution frames durable agent learning as active curation of context outside model weights: system prompts, messages, tools, skills, indexes, summaries, and external memory are the surfaces an agent can manage to create identity, memory, continuity, and future improvement (constitution/CONSTITUTION.md). This is a strong conceptual match to deploy-time learning, but in this checkout it is a prescription, not an implemented learning loop.

Progressive disclosure is the strongest operational principle. The Constitution tells agents to keep compact summaries or indexes always available, then load skills, files, retrieved records, or message history on demand; the affordances file says skill metadata, external-memory metadata, message counts, and a memory-filesystem tree are present in the system prompt, while full external memory must be retrieved by reading files or searching message history (constitution/CONSTITUTION.md, constitution/AFFORDANCES.md).

The documented Letta Code affordances are outside the implementation boundary. AFFORDANCES.md describes a git-versioned memory filesystem, /system in-context memory, external memory files, agent-scoped skills, automatically stored/indexed messages, multiple conversations, compaction summaries, and recall/reflection/defragmentation subagents (constitution/AFFORDANCES.md). The repository contains no code for those mechanisms, so this review treats them as documented host requirements and affordances, not verified deployed behavior.

The only executable behavior in this checkout is repository hygiene. The GitHub Actions workflow checks Markdown files for trailing whitespace on pushes and pull requests (.github/workflows/check-whitespace.yml). That validation supports maintainability of the policy text, but it does not validate memory quality, prompt effects, retrieval, or learning.

Artifact analysis

  • Storage substrate: files — The primary retained behavior-shaping state is authored Markdown in a GitHub repository; secondary substrates are only described in prose, including Letta memory blocks, MemFS projections, message databases, and model-training use.
  • Representational form: prose symbolic — The Constitution and affordances are prose instructions and principles; repository paths, Markdown headings, /system, /skills, references, Git commits, and the whitespace workflow are symbolic structure. I found no parametric artifact in this checkout.
  • Lineage: authored — The repository's reviewed artifacts are human-authored public documents and a simple CI workflow. The docs discuss experience-derived memory, message history, reflection, and training use, but this checkout does not derive durable artifacts from agent traces.
  • Behavioral authority: instruction validation knowledge — The Constitution has instruction authority when loaded into prompting or agent guidance; the whitespace workflow has narrow validation authority over Markdown formatting; the README and affordances document also serve as knowledge artifacts for humans or agents learning the Letta context model.

Constitution document. Storage substrate: repository file constitution/CONSTITUTION.md. Representational form: prose with a hierarchical section structure. Lineage: authored doctrine. Behavioral authority: instruction when used in prompting, and knowledge when read as a public explanation of Letta's memory philosophy.

Affordances document. Storage substrate: repository file constitution/AFFORDANCES.md. Representational form: prose plus symbolic path and capability names such as /system, /skills, memory filesystem, conversations, compaction, and subagents. Lineage: authored description of host mechanisms. Behavioral authority: instruction and routing advice for an agent that has those affordances available; implementation authority is not visible in this repository.

README and contribution surface. Storage substrate: repository README and GitHub issues. Representational form: prose source identity, mission framing, links, license, and feedback channel. Lineage: authored public framing. Behavioral authority: knowledge for reviewers and prospective adopters; weaker than the Constitution itself.

Whitespace workflow. Storage substrate: GitHub Actions YAML. Representational form: symbolic CI rule. Lineage: authored repository governance. Behavioral authority: validation for Markdown formatting only.

Promotion path: the documented Letta design wants a path from raw experience to memory blocks, prompt updates, indexes, compaction summaries, and reflection outputs. This repository does not implement that path. The only implemented promotion visible here is ordinary Git history turning edited Markdown into versioned public doctrine.

Comparison with Our System

Dimension Context Constitution Commonplace
Primary purpose Agent-facing doctrine for context self-management Git-native methodology KB for agent-operated knowledge bases
Canonical artifact Authored Markdown constitution and affordances Typed Markdown artifacts with collection/type contracts
Source of truth Public repository text plus Letta-internal usage not visible here Repository artifacts, generated indexes, review reports, and validation
Write path Manual document edits in this checkout Authored edits plus snapshots, validation, review gates, and generated indexes
Read-back Host-loaded or manually read doctrine; documented MemFS read-back not implemented here Mostly explicit pull through search, indexes, links, skills, and loaded instructions
Governance Whitespace CI and public issue feedback Frontmatter/type validation, link checks, semantic review, git diffs, citations

Context Constitution is closer to Commonplace than many runtime memory products because it treats text artifacts as the core behavior-shaping surface. The difference is operational maturity: Commonplace gives files types, collection contracts, validation, link semantics, and review workflows, while this repository is a compact policy corpus with only formatting validation.

The strongest conceptual overlap is progressive disclosure. Letta's docs describe always-available metadata plus on-demand loading of full skills, files, and message history. Commonplace uses a similar economy through descriptions, indexes, links, and skills, but keeps the mechanics in inspectable repo conventions rather than relying on an unreviewed host harness.

The sharpest tradeoff is authority. Letta's Constitution explicitly asks agents to edit their own identity and prompt context. Commonplace is more conservative: agents can write notes and instructions, but behavioral authority usually flows through typed artifacts, validation, semantic gates, and human-inspectable diffs before becoming durable system guidance.

Borrowable Ideas

Treat self-managed context as an explicit constitution. Ready as a writing pattern. Commonplace could benefit from a short agent-facing policy that states what should belong in always-loaded instructions, in skills, in notes, and in temporary work.

Separate in-context memory from external memory by path semantics. Needs a concrete Commonplace use case. Letta's /system versus external MemFS split is a clear operator model; Commonplace could mirror it with stronger conventions for always-loaded instructions versus library artifacts.

Use indexes as paths of discovery, not just directories. Ready now. The Constitution's emphasis on references that let future agents rediscover deeper material supports Commonplace's link and index discipline.

Make reflection/defragmentation roles explicit. Needs a governed workflow. The documented subagent roles map well to Commonplace review, connect, and rewrite tasks, but should remain tied to validation and evidence rather than free-form self-editing.

Do not borrow selfhood rhetoric as a substitute for artifact governance. Ready as a constraint. The repository's language motivates agents to own memory, but Commonplace still needs source lineage, type contracts, and review gates before behavior-shaping context should gain authority.

Write side

Write agency: manual — In this checkout the durable store changes by authored edits to Markdown and workflow files. The docs describe agent self-modification, prompt learning, compaction, message storage, reflection, and defragmentation, but no automatic write or curation mechanism is implemented in the repository.

Read-back

Read-back: pull — For the reviewed repository itself, the retained documents re-enter future action when a human, agent, prompt builder, or downstream harness deliberately reads or loads them. The README reports that Letta uses the Constitution as prompting foundation, and AFFORDANCES.md describes always-visible /system memory and metadata, but those are static or host-provided contexts and no implemented memory read-back path is present in this checkout.

The important edge case is the documented Letta Code design. If implemented by a host, /system memory and skill/file metadata would be coarse push to an agent, while external files, full skill bodies, and message history search would be pull. This repository only states that design; it does not contain the prompt assembler, message index, MemFS synchronization, or subagent scheduler needed to verify deployed behavior.

Selection, scope, and complexity are therefore policy-level. The Constitution recommends compact summaries, indexes, references, and on-demand loading; the affordances document names message history, conversations, compaction summaries, and memory-filesystem trees. It does not specify top-k retrieval, token budgets, ranking functions, or faithfulness tests in source code.

Authority at consumption depends on host injection path. Loaded as a system prompt or agent instruction, the Constitution has strong instruction authority. Read as a public Markdown document, it is advisory knowledge. Effective behavioral adherence is not tested by this repository.

Curiosity Pass

The most concrete memory mechanism is not in the repository. MemFS is the distinctive design, but the checkout only documents it. That makes this review evidence for Letta's stated architecture, not for a working filesystem-to-memory implementation.

The Constitution treats prompt editing as learning. That is a useful framing for deploy-time learning, but it also raises governance questions: prompt updates can carry high instruction authority without the review and invalidation scaffolding visible in Commonplace.

Message storage is explicitly not enough. The docs say all messages are stored and retrievable, but the Constitution's examples emphasize references, summaries, and indexes that make later retrieval likely. That matches Commonplace's distinction between storage and contextual activation.

Compaction is described as a retained summary, not just truncation. The affordances document says the compaction summary remains in the in-context buffer and can reference files or prior messages. If implemented, that would be a behavior-shaping derived view, but the derivation policy and quality controls are not visible here.

The whitespace workflow is the only checked invariant. For a repository that describes high-authority prompt and memory management, the local CI intentionally remains minimal.

What to Watch

  • Whether this repository adds concrete examples or schemas for MemFS layout; that would let Commonplace compare path conventions rather than only principles.
  • Whether Letta publishes the prompt assembler or memory-filesystem synchronization code tied to this Constitution; that would change read-back from documented affordance to implemented mechanism.
  • Whether compaction and reflection gain source-linked quality criteria; that would determine whether Letta's trace-derived summaries are reviewable artifacts or opaque host outputs.
  • Whether the Constitution grows explicit invalidation rules for outdated identity, memories, and system-prompt learnings; that is the missing governance layer for long-lived self-editing.
  • Whether the training use mentioned in the README gets a public artifact boundary; that would separate prompt-time instruction authority from model-weight learning authority.

Relevant Notes: