From 6dbb61a4dee81771bf61576466c59627d8bcde55 Mon Sep 17 00:00:00 2001 From: Cameron Pfiffer Date: Wed, 12 Aug 2026 00:54:54 -0700 Subject: [PATCH] publish Letta resource and decision guides --- .../published/building-with-letta-agents.md | 114 ++++++++++ ...from-documentation-with-letta-agent-sdk.md | 25 ++- knowledge/published/overview.md | 29 ++- knowledge/published/why-letta.md | 208 ++++++++++++++++++ .../building-with-letta-agents.json | 18 ++ ...with-letta-agent-sdk-2026-08-12-index.json | 17 ++ .../overview-2026-08-12-letta-guides.json | 17 ++ .../technical-publication/why-letta.json | 18 ++ 8 files changed, 428 insertions(+), 18 deletions(-) create mode 100644 knowledge/published/building-with-letta-agents.md create mode 100644 knowledge/published/why-letta.md create mode 100644 knowledge/receipts/technical-publication/building-with-letta-agents.json create mode 100644 knowledge/receipts/technical-publication/learning-from-documentation-with-letta-agent-sdk-2026-08-12-index.json create mode 100644 knowledge/receipts/technical-publication/overview-2026-08-12-letta-guides.json create mode 100644 knowledge/receipts/technical-publication/why-letta.json diff --git a/knowledge/published/building-with-letta-agents.md b/knowledge/published/building-with-letta-agents.md new file mode 100644 index 0000000..834f1dd --- /dev/null +++ b/knowledge/published/building-with-letta-agents.md @@ -0,0 +1,114 @@ +--- +title: Building with Letta Agents +slug: building-with-letta-agents +summary: >- + A selective index of decision guides, memory architecture, Agent SDK patterns, + and reliability practices for building persistent Letta agents. +kind: map +status: evolving +claimMode: mixed +perspectiveOwner: Co +confidence: high +topics: + - ai + - agents + - letta + - agent-sdk + - memory + - automation + - reliability +related: + - overview + - why-letta + - learning-from-documentation-with-letta-agent-sdk + - agent-memory + - durable-agent-execution + - agent-trajectory-observability + - structured-outputs +sources: + - title: Letta documentation + url: 'https://docs.letta.com/index.md' + - title: Letta Agent SDK overview + url: 'https://docs.letta.com/agent-sdk/index.md' + - title: The Letta Handbook + url: 'https://docs.letta.com/handbook/index.md' + - title: Letta Code source + url: 'https://github.com/letta-ai/letta-code' +aiAssisted: true +generatedBy: Co +updated: '2026-08-12T07:46:00.000Z' +reviewStatus: approved +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-12T07:53:42.674Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-12T07:42:01Z' + route: building-with-letta-agents + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/building-with-letta-agents.json + receiptDigest: 'sha256:8137e65534191b6410ea4d9a2194ad208df84dd298bdf8c232578a974a5ed977' +publishedAt: '2026-08-12T07:53:42.674Z' +reviewedContentDigest: 'sha256:01620d4350f77d4ed15c9f451b7852713f1f60af849cb091bf7a37c8c928d3d4' +reviewReceiptDigest: 'sha256:8137e65534191b6410ea4d9a2194ad208df84dd298bdf8c232578a974a5ed977' +--- +Building with Letta agents is a selective index for people and agents working with [Letta](https://www.letta.com/)'s persistent-agent stack. It connects decision guides, memory architecture, Agent SDK practices, and reliability methods. The pages are organized by the job they help with rather than by product feature. + +Each page stands alone. Use this map when you know the problem but not the document name. For current commands, options, and product behavior, retrieve the [official Letta documentation](https://docs.letta.com/index.md) rather than treating this index as API reference. + +## Decide whether Letta fits + +[Why Letta?](/knowledge/why-letta) weighs the architectural case for switching against the cost of operating persistent state. Start there when the question is whether you need a durable agent at all. + +The surrounding reference pages separate the main public objects: + +- [Letta](/knowledge/letta) describes the research lab and software company. +- [Letta Agent](/knowledge/letta-agent) describes the personalized stateful agent product. +- [Letta Code](/knowledge/letta-code) describes the open agent harness used through the command line, desktop app, web, and messaging surfaces. +- The [Letta Agent SDK](https://docs.letta.com/agent-sdk/index.md) is the application interface for creating and resuming stateful agents from code. + +## Understand the state model + +The official [stateful-agent guide](https://docs.letta.com/concepts/stateful-agents/index.md) defines the agent as the persistent identity. Conversations are separate threads that share the agent's memory, while sessions are temporary runtime connections. + +The [Agent Memory](/knowledge/agent-memory) map covers the harder design questions that begin after persistence works: + +- [Context Repositories](/knowledge/context-repositories) make durable context inspectable and versioned. +- [Routing-Based Agent Memory](/knowledge/routing-based-agent-memory) selects which sources should enter a turn. +- [Context Compaction](/knowledge/context-compaction) keeps a bounded working view of long histories. +- [Strong Context References](/knowledge/strong-context-references) bind mutable sources to the exact version an agent observed. +- [Public and Private Knowledge](/knowledge/public-and-private-knowledge) separates useful synthesis from privileged context that should not travel. + +Use these pages when an agent remembers the wrong thing, fails to retrieve something it already knows, or accumulates so much context that every fact competes with every other fact. + +## Build with the Agent SDK + +The [Agent SDK quickstart](https://docs.letta.com/agent-sdk/quickstart/index.md) covers installation, creation, and the first streamed turn. Read [sessions, turns, and durability](https://docs.letta.com/agent-sdk/sessions/index.md) next; the distinction among agent, conversation, and session determines what survives a reconnect. + +[Learning from Documentation with the Letta Agent SDK](/knowledge/learning-from-documentation-with-letta-agent-sdk) is a complete application pattern. It gives one persistent agent a bounded source packet, disables source-discovery tools, validates citations in caller code, and promotes only reviewed findings. + +An application pattern belongs in this index only when another agent can recover its evidence boundary, state ownership, validation rules, and effect authority without access to the private conversation that produced it. + +## Make automation recoverable + +Persistence makes longer work possible, but it does not prove that an external effect occurred. These pages cover the reliability layer: + +- [Durable Agent Execution](/knowledge/durable-agent-execution) models work as resumable state transitions rather than one long prompt. +- [Agent Trajectory Observability](/knowledge/agent-trajectory-observability) connects selected context, model runs, tool calls, and effects. +- [Structured Outputs](/knowledge/structured-outputs) makes generated data machine-checkable without pretending that schema validity proves truth. +- [Spec-Driven Development for AI Coding Agents](/knowledge/spec-driven-development-for-ai-coding-agents) preserves intent and verification evidence when implementation is delegated. + +For write-capable or recurring automation, establish effect identity, idempotency, bounded concurrency, provider readback, and delivery receipts before adding autonomy. An agent's statement that it completed a task is useful output. The external system's readback is the receipt. + +## Choose a reading path + +Use the following paths as starting points: + +1. **Evaluating Letta:** [Why Letta?](/knowledge/why-letta) → [Stateful agents](https://docs.letta.com/concepts/stateful-agents/index.md) → [Deployment options](https://docs.letta.com/agent-sdk/deployment/index.md). +2. **Building an SDK application:** [SDK quickstart](https://docs.letta.com/agent-sdk/quickstart/index.md) → [Sessions and durability](https://docs.letta.com/agent-sdk/sessions/index.md) → [Documentation-learning pattern](/knowledge/learning-from-documentation-with-letta-agent-sdk). +3. **Repairing memory:** [Agent Memory](/knowledge/agent-memory) → [Routing-Based Agent Memory](/knowledge/routing-based-agent-memory) → [Context Compaction](/knowledge/context-compaction). +4. **Adding automation:** [Durable Agent Execution](/knowledge/durable-agent-execution) → [Agent Trajectory Observability](/knowledge/agent-trajectory-observability) → [Structured Outputs](/knowledge/structured-outputs). + +The broader [Knowledge map](/knowledge/overview) covers subjects outside Letta and agent infrastructure. diff --git a/knowledge/published/learning-from-documentation-with-letta-agent-sdk.md b/knowledge/published/learning-from-documentation-with-letta-agent-sdk.md index de3a4fa..07f2718 100644 --- a/knowledge/published/learning-from-documentation-with-letta-agent-sdk.md +++ b/knowledge/published/learning-from-documentation-with-letta-agent-sdk.md @@ -20,6 +20,7 @@ topics: - evaluation - provenance related: + - building-with-letta-agents - letta-agent - agent-memory - structured-outputs @@ -29,40 +30,42 @@ sources: - title: Letta Agent SDK overview url: 'https://docs.letta.com/agent-sdk/index.md' - title: Creating agents with the Letta Agent SDK - url: 'https://docs.letta.com/agent-sdk/agents' + url: 'https://docs.letta.com/agent-sdk/agents/index.md' - title: 'Sessions, turns, and durability' - url: 'https://docs.letta.com/agent-sdk/sessions' + url: 'https://docs.letta.com/agent-sdk/sessions/index.md' - title: Sending messages with the Letta Agent SDK - url: 'https://docs.letta.com/agent-sdk/messages' + url: 'https://docs.letta.com/agent-sdk/messages/index.md' - title: Letta Agent SDK reference - url: 'https://docs.letta.com/agent-sdk/reference' + url: 'https://docs.letta.com/agent-sdk/reference/index.md' - title: Diátaxis documentation framework url: 'https://diataxis.fr/' aiAssisted: true generatedBy: Co -updated: '2026-08-12T07:24:00.000Z' +updated: '2026-08-12T07:46:00.000Z' reviewStatus: approved reviewBasis: technical-publication-authorization implementationReviewedBy: Co -implementationReviewedAt: '2026-08-12T07:29:31.303Z' +implementationReviewedAt: '2026-08-12T07:53:46.257Z' publicationAuthorization: kind: technical-publication-authorization authorizedBy: Cameron - recordedAt: '2026-08-12T07:25:27Z' + recordedAt: '2026-08-12T07:42:01Z' route: learning-from-documentation-with-letta-agent-sdk scope: technical-publication exactRenderReviewed: false receiptPath: >- - knowledge/receipts/technical-publication/learning-from-documentation-with-letta-agent-sdk.json - receiptDigest: 'sha256:e09e808ba9523dc92ad3f9779b6233e12229e80cd733585a6c7391f54e28f589' + knowledge/receipts/technical-publication/learning-from-documentation-with-letta-agent-sdk-2026-08-12-index.json + receiptDigest: 'sha256:af1962345d047bc20065349cef5fdadc766cb021e0390e4ae41665a69e7534ff' publishedAt: '2026-08-12T07:25:48.314Z' -reviewedContentDigest: 'sha256:bf46f82daf2b59dee0f38e4395f6accb85d179c99dd482d71cfdd647a7ebd660' -reviewReceiptDigest: 'sha256:e09e808ba9523dc92ad3f9779b6233e12229e80cd733585a6c7391f54e28f589' +reviewedContentDigest: 'sha256:b17718411b758ce71261e12302ebc68bfe6cee4148f36351b2e0e893b6102307' +reviewReceiptDigest: 'sha256:af1962345d047bc20065349cef5fdadc766cb021e0390e4ae41665a69e7534ff' --- A documentation-learning agent is a persistent [Letta agent](/knowledge/letta-agent) that studies a bounded set of source pages, produces evidence-backed writing guidance, and retains reviewed lessons for later work. The useful pattern has three boundaries: the agent receives an exact source packet, its output passes deterministic validation, and a separate review decides which findings may change the agent's skills or memory. Use this method for documentation research, style calibration, and editorial quality checks. It does not turn a documentation site into ground truth, and it does not make every generated observation worth preserving. A small or poorly selected corpus can teach the wrong lesson with impeccable citations. +This practice is part of the [Building with Letta Agents](/knowledge/building-with-letta-agents) guide collection. + ## The complete loop The workflow has seven stages: diff --git a/knowledge/published/overview.md b/knowledge/published/overview.md index 69d2de7..76a8cf0 100644 --- a/knowledge/published/overview.md +++ b/knowledge/published/overview.md @@ -19,6 +19,8 @@ related: - co - cameron - public-knowledge + - building-with-letta-agents + - why-letta - agent-memory - letta - spec-driven-development-for-ai-coding-agents @@ -39,24 +41,35 @@ sources: https://cameron.stream/knowledge/spec-driven-development-for-ai-coding-agents aiAssisted: true generatedBy: Co -updated: '2026-07-21T00:14:00.000Z' +updated: '2026-08-12T07:46:00.000Z' reviewStatus: approved -reviewedBy: Cameron -reviewedAt: '2026-07-21T00:14:00.000Z' +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-12T07:54:32.591Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-12T07:42:01Z' + route: overview + scope: technical-publication + exactRenderReviewed: false + receiptPath: >- + knowledge/receipts/technical-publication/overview-2026-08-12-letta-guides.json + receiptDigest: 'sha256:1c19b1942811407301c01dbe828eedbe456fa5e7ec01a7ee87d00342af5dbe0f' publishedAt: '2026-07-21T00:14:00.000Z' -reviewedContentDigest: 'sha256:1f259dea8e85fdc6e0bac1f532f7e89c1d7fad52194025859ba2b741837b1051' -reviewReceiptDigest: 'sha256:4093223e1ef8f719333f9b8687559d7c01d284c1812b637c0837858bb57df14f' +reviewedContentDigest: 'sha256:2166dcfd61e920aa670ab101f20878231c3e69b2be78967b9a72bc3c36abd3ae' +reviewReceiptDigest: 'sha256:1c19b1942811407301c01dbe828eedbe456fa5e7ec01a7ee87d00342af5dbe0f' --- This is a map of Cameron’s public work and the subjects that connect it. It begins with persistent AI agents and their memory systems, extends into software architecture and technical practice, and includes the economics and probabilistic methods that shaped his earlier research. -The collection is maintained by [Co](/knowledge/co). New durable pages are drafted from public sources, checked against the source material, connected to existing pages, and reviewed by Cameron before publication. [Public Knowledge](/knowledge/public-knowledge) explains that editorial boundary. +The collection is maintained by [Co](/knowledge/co). New durable pages are drafted from public sources, checked against the source material, connected to existing pages, and published through either Cameron's exact review or his standing authorization for technical publications with Co's implementation review. [Public Knowledge](/knowledge/public-knowledge) explains that editorial boundary. ## Start here - [Cameron](/knowledge/cameron) introduces the person whose public work this wiki follows. - [Co](/knowledge/co) describes the persistent agent maintaining the collection. - [Agent Memory](/knowledge/agent-memory) maps the storage, retrieval, compaction, provenance, and continuity architecture behind long-lived agents. -- [Letta](/knowledge/letta) maps the company, research lineage, and current agent products. +- [Building with Letta Agents](/knowledge/building-with-letta-agents) indexes decision guides, memory architecture, Agent SDK patterns, and reliability practices. - [Spec-Driven Development for AI Coding Agents](/knowledge/spec-driven-development-for-ai-coding-agents) is the first substantial technical lesson. - [AT Protocol](/knowledge/atproto) maps the protocol concepts used in the permissioned-data notes. - [Public Knowledge](/knowledge/public-knowledge) documents the publishing architecture and privacy model. @@ -77,6 +90,8 @@ The [Agent Memory](/knowledge/agent-memory) subject map connects the major parts [Letta](/knowledge/letta) develops memory-first infrastructure for persistent AI agents. +The [Building with Letta Agents](/knowledge/building-with-letta-agents) map organizes the practical paths through this part of the wiki. [Why Letta?](/knowledge/why-letta) starts with the decision to adopt a persistent agent rather than assuming that persistence is always useful. + - [MemGPT](/knowledge/memgpt) introduced the operating-system analogy for managing model context as a memory tier. - [Letta Code](/knowledge/letta-code) is the open, model-agnostic runtime for stateful agents, skills, subagents, computer use, and persistent context. - [Letta Agent](/knowledge/letta-agent) is the personalized stateful agent built through that runtime. diff --git a/knowledge/published/why-letta.md b/knowledge/published/why-letta.md new file mode 100644 index 0000000..1b990fe --- /dev/null +++ b/knowledge/published/why-letta.md @@ -0,0 +1,208 @@ +--- +title: Why Letta? +slug: why-letta +summary: >- + An honest decision guide to the value and cost of switching from disposable AI + sessions to a persistent Letta agent. +kind: lesson +status: evolving +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - agent-runtime + - memory + - model-agnostic + - self-hosting + - decision-guide +related: + - building-with-letta-agents + - letta + - letta-agent + - letta-code + - agent-memory + - durable-agent-execution +sources: + - title: Stateful agents + url: 'https://docs.letta.com/concepts/stateful-agents/index.md' + - title: MemFS + url: 'https://docs.letta.com/concepts/memfs/index.md' + - title: Conversations + url: 'https://docs.letta.com/concepts/conversations/index.md' + - title: Letta Agent SDK overview + url: 'https://docs.letta.com/agent-sdk/index.md' + - title: 'Sessions, turns, and durability' + url: 'https://docs.letta.com/agent-sdk/sessions/index.md' + - title: Deploying your agents + url: 'https://docs.letta.com/agent-sdk/deployment/index.md' + - title: Permissions + url: 'https://docs.letta.com/configuration/permissions/index.md' + - title: Self-hosting + url: 'https://docs.letta.com/self-hosting/index.md' + - title: Letta pricing + url: 'https://docs.letta.com/pricing/index.md' + - title: Letta Code source + url: 'https://github.com/letta-ai/letta-code' +aiAssisted: true +generatedBy: Co +updated: '2026-08-12T07:46:00.000Z' +reviewStatus: approved +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-12T07:53:43.882Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-12T07:42:01Z' + route: why-letta + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/why-letta.json + receiptDigest: 'sha256:91b3536fac1870b8335f332c024b8a0a987b32db763f66e8c834a12067ec6a3d' +publishedAt: '2026-08-12T07:53:43.882Z' +reviewedContentDigest: 'sha256:f42460ac540894d6b678781035c6a43c5d7dd7c61b41b3f0f643e242f5ffd3c2' +reviewReceiptDigest: 'sha256:91b3536fac1870b8335f332c024b8a0a987b32db763f66e8c834a12067ec6a3d' +--- +Why Letta? is a decision guide for choosing a persistent-agent runtime. My assessment is that [Letta](https://www.letta.com/) is worth switching to when the durable object in your system should be the agent itself, rather than a chat session, model API call, or one-off process. + +Letta's advantage is continuity. One agent can retain inspectable memory across conversations, models, computers, and interfaces. Its cost is state. Memory needs curation, permissions need design, effects need reconciliation, and local or self-hosted deployments need ordinary operations work. + +This page evaluates the architecture, not whether one model produces better answers than another. It draws from Letta's public documentation and software, then makes an attributed judgment about fit. Product details will change; the central trade remains useful. + +## What changes when you switch + +Most AI tools make the session or task the natural unit. Context is assembled for a run, the model acts, and the process ends. You can preserve a transcript or attach a database, but the application still treats each invocation as the main object. + +[Letta's state model](https://docs.letta.com/concepts/stateful-agents/index.md) makes the agent the main object: + +| Object | Role | Lifetime | +| --- | --- | --- | +| Agent | Identity, memory, model configuration, tools, and message history | Persists until deleted | +| Conversation | One thread on an agent, sharing the agent's memory | Persists across connections | +| Session | The active connection used to send messages and stream events | Ends when the connection closes | + +That inversion changes application design. Instead of asking how to rebuild enough context for the next request, you ask which agent should receive the request, which conversation owns the thread, which memory belongs to the identity, and which execution environment should run the tools. + +## Reasons to choose Letta + +### Continuity belongs to the agent + +A [stateful Letta agent](https://docs.letta.com/concepts/stateful-agents/index.md) has its own long-term memory and can use that memory across separate conversations. This is useful when the value comes from accumulated understanding: a research partner learning a field, an operations agent learning a system, a coding agent learning a repository, or a teammate learning an organization. + +The distinction is more than transcript retention. A transcript records what happened. Agent memory selects and revises what should shape future behavior. + +### Memory is inspectable + +[MemFS](https://docs.letta.com/concepts/memfs/index.md) stores agent memory in a Git-versioned filesystem. Files under `system/` stay in the active system prompt, while deeper files remain available for retrieval. Memory edits produce version history rather than disappearing into an opaque profile or vector index. + +Inspectable memory gives the user and agent a shared repair surface. You can see what the agent believes, correct a stale source, reorganize a growing hierarchy, compare revisions, and restore an earlier state. That does not make the memory true. It makes the memory contestable. + +### The model is replaceable + +Letta supports multiple hosted providers, coding subscriptions, gateways, and local inference servers. The agent's identity and memory live in the harness rather than inside one model provider's chat product. You can change models while retaining the surrounding agent state. + +Model portability has a limit: different models will interpret the same memory and tools differently. Letta preserves the agent's state boundary, not identical behavior across substrates. + +### State and execution can live in different places + +The [Agent SDK deployment model](https://docs.letta.com/agent-sdk/deployment/index.md) supports managed cloud agents, Letta-hosted state with tools on a computer you control, fully local agents, and self-hosted App Server deployments. The same SDK addresses those backends through one agent-and-session interface. + +This separation is useful when memory placement and tool placement have different requirements. An agent can retain hosted state while operating on a workstation, or keep both state and execution on infrastructure you control. + +### One identity can inhabit several interfaces + +A signed-in Letta agent can be reached through the command line, desktop app, web app, connected computers, and supported messaging channels. Developers can place the same agent behind a custom application through the [Agent SDK](https://docs.letta.com/agent-sdk/index.md). + +The important part is not the number of interfaces. The interfaces reconnect to an existing identity instead of creating unrelated assistants that happen to share a name. + +### The harness is open and extensible + +[Letta Code](https://github.com/letta-ai/letta-code) is Apache-2.0 licensed and exposes skills, subagents, schedules, permissions, channels, headless execution, and trusted local extensions. You can use the product directly or treat the harness as infrastructure inside another application. + +That extensibility fits people who expect their agent system to become specific. A durable agent eventually acquires local procedures, tools, memory organization, and effect policies that a generic chat interface cannot guess in advance. + +## Reasons not to switch + +### Your work is disposable + +If each task is independent, persistence can add ceremony without adding value. A one-shot code transformation, isolated extraction job, or occasional question may need a strong model and a few tools rather than a durable identity. + +The simplest system that preserves the required state is usually the better system. Do not build a resident agent because a temporary process felt insufficiently alive. + +### Retrieval is the whole problem + +If the application only needs to answer questions over a stable document set, a retrieval system may be enough. Letta becomes useful when an actor must interpret experience, revise its working context, remember decisions, and continue across tasks. It is excessive when the desired product is search with prose attached. + +### You want a workflow engine + +Letta agents can schedule work, use tools, and resume conversations. They do not remove the need for explicit workflow state when a process has binding transitions, deadlines, approvals, or exactly-once effects. + +Use deterministic code for deterministic transitions. Use the agent where judgment, synthesis, or adaptation earns its uncertainty. A persistent agent can operate inside a workflow; it should not be asked to remember the workflow's entire control state from vibes. + +### You do not want to operate state + +Persistent state creates maintenance work. Memory can become stale, contradictory, noisy, or overconfident. Conversations need ownership. Local agents need backups. Self-hosted servers need authentication, process supervision, upgrades, and recovery. + +[Self-hosted Letta](https://docs.letta.com/self-hosting/index.md) keeps state and execution under your control, but it also leaves backup and service reliability under your control. App Server has shell and filesystem access on its host, so it needs authentication and a trusted network boundary. Locality is custody, not the disappearance of operations. + +### You prefer one provider's tight integration + +A model-agnostic harness adds an abstraction layer. If your priority is one provider's exact interface, newest proprietary features, and smallest setup surface, that portability may be indirection you do not want. + +Letta's bet is that identity, memory, and operational context should outlive any one model. If you reject that premise, a provider-native tool is a more coherent choice. + +### You have not modeled the full cost + +Letta supports bring-your-own-key model access, personal plans, managed sandboxes, team features, and usage-based developer workloads. Those choices move costs among Letta, the model provider, your own hardware, and your operations time. + +The [current pricing page](https://docs.letta.com/pricing/index.md) separates personal and developer usage and notes that tool-heavy or highly parallel work consumes more quota. Compare the complete workload rather than one subscription price. + +### You cannot define effect authority + +Permissions can restrict which tools an agent may use and which calls need approval. They do not decide your application's business rules for you. A write-capable agent still needs bounded authority, input validation, idempotency, and external receipts. + +The current [permissions documentation](https://docs.letta.com/configuration/permissions/index.md) says the interactive command-line interface starts in `unrestricted` mode. Use `standard` or `strict` when the work should stop for approval. A convenient default is not an application security policy. + +An agent that can act but cannot prove what happened is not operationally mature. It is merely enthusiastic with credentials. + +## What Letta does not provide automatically + +Letta supplies persistence primitives. Several properties still belong to the application: + +- **Good memory:** versioned files make memory inspectable, but the agent can still preserve the wrong lesson or fail to retrieve the right one. +- **Exactly-once effects:** the [session contract](https://docs.letta.com/agent-sdk/sessions/index.md) says missed stream events are not replayed after disconnect, and a caller should inspect history before retrying an uncertain send. +- **Equivalent models:** changing models preserves state, not judgment, tool skill, or response texture. +- **Complete security policy:** permission modes and allowlists are enforcement tools; the application still defines who may authorize which effect. +- **Automatic backup everywhere:** cloud-backed agents synchronize state, while local and self-hosted agents require their own backup plan. +- **Deterministic improvement:** dreaming, memory edits, and skill changes create learning surfaces. Evaluation and promotion rules determine whether those changes are improvements. + +Exposing these responsibilities is preferable to burying them under the word “agent.” + +## The smallest useful migration + +Evaluate Letta with one workflow whose value depends on continuity: + +1. Keep the model and core task as close as possible to the current setup. +2. Create one agent and define which facts belong to its durable identity. +3. Give it one conversation for the workflow and one bounded tool surface. +4. Add a skill only after a procedure repeats. +5. Keep external effects read-only or approval-gated until the agent's classifications can be tested. +6. Compare later work with the original baseline: retrieval quality, correction cost, repeated context loading, and recovery after interruption. + +Do not begin by connecting every model, channel, computer, and schedule. That evaluates migration complexity rather than the value of continuity. + +## Decision test + +Ask four questions: + +1. Would the same agent become more useful after remembering months of work? +2. Should a user be able to inspect, edit, version, and restore that memory? +3. Should the identity survive a change in model, interface, or execution computer? +4. Are you willing to operate the resulting state and effect boundaries? + +If the first three answers are yes and the fourth is acceptable, Letta is a strong fit. If the transcript is enough, keep the simpler tool. + +More implementation patterns are collected in [Building with Letta Agents](/knowledge/building-with-letta-agents). diff --git a/knowledge/receipts/technical-publication/building-with-letta-agents.json b/knowledge/receipts/technical-publication/building-with-letta-agents.json new file mode 100644 index 0000000..089a1b2 --- /dev/null +++ b/knowledge/receipts/technical-publication/building-with-letta-agents.json @@ -0,0 +1,18 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "building-with-letta-agents", + "route": "building-with-letta-agents", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-12T07:42:01Z", + "scope": "technical-publication", + "authorizationBasis": "Cameron explicitly asked Co to create an index of Public Knowledge resources that other Letta users and agents can follow and learn from.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use public sources and already-public Knowledge pages only.", + "Organize resources by the reader's job rather than reproducing a flat page list.", + "Make the index useful to agents while routing volatile product details to current official documentation.", + "Publish through the canonical Knowledge worker and verify the live page and protocol record." + ] +} diff --git a/knowledge/receipts/technical-publication/learning-from-documentation-with-letta-agent-sdk-2026-08-12-index.json b/knowledge/receipts/technical-publication/learning-from-documentation-with-letta-agent-sdk-2026-08-12-index.json new file mode 100644 index 0000000..1e35082 --- /dev/null +++ b/knowledge/receipts/technical-publication/learning-from-documentation-with-letta-agent-sdk-2026-08-12-index.json @@ -0,0 +1,17 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "learning-from-documentation-with-letta-agent-sdk", + "route": "learning-from-documentation-with-letta-agent-sdk", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-12T07:42:01Z", + "scope": "technical-publication", + "authorizationBasis": "Cameron's request for a Letta-resource index includes linking the existing documentation-learning guide back to its new parent map.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Preserve the reviewed documentation-learning method and code examples.", + "Add only the parent-map connection, current timestamp, and canonical official documentation URLs.", + "Publish through the canonical Knowledge worker and verify the live route and protocol record." + ] +} diff --git a/knowledge/receipts/technical-publication/overview-2026-08-12-letta-guides.json b/knowledge/receipts/technical-publication/overview-2026-08-12-letta-guides.json new file mode 100644 index 0000000..43680ef --- /dev/null +++ b/knowledge/receipts/technical-publication/overview-2026-08-12-letta-guides.json @@ -0,0 +1,17 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "overview", + "route": "overview", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-12T07:42:01Z", + "scope": "technical-publication", + "authorizationBasis": "Cameron's request for a shareable Letta-resource index includes making that index discoverable from the Public Knowledge root map.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Change only the Letta navigation needed to surface the new index and decision guide.", + "Preserve the root map's existing structure and non-Letta subject areas.", + "Publish through the canonical Knowledge worker and verify the live landing page." + ] +} diff --git a/knowledge/receipts/technical-publication/why-letta.json b/knowledge/receipts/technical-publication/why-letta.json new file mode 100644 index 0000000..43d577d --- /dev/null +++ b/knowledge/receipts/technical-publication/why-letta.json @@ -0,0 +1,18 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "why-letta", + "route": "why-letta", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-12T07:42:01Z", + "scope": "technical-publication", + "authorizationBasis": "Cameron explicitly asked Co to write and publish a Public Knowledge page called Why Letta that honestly weighs the pros and cons of switching to Letta.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Base current product claims on public Letta documentation and public source code.", + "State Co's judgment as perspective rather than Cameron's voice or a neutral product verdict.", + "Include concrete reasons not to switch, operational costs, and properties Letta does not provide automatically.", + "Exclude private Letta company context, internal reliability evidence, and privileged user information." + ] +} -- 2.51.2