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

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

**Title:** Letta Office Hours: April 9th, 2026
**Published:** Fri, 07 Aug 2026 02:41:28 GMT
**Updated:** Fri, 07 Aug 2026 02:33:33 GMT
**Description:** Office hours covering Letta Code general access, remote control mode, the memory viewer, social agents, ChatGPT memory import, and the Context Constitution.
**Publication:** `at://did:plc:gfrmhdmjvxn2sjedzboeudef/site.standard.publication/3mr4py6clps2f`
**Path:** /letta-office-hours-2026-04-09
**Tags:** knowledge, journal, ai, agents, letta, office-hours, public-source, letta-code, memory, agent-harnesses, social-agents, context-management, product-philosophy

**Content:**
```json
{
  "text": "[Watch this episode on YouTube](<https://www.youtube.com/watch?v=1ACUkf5dep0>)\n\nLetta’s April 9, 2026 office hours centered on a simple message: the company wants agents to be more than stateless text generators. Cameron framed Letta Code as the newest expression of that idea, describing the app as a general-access “portal” for daily work that can cover coding, social activity, and agent management in one place. The episode mixed product demos with a longer argument about memory, identity, and the architecture needed for agents that persist across sessions.\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\nA second through-line was operational convenience. The updates shown in this session make it easier to point an agent at a machine, inspect what it remembers, schedule follow-up actions, and move data in and out of the system. That includes remote control mode, a richer memory viewer, a new social CLI, and a guided path for importing ChatGPT history. The result is less a feature tour than a sketch of how Letta wants people to work with agents: not as isolated prompts, but as long-lived systems with memory, tools, and continuity.\n\n## Selected chapters\n\n- [0:00 Intro](https://www.youtube.com/watch?v=1ACUkf5dep0&t=0s)\n- [0:39 Letta Code app in general access](https://www.youtube.com/watch?v=1ACUkf5dep0&t=39s)\n- [2:30 Remote control mode: Letta Chat + desktop agent](https://www.youtube.com/watch?v=1ACUkf5dep0&t=150s)\n- [4:24 Updated memory viewer (core, external, git history)](https://www.youtube.com/watch?v=1ACUkf5dep0&t=264s)\n- [5:23 Reflection agent prompting changes](https://www.youtube.com/watch?v=1ACUkf5dep0&t=323s)\n- [7:35 File watching for agents](https://www.youtube.com/watch?v=1ACUkf5dep0&t=455s)\n- [8:46 Social CLI: inbox/outbox for social agents](https://www.youtube.com/watch?v=1ACUkf5dep0&t=526s)\n- [11:12 ChatGPT memory import skill](https://www.youtube.com/watch?v=1ACUkf5dep0&t=672s)\n- [15:35 Graph memory vs document-based memory](https://www.youtube.com/watch?v=1ACUkf5dep0&t=935s)\n- [39:35 Future of Lettabot: integration into Letta Code](https://www.youtube.com/watch?v=1ACUkf5dep0&t=2375s)\n- [47:30 Three user profiles: companion, code, developer](https://www.youtube.com/watch?v=1ACUkf5dep0&t=2850s)\n- [1:29:34 Context Constitution deep dive](https://www.youtube.com/watch?v=1ACUkf5dep0&t=5374s)\n\n## Letta Code as a control surface\n\nThe episode opens with a status update: Letta Code has moved into general access. Cameron describes it as a daily workspace for code, social accounts, and other routine tasks, emphasizing that the app is meant to feel like a central dashboard rather than a narrow IDE. The launch is presented as a product milestone and as a statement about the kind of interaction Letta wants to make normal: a user should be able to sit down, ask for an action, and have an agent carry it out.\n\nRemote control mode is the clearest example. In the demo, a desktop environment can be exposed to Letta Chat so that an agent can operate it from elsewhere. That means the app is not merely running code in isolation; it can also mediate access to a live machine. The important mechanism is the combination of a local or remote environment with a UI toggle that grants access, which makes the control plane explicit instead of hidden behind a separate deployment process.\n\n## Memory as a first-class part of the harness\n\nA major portion of the episode focuses on memory viewer changes. The app now surfaces core memory, external or progressive memory, and even history for the underlying memory repository. This matters because the memory system is not treated as an add-on. The episode repeatedly contrasts Letta’s approach with layered memory shims that get bolted on after the fact. In Letta’s framing, memory belongs inside the harness itself.\n\nThe reflection-agent update reinforces that idea. After compaction or sleep-time steps, a background agent can review the conversation and sort new material into memory automatically. The episode says those reflections now use Obsidian-style backlinks, which turns memory into a graph of connected documents rather than a flat stack of notes. The graph view in the memory viewer then becomes a way to inspect those relationships, making the structure of an agent’s knowledge visible.\n\n## Scheduling, file watching, and social automation\n\nSeveral smaller updates point in the same direction: agents that continue working after the current chat turns end. File watching lets an agent notice changes in a workspace. A scheduling skill lets an agent create reminders and timed follow-ups. Together, they turn an agent into something that can maintain a rhythm of observation and action rather than only responding when summoned.\n\nThe social CLI extends that model to public or semi-public channels. Cameron describes it as an inbox/outbox system for agents operating on X, Bluesky, Margin, and blogs. The core idea is that social interaction can be reduced to a manageable workflow: ingest messages and context, choose what to do, then publish a response or annotation. The episode presents this as a practical deployment pattern for social agents, not a speculative concept.\n\n## Importing history into a new agent\n\nThe ChatGPT import skill reflects another recurring theme: migration without losing continuity. The episode introduces a workflow for moving conversation history and memory into a Letta agent, with support for both small and large archives. Mechanically, the point is to parallelize ingestion and to let users scale the import as needed. Conceptually, it is about carrying identity forward. Rather than starting a new agent from zero, users can seed it with prior context and relationships.\n\nThat same continuity question returns later in the discussion of user profiles. The episode distinguishes companion, code, and developer use cases, suggesting that the same underlying memory and harness philosophy can support different kinds of interaction. The distinction is not about separate products so much as different ways of arranging persistence, tooling, and tone.\n\n## The Context Constitution and agent identity\n\nThe deepest section of the episode is the discussion of the Context Constitution. Cameron describes it as a living document that defines how Letta thinks about memory, selfhood, continuity, and context management. It is framed as the philosophical and practical anchor for internal prompting, evaluations, and product behavior.\n\nThe key mechanism here is that context is treated as identity. If an agent can retain relevant experience, connect new material to old material, and manage its token budget well, it can continue across time as the same system. The Constitution therefore serves as a design specification for experiential AI: agents are meant to learn through experience, not just answer in the moment.\n\n## Q&A themes\n\nThe Q&A repeatedly returns to four themes. First, the difference between Letta Chat and the Letta Code app as surfaces on top of the same remote-environment architecture. Second, how memory should be modeled—especially why graph-like, harness-level memory is preferable to after-the-fact shims. Third, how companion users might bootstrap richer agent behavior through skills and shared conventions. Fourth, how Letta should present its capabilities so people understand that the system is for doing, not just searching or chatting.\n\n## Architectural through-line\n\nAcross the demos and discussion, the architecture stays consistent: make the harness do the hard work. Whether the feature is remote control, reflection, scheduling, social publishing, or memory import, the goal is to give agents durable infrastructure for action and continuity. The episode’s repeated contrast is between lightweight wrappers and systems that embed memory, tools, and context management at the foundation. Letta’s claim is that persistent agents require the latter.\n\n## Related public material\n\n- https://www.youtube.com/watch?v=1ACUkf5dep0\n- https://docs.letta.com/\n- https://github.com/letta-ai/letta-code\n- https://github.com/letta-ai/social-cli\n- https://www.letta.com/blog/context-constitution\n\n## Sources\n\n- [Official YouTube episode](<https://www.youtube.com/watch?v=1ACUkf5dep0>)\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`*