# Record
**Author:** @cameron.stream (`did:plc:gfrmhdmjvxn2sjedzboeudef`)

## `knowledge-letta-office-hours-2026-07-30`
**Collection:** `site.standard.document`
**AT URI:** `at://did:plc:gfrmhdmjvxn2sjedzboeudef/site.standard.document/knowledge-letta-office-hours-2026-07-30`

**Title:** Letta Office Hours: Free Dreaming, ACP, MCP, and Trajectory
**Published:** Fri, 07 Aug 2026 02:41:35 GMT
**Updated:** Fri, 07 Aug 2026 02:33:26 GMT
**Description:** Letta adds free dreaming on Cloud, ACP editor support, broader MCP integration, and Trajectory for learning across coding-agent harnesses.
**Publication:** `at://did:plc:gfrmhdmjvxn2sjedzboeudef/site.standard.publication/3mr4py6clps2f`
**Path:** /letta-office-hours-2026-07-30
**Tags:** knowledge, journal, ai, agents, letta, office-hours, public-source, agent-sdk, memory, acp, mcp, trajectory

**Content:**
```json
{
  "text": "[Watch this episode on YouTube](<https://www.youtube.com/watch?v=8EmAPYKl-4Y>)\n\nThe [July 30, 2026 Letta Office Hours episode](https://www.youtube.com/watch?v=8EmAPYKl-4Y) centers on how Letta’s agent stack is becoming more programmable, more portable, and easier to inspect. The headline announcement is that dreaming is now free on Letta Cloud: after compaction, a reflection step can summarize recent conversation into memory without consuming the old model-heavy quota that made the feature harder to use. That change sits alongside editor support through [Agent Client Protocol](https://docs.letta.com/platform/acp), broader [MCP](https://docs.letta.com/) integration, and [Trajectory](https://docs.letta.com/) as a normalization layer for learning from transcripts across multiple coding-agent harnesses.\n\nThis guide is part of the [Letta Office Hours archive](https://cameron.stream/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification.\n\nThe episode is less about one product surface than about a pattern: the agent, its memories, its tools, and its harness should be separable enough that each can be swapped or reused. Cameron spends much of the discussion explaining how persistent memory, external protocols, and cross-harness learning fit together, then uses Q&A to clarify why memory maintenance, approvals, and model behavior are still active areas of product and research work.\n\n## Selected chapters\n\n| Time | Topic |\n| --- | --- |\n| [00:00](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=0s) | Welcome and episode framing |\n| [00:18](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=18s) | Dreaming becomes free on Letta Cloud |\n| [02:17](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=137s) | Reflection and memory commit demo |\n| [04:22](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=262s) | Customizing the dreaming model |\n| [05:06](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=306s) | ACP support announced |\n| [06:12](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=372s) | Letta ACP in Zed |\n| [08:25](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=505s) | MCP support across the stack |\n| [09:30](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=570s) | Chat Completions and Responses APIs |\n| [11:00](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=660s) | Trajectory and transcript learning |\n| [12:58](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=778s) | Q&A on the research team and memory model |\n| [15:57](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=957s) | Why GLM 5.2 struggled with memory |\n| [20:52](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=1252s) | MCP versus skills |\n| [26:17](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=1577s) | Trajectory’s use cases |\n| [31:58](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=1918s) | Sleep time for companion agents |\n| [38:07](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=2287s) | Trajectory for companion workflows |\n| [45:13](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=2713s) | Memory belongs inside the harness |\n| [49:38](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=2978s) | Multi-agent orchestration |\n| [1:14:21](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=4461s) | Teaching agents to improve |\n| [1:24:50](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=5090s) | Skills for learning software engineering |\n| [1:34:52](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=5692s) | Misaligned and playtesting |\n\n## Dreaming becomes a cheaper maintenance loop\n\nCameron opens by saying that dreaming is now free on Letta Cloud, which matters because dreaming is the background maintenance step that turns recent conversation into durable memory. The episode explains it as a reflection subagent that reviews the latest transcript after compaction and decides what should be kept. In earlier behavior, that step was tied to a heavier model and could be affected by quota limits. The new arrangement lowers the barrier to keeping agents current without asking users to manage a separate maintenance workflow.\n\nThat shift is a good example of Letta’s design philosophy. Memory is not just chat history, and the maintenance of memory is not the same thing as ordinary message exchange. The reflection step is presented as an explicit background process with its own model choice, cost profile, and output: a memory commit that can be inspected in Letta Desktop. For a product built around persistent agents, making that loop cheap enough to run regularly is as important as making the main conversation fluent.\n\n## Agent Client Protocol moves Letta into editors\n\nA major announcement in the episode is support for [Agent Client Protocol](https://docs.letta.com/platform/acp), which lets Letta agents appear inside coding editors such as Zed. The practical point is not just that a plugin exists. It is that a client can talk to a persistent Letta agent without taking ownership of the agent’s memory or runtime. The editor becomes a surface for interaction, while Letta remains the system that owns continuity.\n\nThis matters because the episode is trying to separate identity from interface. A developer can work in an editor, send messages into a conversation, and rely on the same agent memory across sessions. The ACP framing also shows why Letta keeps talking about protocols rather than one-off integrations: once the interface is standardized, the same agent can be exposed in more than one environment without duplicating its state model.\n\n## MCP and API compatibility widen the integration surface\n\nThe episode also emphasizes expanding [MCP](https://docs.letta.com/) support across the Letta stack, plus OpenAI-compatible Chat Completions and Responses API endpoints. Together, those pieces reduce the friction of adopting Letta in existing tools. A system can use familiar request formats while still benefiting from Letta’s persistent-agent model underneath.\n\nThat compatibility layer is important because the office-hours discussion repeatedly returns to the same question: how do you make an agent system feel usable without flattening it into a generic chat API? The answer offered here is to preserve Letta’s internal structure—memory, tools, schedules, agents, and sessions—while meeting developers where they already build. Compatibility is therefore a bridge, not a replacement for the underlying architecture.\n\n## Trajectory treats agent transcripts as reusable learning data\n\nTrajectory is introduced as a normalization layer for transcripts from different coding-agent harnesses, including Codex, Claude Code, Letta, and OpenHands. The reason to normalize is simple: if agent work is recorded in incompatible formats, it is hard to learn from it across systems. Trajectory tries to make those histories comparable so that they can be used for evaluation, research, and future training workflows.\n\nThe discussion around Trajectory is broader than a format announcement. Cameron frames it as a way to make agent work legible across harness boundaries. That includes not only code-writing tasks, but also companion-agent behavior, coordination patterns, and recurring workflows. The episode treats transcript data as something more than logs: if normalized well, it becomes a corpus for understanding how agents behave and improve.\n\n## Q&A themes\n\nThe Q&A turns the product updates into a set of architectural questions:\n\n- **How should memory maintenance be powered?** The episode argues for a cheaper, more routine dreaming loop so agents stay current without expensive upkeep.\n- **Where should agent identity live?** The recurring answer is inside the Letta runtime, not inside whichever editor or client happens to connect.\n- **What is the relationship between MCP and skills?** MCP is treated as a transport/interface layer, while skills are part of the agent’s internal capability set.\n- **Why normalize transcripts across harnesses?** Because learning from agent behavior requires comparable data, not just more data.\n- **How should companion agents sleep or wake?** The episode explores timing as part of harness design, not as an afterthought.\n- **Why keep emphasizing inspectability?** Because persistent memory is only useful if people can review and revise it.\n\n## Architectural through-line\n\nThe episode’s through-line is that Letta is trying to make agents modular across five boundaries: memory maintenance, client protocol, model/provider compatibility, cross-harness learning, and runtime identity. Dreaming, ACP, MCP, and Trajectory are not isolated features; they are all attempts to let one part of the system change without forcing the others to be rebuilt.\n\nThat makes the platform more flexible, but also more conceptually demanding. Users have to understand that an agent can persist across tools, that transcript data can be reused across harnesses, and that maintenance can happen separately from interactive conversation. The episode presents that complexity as the price of building agents that can continue working after the initial chat ends.\n\n## Related public material\n\n- [YouTube episode](https://www.youtube.com/watch?v=8EmAPYKl-4Y)\n- [Letta documentation](https://docs.letta.com/)\n- [Agent Client Protocol](https://docs.letta.com/platform/acp)\n- [Letta Agent SDK](https://docs.letta.com/agent-sdk)\n- [Letta Code](https://github.com/letta-ai/letta-code)\n- [Letta Agent SDK repository](https://github.com/letta-ai/letta-agent-sdk)\n- [Trajectory](https://docs.letta.com/)\n- [OpenHands](https://github.com/All-Hands-AI/OpenHands)\n\n## Sources\n\n- [Official YouTube episode](<https://www.youtube.com/watch?v=8EmAPYKl-4Y>)\n- [Letta documentation](<https://docs.letta.com/>)",
  "$type": "site.standard.content.markdown",
  "version": "1.0"
}
```

---
*Fetched from https://enoki.us-east.host.bsky.network via `com.atproto.repo.getRecord`*