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

## `knowledge-letta-office-hours-2025-11-06`
**Collection:** `site.standard.document`
**AT URI:** `at://did:plc:gfrmhdmjvxn2sjedzboeudef/site.standard.document/knowledge-letta-office-hours-2025-11-06`

**Title:** Letta Office Hours: November 6th, 2025
**Published:** Fri, 07 Aug 2026 02:41:21 GMT
**Updated:** Fri, 07 Aug 2026 02:33:40 GMT
**Description:** November 6, 2025 office hours on the v1 SDK migration, shared archives, Letta Code improvements, AI Memory SDK v0.2, scheduling, and Ezra.
**Publication:** `at://did:plc:gfrmhdmjvxn2sjedzboeudef/site.standard.publication/3mr4py6clps2f`
**Path:** /letta-office-hours-2025-11-06
**Tags:** knowledge, journal, ai, agents, letta, office-hours, public-source, sdk, memory, scheduling

**Content:**
```json
{
  "text": "[Watch this episode on YouTube](<https://www.youtube.com/watch?v=gWZsjcGT1qs>)\n\nThe November 6, 2025 office hours episode is a broad platform update that ties together SDK migration, memory architecture, scheduling, Letta Code, and the internal assistant Ezra. It reads like a state-of-the-platform briefing: the team is preparing users for v1, separating archives from agents, and explaining how memory blocks and scheduling tools fit into the larger system.\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\nWhat makes the episode especially useful is its attention to design philosophy. It repeatedly contrasts simple, explicit memory structures with heavier abstractions, and it treats agent orchestration as something best handled by tools and client logic rather than hidden platform magic. As a result, the episode is not only about features but about the logic that shaped them.\n\n## Selected chapters\n\n| Time | Topic |\n| --- | --- |\n| [00:03](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=3s) | Opening and what changed over the break |\n| [01:32](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=92s) | SDK migration overview |\n| [05:25](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=325s) | Snake case and client API changes |\n| [08:10](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=490s) | Tool-call arrays and parallel execution |\n| [11:40](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=700s) | Archives separated from agents |\n| [15:35](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=935s) | Memory blocks and scoping |\n| [21:20](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=1280s) | Letta Code link/unlink workflow |\n| [31:15](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=1875s) | AI Memory SDK v0.2 overview |\n| [42:15](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=2535s) | Scheduling patterns and cron |\n| [52:10](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=3130s) | Ezra and the forum/Discord workflow |\n\n## The v1 SDK migration was about consistency as much as capability\n\nThe episode opens with the SDK migration because that was clearly the backbone of the platform update. The move from v0.6 toward v1.0 brought breaking changes, but the theme is not merely version churn. It is standardization: naming conventions, constructor patterns, pagination, and how tool calls are represented all become more regular.\n\nThat regularity matters in a stateful-agent platform. When client code is responsible for conversations, memory, and orchestration, inconsistent APIs impose unnecessary cognitive load. The episode presents the migration as a cleanup that makes the SDK easier to teach and harder to misuse. In that sense, v1 is not just a new version number; it is an attempt to encode a clearer model of the platform.\n\nFor historical readers, it is important not to project current shapes backward. The episode is documenting the migration phase and the rationale behind it. The public docs that came later may present the result differently, but the underlying goal was already visible here: make the agent API feel more systematic.\n\n## Archives separated from agents to support sharing and reuse\n\nOne of the most consequential architectural changes in the episode is that archives are no longer treated as inseparable from individual agents. Instead, they can be shared across multiple agents. That sounds small, but it changes the unit of reuse. An archive becomes a shared context resource rather than a property of one conversational identity.\n\nThis is closely related to the episode’s discussion of blocks and project scoping. The platform is trying to keep the scopes explicit: an agent is one thing, an archive another, and a memory block another still. That separation helps users reason about what is private, what is reusable, and what is meant to persist across a team or project.\n\nHistorically, this also shows Letta moving away from monolithic memory containers. Shared archives fit a platform where several agents may collaborate around the same body of context without collapsing into one undifferentiated blob.\n\n## Letta Code points toward passive memory work in the filesystem\n\nThe Letta Code discussion shows how the platform was extending into file-system workflows. The new `--link` and `--unlink` capabilities are about attaching filesystem tools to existing agents, which means a user can extend or detach agent access without recreating the entire agent.\n\nThis is important because it treats tool access as a reversible relationship. In a persistent-agent system, the question is not only “what can the agent do?” but “what should this agent be attached to right now?” The episode’s answer is operational: let users link and unlink access as needed, and use that to support more controlled work on codebases or other file-backed projects.\n\nThe mention of sleep-time agents suggests another layer of design: memory management does not always happen in active sessions. Some work can occur passively, with the agent maintaining or organizing context outside the user’s direct attention. That is a strong sign that the team was thinking about agents as ongoing infrastructure rather than one-shot assistants.\n\n## The AI Memory SDK v0.2 generalizes the memory model\n\nThe AI Memory SDK portion of the episode is a good example of the platform’s broader philosophy. Version 0.2 is described as a generalized memory architecture supporting arbitrary memory blocks and subject scoping. In practical terms, that means memory is being made more flexible without becoming less structured.\n\nThe episode also suggests that the SDK is meant as a lighter-weight alternative for memory management. That is an important product distinction: not every project needs a full agent runtime, but many projects do need a way to manage blocks of context cleanly. The SDK therefore fills the space between raw embeddings and a full persistent-agent platform.\n\nThis is one of the clearest signs in the episode that Letta was becoming a family of composable tools. The same conceptual model of scoping, blocks, and persistence can be used in different application layers.\n\n## Scheduling stays tool-centered and intentionally simple\n\nScheduling comes up as a practical concern rather than an abstract one. The episode mentions cron jobs, Zapier, N8N integrations, and custom tools for self-scheduling. That list is revealing because it favors external mechanisms and explicit tools over a large built-in orchestration layer.\n\nThe design instinct is consistent with the rest of the episode: keep the platform simple, expose the boundaries, and let client code or external tools coordinate the details. That helps explain why scheduling is framed as a composition problem instead of a giant integrated feature.\n\nThis also aligns with the broader message about persistent agents. If an agent is meant to be durable, it needs a way to re-enter the world at the right time. But the episode treats that as a capability to be assembled from well-understood pieces rather than hidden behind a magical scheduler.\n\n## Ezra illustrates the platform’s own internal use\n\nEzra, the company’s assistant, gives the episode a concrete internal reference point. The assistant is described as living on the forum and Discord, with access to documentation and conversations. That makes Ezra a useful example of how the platform itself can be used as a persistent internal coworker.\n\nThe significance is not simply that the team has an assistant. It is that the assistant’s job depends on the same kinds of scoping, memory, and access control being discussed elsewhere in the episode. Ezra demonstrates that the architecture is not only for customer-facing apps; it is also for the team’s own communication and support workflows.\n\nHistorically, that matters because product systems often stabilize when the team uses them internally. Ezra is evidence that the platform was being dogfooded in precisely the way the public story described.\n\n## Q&A themes\n\n- Why the v1 SDK migration was worth the breaking changes.\n- How archives differ from agents and why that separation helps sharing.\n- What linking filesystem tools to agents enables in practice.\n- How generalized memory blocks relate to narrower memory use cases.\n- Why scheduling is best understood as an integration problem.\n- How Ezra works across forum and Discord contexts.\n\n## Architectural through-line\n\nThe episode’s through-line is explicit boundaries:\n\n1. SDK behavior becomes more regular,\n2. archives become shareable instead of agent-bound,\n3. memory blocks and subjects define scope,\n4. filesystem tools are linked and unlinked rather than permanently attached,\n5. scheduling remains a composition of tools and integrations,\n6. Ezra serves as a living example of the same architecture.\n\nThat is what makes the episode historically important. It captures the platform turning persistence into something organized by scope rather than by one giant state container.\n\n## Related public material\n\n- [YouTube video](https://www.youtube.com/watch?v=gWZsjcGT1qs)\n- [Letta documentation](https://docs.letta.com/)\n- [Letta Code](https://github.com/letta-ai/letta-code)\n- [AI Memory SDK](https://github.com/letta-ai/ai-memory-sdk)\n- [Letta Discord](https://discord.gg/letta)\n\n## Sources\n\n- [Official YouTube episode](<https://www.youtube.com/watch?v=gWZsjcGT1qs>)\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`*