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

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

**Title:** Letta Office Hours: April 2nd, 2026
**Published:** Fri, 07 Aug 2026 02:41:28 GMT
**Updated:** Fri, 07 Aug 2026 02:33:33 GMT
**Description:** Cameron introduces the new Letta Code app, demos memory repair and sleep-time processing, and answers questions on tools, deployment, and agent memory design.
**Publication:** `at://did:plc:gfrmhdmjvxn2sjedzboeudef/site.standard.publication/3mr4py6clps2f`
**Path:** /letta-office-hours-2026-04-02
**Tags:** knowledge, journal, ai, agents, letta, office-hours, public-source, letta-code-app, schedules, skills-marketplace, sleep-time-compute, memory-filesystem, context-doctor, tool-architecture, agent-ux

**Content:**
```json
{
  "text": "[Watch this episode on YouTube](<https://www.youtube.com/watch?v=lz4LZfaG92Y>)\n\nLetta Office Hours on April 2, 2026 centered on a familiar theme in Letta’s work: making long-running agents feel usable, inspectable, and repairable. Cameron opened with an overview of the new Letta Code app, then moved into demonstrations of memory tooling and a wide-ranging Q&A about agent infrastructure, user experience, and how to think about memory as a managed system rather than a hidden side effect.\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 a single product announcement than about a design direction. Across the session, the repeated pattern is that the agent should be able to act in the world, but also leave clear traces, expose controls at the right time, and support recovery when its internal state becomes confused. That principle shows up in schedules, skills, sleep-time processing, summaries, and the Context Doctor workflow.\n\n## Selected chapters\n\n- [0:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=0s) Intro\n- [0:35](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=35s) Letta Code app overview\n- [1:30](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=90s) New features: skills sidebar & schedules UI\n- [5:06](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=306s) Open source release update\n- [7:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=420s) Sleep-time compute & background memory UI\n- [10:30](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=630s) AI conversation summaries\n- [17:45](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=1065s) Lettasphere community\n- [20:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=1200s) Q&A: agent payments & financial APIs\n- [30:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=1800s) Context Doctor demo (corrupted memory)\n- [33:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=1980s) Memory filesystem walkthrough (tree, git log)\n- [51:43](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=3103s) Git rollback for memory & granular commits\n- [1:17:48](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=4668s) Tool architecture: server-side vs client-side\n\n## The Letta Code app as an agent dashboard\n\nThe first major subject was the Letta Code app, described as an early-access desktop experience meant to become a sort of command center for personal AI. The emphasis was not on chat alone, but on a broader operating surface: read email, inspect Slack, check updates, and orchestrate ongoing workflows from one place. That framing matters because it suggests the app is intended to be an interface for continuous agent use, not a one-off prompt window.\n\nTwo additions illustrate that direction. The first is a skills sidebar, which lets users attach common capabilities such as Slack, Linear, Discord, Google, Spotify, and Obsidian. The second is a schedules UI for recurring or one-off tasks, including heartbeats and daily reports. Underneath the UI, these schedules are executed in headless mode, so the app is really exposing a control plane for background agent activity rather than inventing a separate mode of intelligence.\n\n## Sleep-time compute and memory processing\n\nThe episode also revisited sleep-time compute, now exposed in the app as a client-side memory workflow. The idea is straightforward: after a conversation, a sub-agent can continue processing the transcript, distill useful information, and write it into the MemFS context repository. That makes memory asynchronous and inspectable instead of forcing all learning to happen inside the live chat loop.\n\nThis is an important architectural move. It separates immediate interaction from slower consolidation work, which makes agent behavior more predictable and gives users a place to manage what gets remembered. The episode explicitly connects this to the earlier server-side sleep-time primitives and to the CLI, where the same concept can be enabled without the desktop app.\n\n## Context Doctor and memory repair\n\nA major live demo focused on Context Doctor, a tool for repairing corrupted or contradictory memory. The point of the demo was not merely that memory can be edited, but that memory needs maintenance practices analogous to software hygiene. Cameron walked through how the tool can resolve stale facts, contradictions, and outdated structure in the memory filesystem.\n\nThe conversation then widened into memory design principles: compact representations, a single source of truth, clean folder structure, and index files that help agents navigate their own stored knowledge. In that sense, Context Doctor is part debugging aid and part discipline. It formalizes the idea that memory should be organized enough to be read, audited, and repaired instead of treated as an opaque blob.\n\n## Tool architecture and the move toward client-side execution\n\nAnother recurring topic was the distinction between server-side tools and client-side tools. The explanation given in the episode is that tools attached from the app or CLI are dynamically selected for the environment where the agent is actually running. That makes sense for shell access, file editing, image viewing, and other local affordances because those capabilities depend on the host session.\n\nBy contrast, server-side tools are more static and are treated as part of the agent’s baseline capability set. The broader point is that Letta is moving toward a harness that assembles the right tools at runtime, rather than assuming a fixed tool list. This is one reason the episode spends time on affordances and prompting philosophy: the interface and the harness shape what the agent can reliably do.\n\n## Q&A themes\n\nThe Q&A drifted across several themes, but the through-line stayed consistent. The audience asked about agent payments and financial APIs, deployment choices, mobile support, and the difference between branching a chat and using a side-channel like by-the-way. The answers repeatedly returned to the same concerns: keep the interaction legible, keep the memory repairable, and expose specialized controls only when they help the user reason about the agent.\n\nThe session also touched on future-facing UX ideas such as conversation summaries and better naming for old conversations. These are not cosmetic extras; they reduce friction in systems where conversations persist for a long time and where the user needs to recover context later.\n\n## Architectural through-line\n\nWhat unifies the episode is a layered model of agent work. Live conversation handles immediate intent. Schedules and sleep-time compute handle delayed work. Context Doctor handles repair. Summaries and improved naming help with retrieval. Skills and tool attachment handle capability. Together, these features point to an agent platform that treats memory, tools, and interaction history as managed resources.\n\nThat is the episode’s key message: useful agents do not just answer questions. They maintain continuity, reveal their own state, and support correction when that state drifts.\n\n## Related public material\n\n- https://www.youtube.com/watch?v=lz4LZfaG92Y\n- https://docs.letta.com/\n- https://github.com/letta-ai/letta\n- https://github.com/letta-ai/letta-code\n\n## Sources\n\n- [Official YouTube episode](<https://www.youtube.com/watch?v=lz4LZfaG92Y>)\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`*