From 5fee6e8748d77cb7e29e3656586a085e9f55bfa4 Mon Sep 17 00:00:00 2001 From: Cameron Pfiffer Date: Thu, 6 Aug 2026 19:44:27 -0700 Subject: [PATCH] Publish the Letta Office Hours archive. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add historical episode guides and a navigable series map so the public knowledge base preserves the architecture discussed across the full public recording archive. 👾 Generated with [Letta Code](https://letta.com) Co-Authored-By: Letta Code --- .../letta-office-hours-2025-09-25.md | 111 +++++++++++++ .../letta-office-hours-2025-10-02.md | 136 +++++++++++++++ .../letta-office-hours-2025-10-16.md | 140 ++++++++++++++++ .../letta-office-hours-2025-10-30.md | 145 ++++++++++++++++ .../letta-office-hours-2025-11-06.md | 149 +++++++++++++++++ .../letta-office-hours-2025-12-04.md | 155 ++++++++++++++++++ .../letta-office-hours-2025-12-18.md | 123 ++++++++++++++ .../letta-office-hours-2026-01-09.md | 119 ++++++++++++++ .../letta-office-hours-2026-01-26.md | 115 +++++++++++++ .../letta-office-hours-2026-01-29.md | 123 ++++++++++++++ .../letta-office-hours-2026-02-05.md | 120 ++++++++++++++ .../letta-office-hours-2026-02-26.md | 110 +++++++++++++ .../letta-office-hours-2026-03-05.md | 113 +++++++++++++ .../letta-office-hours-2026-03-12.md | 126 ++++++++++++++ .../letta-office-hours-2026-03-19.md | 119 ++++++++++++++ .../letta-office-hours-2026-03-26.md | 115 +++++++++++++ .../letta-office-hours-2026-04-02.md | 120 ++++++++++++++ .../letta-office-hours-2026-04-09.md | 121 ++++++++++++++ .../letta-office-hours-2026-04-16.md | 116 +++++++++++++ .../letta-office-hours-2026-04-23.md | 120 ++++++++++++++ .../letta-office-hours-2026-05-01.md | 113 +++++++++++++ .../letta-office-hours-2026-05-08.md | 121 ++++++++++++++ .../letta-office-hours-2026-05-14.md | 123 ++++++++++++++ .../letta-office-hours-2026-05-21.md | 133 +++++++++++++++ .../letta-office-hours-2026-06-19.md | 117 +++++++++++++ .../letta-office-hours-2026-06-29.md | 115 +++++++++++++ .../letta-office-hours-2026-07-02.md | 111 +++++++++++++ .../letta-office-hours-2026-07-09.md | 118 +++++++++++++ .../letta-office-hours-2026-07-16.md | 131 +++++++++++++++ .../letta-office-hours-2026-07-23.md | 132 +++++++++++++++ .../letta-office-hours-2026-07-30.md | 135 +++++++++++++++ knowledge/published/letta-office-hours.md | 143 ++++++++++++++++ .../letta-office-hours-2025-09-25.json | 20 +++ .../letta-office-hours-2025-10-02.json | 20 +++ .../letta-office-hours-2025-10-16.json | 20 +++ .../letta-office-hours-2025-10-30.json | 20 +++ .../letta-office-hours-2025-11-06.json | 20 +++ .../letta-office-hours-2025-12-04.json | 20 +++ .../letta-office-hours-2025-12-18.json | 20 +++ .../letta-office-hours-2026-01-09.json | 20 +++ .../letta-office-hours-2026-01-26.json | 20 +++ .../letta-office-hours-2026-01-29.json | 20 +++ .../letta-office-hours-2026-02-05.json | 20 +++ .../letta-office-hours-2026-02-26.json | 20 +++ .../letta-office-hours-2026-03-05.json | 20 +++ .../letta-office-hours-2026-03-12.json | 20 +++ .../letta-office-hours-2026-03-19.json | 20 +++ .../letta-office-hours-2026-03-26.json | 20 +++ .../letta-office-hours-2026-04-02.json | 20 +++ .../letta-office-hours-2026-04-09.json | 20 +++ .../letta-office-hours-2026-04-16.json | 20 +++ .../letta-office-hours-2026-04-23.json | 20 +++ .../letta-office-hours-2026-05-01.json | 20 +++ .../letta-office-hours-2026-05-08.json | 20 +++ .../letta-office-hours-2026-05-14.json | 20 +++ .../letta-office-hours-2026-05-21.json | 20 +++ .../letta-office-hours-2026-06-19.json | 20 +++ .../letta-office-hours-2026-06-29.json | 20 +++ .../letta-office-hours-2026-07-02.json | 20 +++ .../letta-office-hours-2026-07-09.json | 20 +++ .../letta-office-hours-2026-07-16.json | 20 +++ .../letta-office-hours-2026-07-23.json | 20 +++ .../letta-office-hours-2026-07-30.json | 20 +++ .../letta-office-hours.json | 20 +++ 64 files changed, 4628 insertions(+) create mode 100644 knowledge/published/letta-office-hours-2025-09-25.md create mode 100644 knowledge/published/letta-office-hours-2025-10-02.md create mode 100644 knowledge/published/letta-office-hours-2025-10-16.md create mode 100644 knowledge/published/letta-office-hours-2025-10-30.md create mode 100644 knowledge/published/letta-office-hours-2025-11-06.md create mode 100644 knowledge/published/letta-office-hours-2025-12-04.md create mode 100644 knowledge/published/letta-office-hours-2025-12-18.md create mode 100644 knowledge/published/letta-office-hours-2026-01-09.md create mode 100644 knowledge/published/letta-office-hours-2026-01-26.md create mode 100644 knowledge/published/letta-office-hours-2026-01-29.md create mode 100644 knowledge/published/letta-office-hours-2026-02-05.md create mode 100644 knowledge/published/letta-office-hours-2026-02-26.md create mode 100644 knowledge/published/letta-office-hours-2026-03-05.md create mode 100644 knowledge/published/letta-office-hours-2026-03-12.md create mode 100644 knowledge/published/letta-office-hours-2026-03-19.md create mode 100644 knowledge/published/letta-office-hours-2026-03-26.md create mode 100644 knowledge/published/letta-office-hours-2026-04-02.md create mode 100644 knowledge/published/letta-office-hours-2026-04-09.md create mode 100644 knowledge/published/letta-office-hours-2026-04-16.md create mode 100644 knowledge/published/letta-office-hours-2026-04-23.md create mode 100644 knowledge/published/letta-office-hours-2026-05-01.md create mode 100644 knowledge/published/letta-office-hours-2026-05-08.md create mode 100644 knowledge/published/letta-office-hours-2026-05-14.md create mode 100644 knowledge/published/letta-office-hours-2026-05-21.md create mode 100644 knowledge/published/letta-office-hours-2026-06-19.md create mode 100644 knowledge/published/letta-office-hours-2026-06-29.md create mode 100644 knowledge/published/letta-office-hours-2026-07-02.md create mode 100644 knowledge/published/letta-office-hours-2026-07-09.md create mode 100644 knowledge/published/letta-office-hours-2026-07-16.md create mode 100644 knowledge/published/letta-office-hours-2026-07-23.md create mode 100644 knowledge/published/letta-office-hours-2026-07-30.md create mode 100644 knowledge/published/letta-office-hours.md create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2025-09-25.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2025-10-02.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2025-10-16.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2025-10-30.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2025-11-06.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2025-12-04.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2025-12-18.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-01-09.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-01-26.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-01-29.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-02-05.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-02-26.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-03-05.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-03-12.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-03-19.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-03-26.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-04-02.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-04-09.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-04-16.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-04-23.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-05-01.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-05-08.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-05-14.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-05-21.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-06-19.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-06-29.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-07-02.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-07-09.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-07-16.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-07-23.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours-2026-07-30.json create mode 100644 knowledge/receipts/technical-publication/letta-office-hours.json diff --git a/knowledge/published/letta-office-hours-2025-09-25.md b/knowledge/published/letta-office-hours-2025-09-25.md new file mode 100644 index 0000000..3c4ffa0 --- /dev/null +++ b/knowledge/published/letta-office-hours-2025-09-25.md @@ -0,0 +1,111 @@ +--- +title: 'Letta Discord Office Hours: September 25th, 2025' +slug: letta-office-hours-2025-09-25 +summary: >- + Office hours on the AI SDK v5 update, cloud reliability work, open-source + release planning, memory behavior, and model/provider recommendations. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - ai-sdk-v5 + - letta-cloud-reliability + - open-source-release-planning + - memory-architecture + - model-and-provider-guidance +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=UoUnApXDcZ8' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:2c250eae576c54055415c618113a70c9ca2886cbb9454f4bd44838d04d51754a' +updated: '2026-08-07T02:33:42.274Z' +reviewStatus: approved +youtubeVideoId: UoUnApXDcZ8 +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:19.313Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2025-09-25 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2025-09-25.json + receiptDigest: 'sha256:6a8ba23ddc01286d4284323797b004320b3f3cdf0f50867f0656e0dfc15f36ab' +publishedAt: '2026-08-07T02:41:19.313Z' +reviewedContentDigest: 'sha256:de3cd1513f57dc87bd7c7e3abf552e548f690f2a57c5dedc42a2f533149e2e7b' +reviewReceiptDigest: 'sha256:6a8ba23ddc01286d4284323797b004320b3f3cdf0f50867f0656e0dfc15f36ab' +--- +Letta’s September 25, 2025 office hours focused on a mix of immediate product changes and longer-horizon infrastructure work. The clearest user-facing update was support for Vercel’s AI SDK v5, which replaces the older v4 integration and gives front-end developers more control over provider options while preserving the basic pattern of talking to Letta agents through a standardized interface. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The rest of the session moved between cloud architecture, open-source coordination, and practical advice for people building on the stack. The discussion emphasized that several changes were announced as in-progress experiments or internal rollouts, not universal product behavior. In particular, the episode framed Temporal migration, PlanetScale adoption, and agent-loop redesigns as reliability and scalability work underway behind the scenes. + +## Selected chapters +- [00:00:30](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=30s) AI SDK v5 replaces the older integration +- [00:01:30](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=90s) Why the SDK matters for front-end agent apps +- [00:03:00](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=180s) Architectural revisions for cloud scale +- [00:03:30](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=210s) Temporal for agent-loop execution and retries +- [00:05:30](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=330s) Database migration to PlanetScale +- [00:07:30](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=450s) Proxy compatibility and OpenAI-style endpoints +- [00:09:00](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=540s) Responses API support and agent type constraints +- [00:14:00](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=840s) Community contribution paths and roadmap gaps +- [00:17:30](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=1050s) V1 release planning and migration guidance +- [00:20:00](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=1200s) Why dynamic memory swapping is hard today +- [00:24:00](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=1440s) Removing strict tool-call requirements for broader providers +- [00:29:00](https://www.youtube.com/watch?v=UoUnApXDcZ8&t=1740s) Local and offline model recommendations + +## AI SDK v5 and the front-end integration layer +The episode’s main product announcement was the move from AI SDK v4 to v5. The AI SDK is presented as Vercel’s abstraction for building language-model features in web apps, with Letta agents exposed through that layer. The practical point is less about a new model capability than about a cleaner interface for application developers: v5 adds better type safety and more control over provider options, which makes it easier to tune inference behavior from the client side. + +The architectural implication is that Letta can be swapped into front-end stacks that already expect a standardized model-provider interface. That means teams can preserve their app structure while changing the underlying inference engine, which is especially useful for builders already invested in TypeScript and Vercel-adjacent tooling. + +## Cloud reliability work under the hood +A second major theme was reliability engineering on Letta Cloud. The team described a migration of the agent-loop execution engine to Temporal, a workflow system that makes rescheduling and failure recovery easier than the older asynchronous setup. The benefit discussed was not simply speed, but observability: when something fails, the hope is that the system can explain what happened instead of surfacing a generic server error. + +The episode also mentioned a backend database move to PlanetScale and broader cloud-performance revisions. These were framed as scaling and latency improvements, not as changes that would necessarily affect self-hosted users. The important takeaway is that the cloud stack is being reworked to make operational behavior more legible and resilient while keeping the open-source path comparatively stable for now. + +## Open-source release planning and community support +The conversation repeatedly returned to open-source coordination. A v1 release is being prepared as a breaking release, with the intention of batching changes together and eventually publishing migration guidance. The episode suggests that many of the changes are already known internally, but that they need to be documented more clearly so contributors and users can see what is changing and why. + +There was also explicit reflection on contribution pathways. The team wants a more usable roadmap for community contributors, plus a clearer way to mark features as community-supported when they fall outside the core maintenance surface. In other words, the episode treats open source not as a static code dump but as a living collaboration problem that requires better scope-setting and documentation. + +## Memory behavior and agent-loop constraints +A more technical section focused on memory block swapping and archival memory. The core issue is that the current agent loop carries pickled state, which can drift from any memory changes made through the API while a loop is in progress. That makes fully agentic memory management difficult today, especially when adding or reconfiguring blocks dynamically. + +The proposed direction is to simplify the loop by giving clients the agent ID and a Letta client, rather than hiding too much state inside the loop itself. Once that changes, dynamic memory management becomes much easier. Until then, archival memory is described as workable but somewhat hacky: tagging memories by repo name and including paths inside the content can help retrieval, but it is not a clean file-system replacement. + +## Broader provider compatibility +Another practical subject was provider support. The episode noted that strict tool-call enforcement limits compatibility with providers that do not reliably emit tool calls, and that a future agent-loop update should relax that requirement. That would make it possible to use more providers in Letta Cloud, even if they sometimes return ordinary assistant text instead of structured tool output. + +The same section distinguished between providers built for agentic workflows and those that are not. The recommendation was not “everything works equally well,” but rather that the platform is moving toward better tolerance for imperfect providers while still warning users when a service is known to degrade agent behavior. + +## Q&A themes +The questions clustered around three recurring concerns: endpoint compatibility, memory operations, and model choice. Viewers asked about OpenAI-compatible proxies, Responses API support, and streaming behavior, while the answers emphasized that some features were available only in specific agent configurations or were still being validated. + +Another thread involved what kinds of local models work best. The guidance highlighted Qwen 3 as the most broadly solid choice for tool calling, with GPT-OSS also viable, while Mistral and Gemma were described more skeptically. The recurring criterion was not raw benchmark status, but whether a model behaves well in agentic, tool-using loops. + +## Architectural through-line +The through-line of the episode is a shift from ad hoc integration toward systems that are easier to compose, observe, and extend. AI SDK v5 standardizes the front-end interface. Temporal and PlanetScale harden the cloud. The agent-loop redesign aims to loosen assumptions that currently block memory flexibility and provider diversity. Each topic points to the same design direction: make Letta more modular at the edges while reducing operational fragility at the center. + +## Related public material +- https://www.youtube.com/watch?v=UoUnApXDcZ8 +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code diff --git a/knowledge/published/letta-office-hours-2025-10-02.md b/knowledge/published/letta-office-hours-2025-10-02.md new file mode 100644 index 0000000..a2e8999 --- /dev/null +++ b/knowledge/published/letta-office-hours-2025-10-02.md @@ -0,0 +1,136 @@ +--- +title: 'Letta Discord Office Hours: October 2nd, 2025' +slug: letta-office-hours-2025-10-02 +summary: >- + October 2, 2025 office hours on the v1 alpha, memory tools, mobile agents, + Obsidian, Bluesky, and the shift toward a new agent architecture. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - memory + - sdk +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=BPqDTs77Ys4' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:a5fe49675cab936aed6dbb278bc8e154a55dcefb798766eab14d5e3cdcc1ae16' +updated: '2026-08-07T02:33:41.744Z' +reviewStatus: approved +youtubeVideoId: BPqDTs77Ys4 +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:19.853Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2025-10-02 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2025-10-02.json + receiptDigest: 'sha256:b96710d6941ae026703e996b208b72c394f30a0da81479dfd0ff89af1f4e762c' +publishedAt: '2026-08-07T02:41:19.853Z' +reviewedContentDigest: 'sha256:7fdf176e826ff83f04957809c82af0d9544c714ef57a49ac054b3d9724fb3d63' +reviewReceiptDigest: 'sha256:b96710d6941ae026703e996b208b72c394f30a0da81479dfd0ff89af1f4e762c' +--- +The October 2, 2025 Letta office hours episode sits at an important transition point. The discussion centers on the v1 alpha release, a new agent architecture that no longer requires the traditional send-message tool pattern, and a memory tool that lets agents manage their own memory blocks. In practical terms, the session reframes Letta less as a single chat surface and more as a set of programmable building blocks for persistent systems. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The episode also shows how that architecture was being tested in real workflows: a personal agent demo, Obsidian plugin updates, Bluesky deployment ideas, and comparisons between self-hosting and cloud setups. Read historically, the conversation is not a current product manual so much as a snapshot of how the team was trying to make stateful agents more flexible across models, interfaces, and deployment environments. + +## Selected chapters + +| Time | Topic | +| --- | --- | +| [00:03](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=3s) | Session framing and what is changing | +| [00:34](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=34s) | Public announcement of the v1 direction | +| [01:02](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=62s) | What the AI SDK is in this context | +| [05:02](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=302s) | Agent architecture and model compatibility | +| [08:13](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=493s) | Memory tool and agent-managed memory | +| [14:10](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=850s) | Personal agent demo and mobile workflow | +| [22:06](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=1326s) | Obsidian plugin and knowledge workflows | +| [31:10](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=1870s) | Bluesky and deployment ideas | +| [36:52](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=2212s) | Self-hosting versus cloud tradeoffs | +| [40:34](https://www.youtube.com/watch?v=BPqDTs77Ys4&t=2434s) | Wrap-up of the core architectural argument | + +## The v1 alpha rethinks how an agent is allowed to act + +The headline change in this episode is the v1 alpha. The official description frames it as a major new agent architecture that works with any chat model, including providers that previously had compatibility problems. Captions and discussion suggest that the key move was to remove a hard dependency on a specialized send-message tool pattern. Historically, that meant an agent could be easier to connect to models that already spoke ordinary chat-completions style APIs. + +That matters because it changes the role of the model. Rather than assuming one specific tool contract, the architecture aims to let Letta mediate the conversation and memory management around more model types. For readers encountering the current docs later, the historical boundary matters: the episode is documenting the team’s path toward a more model-agnostic architecture, not claiming that every downstream detail had already stabilized. + +[Current Letta documentation](https://docs.letta.com/) now presents a broader platform, but the episode should be read as a product transition moment. The technical point is not that all models are equal in every sense; it is that the agent layer was being redesigned to reduce assumptions about how models had to be wrapped. + +## The memory tool moves memory management closer to the agent + +The other defining announcement is the memory tool. The episode describes it as a way for agents to fully manage their own memory blocks. That is a subtle but important shift. Instead of treating memory as something only the user or platform operator curates externally, the agent can participate in writing, updating, and organizing its own scoped memory. + +In architectural terms, this sits between static prompt injection and free-form conversational remembering. The idea is not that the model gets unlimited self-modification, but that memory becomes an explicit tool surface with boundaries. That makes memory more actionable: a task can cause a memory update, a memory block can be scoped to a user or project, and future interactions can retrieve that state without re-litigating the same setup. + +The episode also includes discussion of project-scoped and identity-scoped behavior. Even if the exact UI and naming later changed, the underlying design principle is visible: persistent agents work best when memory is partitioned by what should survive, what should be shared, and what should remain local to one agent identity. + +## Mobile and personal-agent demos show the intended user experience + +The personal-agent demo matters because it makes the architecture concrete. Rather than speaking only about infrastructure, the episode explores what it feels like to interact with a stateful agent on a mobile device. That includes practical questions about notifications, quick interactions, and how a user re-enters a long-running relationship with an agent. + +The demo also surfaces an important design tension. A personal agent is not just a chatbot with a profile picture. It is a service that may need memory, scheduling, and multiple interaction channels while remaining understandable to the person using it. The episode’s examples hint at a product philosophy: if the agent is meant to be persistent, then the interface must help the user recognize continuity without hiding where the state lives. + +A historical reading should keep the demo in context. This was not a claim that the personal-agent story was finished, only that the team considered it a meaningful application of the v1 architecture. The episode therefore acts as evidence of product intent as much as it does of shipped behavior. + +## Obsidian and Bluesky point to knowledge-sharing use cases + +The episode’s Obsidian discussion is especially useful because it shows the same memory architecture being applied to note-taking and knowledge management. That is a familiar pattern in Letta’s public work: durable memory is not only for agent autonomy, but also for helping people structure what an agent knows about a project or a corpus of notes. + +Bluesky comes up as another deployment target, which is helpful historically because it shows the team was already thinking beyond one canonical chat interface. A stateful agent architecture becomes more interesting when it can inhabit different surfaces: a note system, a social account, a web frontend, or a personal workflow. The episode suggests that the real unit is not the chat window but the long-lived agent and its managed state. + +That is also why the boundary between public product ideas and experimental demos matters. The episode connects these use cases by analogy, but it does not claim that every channel or plugin had the same maturity level. + +## Self-hosting versus cloud remained an open tradeoff + +The closing discussion returns to deployment choices. Self-hosting gives control and local proximity to data, while cloud deployment can make persistence, access, and operations easier. The episode does not resolve that tension; it uses it to explain why a stateful-agent platform has to support more than one operational model. + +This is one reason the v1 architecture is significant. When models, memory, tools, and deployment can vary independently, the platform can fit more workflows. The cost is complexity: users need to understand where state lives and how an agent continues across sessions. The episode’s value lies in making that tradeoff visible rather than pretending one deployment story fits all. + +## Q&A themes + +- Whether the new architecture depends on a particular model family or can support broader model compatibility. +- How the memory tool should be thought about: as automation, as user assistance, or as agent-owned state. +- What a personal agent should feel like in everyday use, especially on mobile. +- How the Obsidian plugin fits into knowledge workflows rather than just chat. +- Whether self-hosted and cloud deployments are interchangeable or serve different needs. + +## Architectural through-line + +The episode’s through-line is that stateful agents become more usable when the platform separates concerns that were previously bundled together: + +1. model compatibility is separated from a single tool contract, +2. memory management is separated into its own explicit surface, +3. user-facing experiences can vary by channel or app, +4. deployment can remain flexible across self-hosted and cloud environments. + +That separation is the story beneath the announcements. The episode marks a moment when Letta was making persistent behavior less dependent on one fixed interface and more like a system of composable agent capabilities. + +## Related public material + +- [YouTube video](https://www.youtube.com/watch?v=BPqDTs77Ys4) +- [Letta documentation](https://docs.letta.com/) +- [Letta GitHub organization](https://github.com/letta-ai) +- [Letta Code](https://github.com/letta-ai/letta-code) +- [Letta Obsidian plugin](https://github.com/cpfiffer/letta-obsidian) +- [Bluesky](https://bsky.app/) diff --git a/knowledge/published/letta-office-hours-2025-10-16.md b/knowledge/published/letta-office-hours-2025-10-16.md new file mode 100644 index 0000000..de866ed --- /dev/null +++ b/knowledge/published/letta-office-hours-2025-10-16.md @@ -0,0 +1,140 @@ +--- +title: 'Letta Discord Office Hours: October 16th, 2025' +slug: letta-office-hours-2025-10-16 +summary: >- + October 16, 2025 office hours on voice support, the runs viewer, Telegram + improvements, stateful-agent patterns, and practical tips for building with + memory. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - voice + - telegram + - memory +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=l-HAr-y1CAA' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:9b4036db4b984bfa5f138768ea0aaab9379574b3250cb5dc64ea91c1303d2ba8' +updated: '2026-08-07T02:33:41.228Z' +reviewStatus: approved +youtubeVideoId: l-HAr-y1CAA +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:20.408Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2025-10-16 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2025-10-16.json + receiptDigest: 'sha256:7f3a9463b90bf4dbe3c1715775b994b5048d314ec1d81e6c9783e4f4cff1ccb0' +publishedAt: '2026-08-07T02:41:20.408Z' +reviewedContentDigest: 'sha256:5df1770af46fc61bde69a029050ee4b8f23d0746c06d47c11759c36f23e78987' +reviewReceiptDigest: 'sha256:7f3a9463b90bf4dbe3c1715775b994b5048d314ec1d81e6c9783e4f4cff1ccb0' +--- +The October 16, 2025 office hours episode is a transitional update on the platform rather than a single feature demo. It covers voice-agent plumbing, improvements to the runs viewer, Telegram bot capabilities, error reporting, and practical patterns for using Letta in stateful applications. The session also includes guidance on multiple users, multiple agents, shared memory, and how to scale an agent system without letting context blow up. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +What makes the episode useful historically is that it condenses product direction into operational advice. The team is not only listing features; it is explaining how persistent agents should be wired into apps, how memory should be partitioned, and why the public API was moving toward clearer modeling of state, tools, and interactions. Read today, it functions as a snapshot of how Letta was trying to become a practical agent platform rather than just a research prototype. + +## Selected chapters + +| Time | Topic | +| --- | --- | +| [00:03](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=3s) | Opening and session framing | +| [00:33](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=33s) | What changed since the previous update | +| [01:31](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=91s) | Voice agents and chat-completions direction | +| [05:20](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=320s) | Runs viewer and UI changes | +| [09:05](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=545s) | Telegram bot improvements | +| [13:10](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=790s) | Memory, multiple users, and scaling patterns | +| [21:40](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=1300s) | Next.js integration guidance | +| [28:15](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=1695s) | Tool overload and MCP discussion | +| [35:05](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=2105s) | Statefulness, app design, and memory boundaries | +| [42:40](https://www.youtube.com/watch?v=l-HAr-y1CAA&t=2560s) | Q&A on agent behavior and debugging | + +## Voice support was being treated as an application concern, not a side feature + +One of the episode’s clearest themes is that voice support was coming through the existing chat-completions style endpoint rather than as an isolated special case. Historically, that matters because it shows the team trying to make voice another manifestation of the same agent runtime, not a completely separate product. + +The practical implication is that the agent layer must preserve conversation state, tool access, and model choice even when the input and output modality changes. In other words, voice is not simply speech-to-text wrapped around a chat app; it is a transport and interface concern layered on top of the same stateful-agent architecture. The episode frames that as part of the broader platform evolution rather than as a standalone feature. + +For readers comparing with current docs, the boundary is important. The episode documents what was being explored in October 2025, not every later integration or naming convention. Use the episode as evidence for design intent, not as a current contract. + +## The runs viewer made internal behavior easier to inspect + +The runs viewer is another small but revealing change. The episode treats it as a way to show messages and execution more clearly inside the UI. That kind of observability feature is easy to overlook, but for stateful agents it is central: users need to see what the agent saw, what it tried, and where a failure happened. + +The significance is not merely cosmetic. A system that stores memory, calls tools, and may operate across several channels becomes much harder to trust if its execution trail is opaque. The runs viewer pushes in the opposite direction by making agent activity more legible. That is a recurring theme in Letta’s public material: persistent systems need persistent inspection. + +Historically, this also fits the platform’s broader effort to make development feel less like inference black-boxing and more like working with an inspectable runtime. The episode’s emphasis on improved error messages reinforces that point. + +## Telegram improvements show how multi-modal access was becoming real + +The Telegram bot updates in the episode are useful because they show the team working through everyday agent ergonomics: voice, images, multi-agent switching, shortcuts, and mobile usage. Telegram is not just a toy integration here; it serves as a proof point for how a persistent agent can live in a messaging environment people already use. + +That matters because user adoption is often defined by the shortest path to interaction. If people can log in, select an agent, and move between agents on a phone, the platform begins to look more like an ongoing companion system than a developer demo. The episode suggests that Letta was pushing toward that experience while still keeping the underlying memory architecture visible. + +The historical boundary remains important. The episode gives a strong sense of the intended Telegram workflow, but it should not be read as claiming that every edge case had been solved. The practical value is in understanding the pattern: channels are ways persistent agents meet users where they already are. + +## Memory management stayed central to everything else + +A major portion of the session is about stateful-agent patterns: proactive memory, multiple users, separate memory blocks, and scaling to thousands of entities without overflowing context. These are not separate topics; they are different views of the same problem. A durable agent only works if identity, user state, and task context stay partitioned. + +The episode’s advice is therefore structural. Letta’s memory model is not about stuffing ever more text into a single conversation. It is about choosing what belongs in long-term blocks, what belongs in a particular user or identity scope, and what should remain ephemeral. That is why the discussion about blocks and scoping matters more than any one implementation detail. + +This is also where the product philosophy becomes visible. The team repeatedly prefers explicit memory surfaces and client-side orchestration over hidden magic. That makes the system more complex to learn, but it also makes persistent behavior easier to reason about and debug. + +## Next.js and MCP show the platform moving into real integrations + +The episode’s practical integration advice suggests that Letta was being positioned as something developers could drop into an application stack rather than only a standalone workspace. Next.js appears as a familiar web-app context, while MCP is discussed in relation to tool handling and overload. + +That combination is revealing. App developers want a familiar frontend/backend path, but agent systems also have to tolerate tool sprawl. When too many tools are attached, the runtime can become unwieldy or confusing. The episode’s framing implies that part of the engineering work was not just adding capabilities but constraining them into manageable surfaces. + +For historical interpretation, this is a sign that the platform was moving from “can we build an agent?” toward “can we make this agent fit the way product teams already ship software?” + +## Q&A themes + +- How voice agents should share the same runtime assumptions as text agents. +- Why runs and errors need to be visible if the system is meant to be trusted. +- How to support multiple users without collapsing all context into one memory store. +- Whether Telegram should be understood as a messaging channel or a primary product surface. +- How to connect Letta to a conventional app stack without overloading the tool layer. + +## Architectural through-line + +The episode’s through-line is separation of concerns in a stateful system: + +1. voice is layered on the same agent runtime, +2. the runs viewer makes execution inspectable, +3. Telegram is one channel among several, +4. memory blocks and identity scopes keep user state from collapsing, +5. integrations such as Next.js and MCP are handled as application interfaces rather than as special cases. + +That architecture makes the platform more composable, but it also makes the mental model less obvious. The episode is valuable because it explains both sides of that tradeoff. + +## Related public material + +- [YouTube video](https://www.youtube.com/watch?v=l-HAr-y1CAA) +- [Letta documentation](https://docs.letta.com/) +- [Telegram bot guide](https://docs.letta.com/guides/telegram-bot) +- [Model Context Protocol](https://modelcontextprotocol.io/) +- [Next.js](https://nextjs.org/) diff --git a/knowledge/published/letta-office-hours-2025-10-30.md b/knowledge/published/letta-office-hours-2025-10-30.md new file mode 100644 index 0000000..7c0e1e2 --- /dev/null +++ b/knowledge/published/letta-office-hours-2025-10-30.md @@ -0,0 +1,145 @@ +--- +title: 'Letta Office Hours: October 30th, 2025' +slug: letta-office-hours-2025-10-30 +summary: >- + October 30, 2025 office hours on Letta Code, Co, the Obsidian plugin, personal + agents, and the platform shift toward terminal-first and note-centric + workflows. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-code + - obsidian +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=63OkozcdjmY' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:6acbd05a193a59942b810f0ffc7f3ac18c3d4127e5ff86d120a77c08c2055b54' +updated: '2026-08-07T02:33:40.686Z' +reviewStatus: approved +youtubeVideoId: 63OkozcdjmY +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:20.957Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2025-10-30 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2025-10-30.json + receiptDigest: 'sha256:a4f2a5c721140be37d5732a43c28104c1acbd220d38108fdd61b08d7cc925c22' +publishedAt: '2026-08-07T02:41:20.957Z' +reviewedContentDigest: 'sha256:794ac59d44525b03d471d1cd48d25176ce2235a68dc5aa2acdd788e911e98c20' +reviewReceiptDigest: 'sha256:a4f2a5c721140be37d5732a43c28104c1acbd220d38108fdd61b08d7cc925c22' +--- +The October 30, 2025 office hours episode is one of the clearest pictures of Letta moving from a single chat interface toward a family of agent-centered tools. The discussion covers Letta Code, the Co frontend, and an Obsidian plugin for manual context management. Those pieces are not merely products in parallel; together they show the team experimenting with where persistent agents should live and how users should shape their context. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +Because the episode is broad, it also works well as a historical explainer of the product’s mental model. The team talks about personal agents, infrastructure-oriented workflows, and the tension between convenience and control. In that sense, the episode captures the moment when Letta’s public story started to look like a platform for different agent surfaces rather than one opinionated app. + +## Selected chapters + +| Time | Topic | +| --- | --- | +| [00:03](https://www.youtube.com/watch?v=63OkozcdjmY&t=3s) | Opening and session setup | +| [00:33](https://www.youtube.com/watch?v=63OkozcdjmY&t=33s) | Why there is a lot to cover | +| [00:52](https://www.youtube.com/watch?v=63OkozcdjmY&t=52s) | Letta Code and terminal-first agents | +| [04:20](https://www.youtube.com/watch?v=63OkozcdjmY&t=260s) | Co and consumer-facing agent workflows | +| [08:05](https://www.youtube.com/watch?v=63OkozcdjmY&t=485s) | Obsidian plugin and context management | +| [14:15](https://www.youtube.com/watch?v=63OkozcdjmY&t=855s) | Personal agents and user expectations | +| [22:30](https://www.youtube.com/watch?v=63OkozcdjmY&t=1350s) | Infrastructure and deployment concerns | +| [30:05](https://www.youtube.com/watch?v=63OkozcdjmY&t=1805s) | Memory, note-taking, and context boundaries | +| [38:40](https://www.youtube.com/watch?v=63OkozcdjmY&t=2320s) | The platform’s public-facing shape | +| [46:10](https://www.youtube.com/watch?v=63OkozcdjmY&t=2770s) | Q&A on workflows and control | + +## Letta Code made the terminal a serious agent surface + +The headline feature in this episode is Letta Code, described as a research preview of a terminal coding assistant. Historically, that matters because it shows the team treating the terminal as a first-class agent environment rather than a stopgap. The agent is not just answering questions; it is learning a codebase, staying stateful across work, and acting as a long-lived collaborator. + +That framing explains why the episode is so interested in filesystem access, codebase memory, and workflow continuity. A terminal assistant has access to local context that a web chat often lacks. The value of a stateful agent in that setting is not raw code generation alone, but continuity across sessions and an ability to accumulate project knowledge over time. + +For readers looking at current Letta materials, the historical boundary matters. The episode documents the preview stage of this idea, when the public narrative was still being formed. It should be read as evidence of where the platform was headed, not as a promise that every terminal feature had already settled into its final shape. + +## Co and the shift toward consumer-facing agent interaction + +The Co frontend appears in the episode as a consumer-facing way to work with Letta agents. That is important historically because it shows the team thinking about users who want an approachable interface for long-lived agents, not only developers embedding the system in their own stacks. + +The distinction between Letta Code and Co is useful. One leans into developer productivity and codebase interaction; the other explores a more general end-user front end. Together they imply that the agent runtime was being abstracted away from any single UI. That is a common maturation step in platform design: once the core is stable enough, the interface can vary by audience. + +The episode does not suggest that one interface replaces the other. Instead, it presents them as complementary expressions of the same persistent-agent model. That makes the episode a good historical marker for the moment when Letta began to look like a toolkit for multiple product shapes. + +## The Obsidian plugin shows context management as a user practice + +The Obsidian plugin discussion is one of the most revealing parts of the episode because it pushes context management into a note-taking workflow. Manual context management sounds mundane, but in a stateful-agent system it is a deep design choice. It means users can deliberately decide what knowledge enters the agent’s working set and what stays outside it. + +That is an important counterweight to the idea that agents should automatically absorb everything. The episode’s approach suggests that a good memory system is not just about retention; it is about curation, scope, and user intent. Obsidian is a natural fit because it already functions as a structured personal knowledge space. + +The public significance is broader than one plugin. It shows the team treating external knowledge tools as part of the agent stack. In that sense, the episode points toward an ecosystem model: notes, terminal, and chat are all different ways to shape the same long-lived context. + +## Personal agents raise expectations around continuity and control + +The discussion of personal agents is especially useful for understanding Letta’s public philosophy. A personal agent is not valuable because it can answer one prompt; it is valuable because it can preserve continuity across time, channels, and tasks. That makes user trust and control central issues. + +The episode implies that people wanted something like a personal assistant that could live across surfaces such as chat, code, and notes. But the architecture also has to protect the user from context sprawl. If every interaction is remembered indiscriminately, the agent becomes harder to steer. If too little is remembered, the continuity disappears. The episode’s emphasis on scoping shows the team working in that tension. + +Historically, this is one of the places where Letta’s product story becomes easiest to misunderstand. “Personal agent” can sound like a generic assistant, but the episode treats it as a persistent, stateful system with a controlled memory boundary. That distinction is what makes the feature interesting. + +## Deployment and infrastructure concerns shaped the product story + +Under the hood, the episode keeps returning to infrastructure. That is not accidental. Terminal tools, file-system access, note plugins, and consumer frontends all depend on a platform that can maintain identity and context across environments. + +The infrastructure discussion also reveals a practical constraint: the more surfaces the agent inhabits, the more important it becomes to know where state lives and how it is updated. The episode does not make a grand theoretical claim; it demonstrates an operational one. Agent systems are easier to reason about when the deployment path, storage path, and user interface are not blurred together. + +This historical moment is therefore about architecture as product strategy. By splitting out terminal, note, and consumer surfaces, the team could support different use cases without forcing every user through the same workflow. + +## Memory and note-taking define the through-line + +What ties the episode together is the idea that memory is not passive storage. In Letta’s framing, memory is something users and agents work with actively. The Obsidian plugin, Letta Code, and Co all depend on that idea, even though they present it differently. + +That means the episode is less about isolated announcements and more about a single platform thesis: agent systems become more useful when context is intentional, persistent, and inspectable. Letta’s tools were being arranged around that thesis, even if the naming and exact interfaces later changed. + +## Q&A themes + +- What makes Letta Code different from a generic terminal agent. +- Whether consumer-facing agent interfaces can remain consistent with developer workflows. +- How much context should live in notes versus agent memory. +- How personal agents should balance continuity with user control. +- What deployment model is best when an agent spans multiple surfaces. + +## Architectural through-line + +The episode’s architectural through-line is the separation of agent runtime from surface: + +1. Letta Code makes the terminal a stateful workspace, +2. Co offers a consumer-facing entry point, +3. Obsidian provides intentional context management, +4. memory remains a deliberate, scoped resource rather than a hidden dump, +5. deployment can vary without changing the core need for continuity. + +This is the episode’s enduring value. It shows Letta evolving into a platform where the same persistent-agent core can inhabit different interfaces without losing its identity. + +## Related public material + +- [YouTube video](https://www.youtube.com/watch?v=63OkozcdjmY) +- [Letta documentation](https://docs.letta.com/) +- [Letta Code](https://github.com/letta-ai/letta-code) +- [Co](https://github.com/letta-ai/co) +- [Obsidian](https://obsidian.md/) diff --git a/knowledge/published/letta-office-hours-2025-11-06.md b/knowledge/published/letta-office-hours-2025-11-06.md new file mode 100644 index 0000000..bb32086 --- /dev/null +++ b/knowledge/published/letta-office-hours-2025-11-06.md @@ -0,0 +1,149 @@ +--- +title: 'Letta Office Hours: November 6th, 2025' +slug: letta-office-hours-2025-11-06 +summary: >- + November 6, 2025 office hours on the v1 SDK migration, shared archives, Letta + Code improvements, AI Memory SDK v0.2, scheduling, and Ezra. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - sdk + - memory + - scheduling +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=gWZsjcGT1qs' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:77e4012d339ef3720c068732d762b3b7f7a60b519b120bfd7fe270f95702143a' +updated: '2026-08-07T02:33:40.148Z' +reviewStatus: approved +youtubeVideoId: gWZsjcGT1qs +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:21.513Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2025-11-06 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2025-11-06.json + receiptDigest: 'sha256:7845dbae6bec6df5c1db70b6c0569058708cc9c108454872c81c4e791e47886d' +publishedAt: '2026-08-07T02:41:21.513Z' +reviewedContentDigest: 'sha256:01e1b4f2c1c1eb0d697126335215b7888561d6765449236cd2da0d84700ac335' +reviewReceiptDigest: 'sha256:7845dbae6bec6df5c1db70b6c0569058708cc9c108454872c81c4e791e47886d' +--- +The 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. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +What 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. + +## Selected chapters + +| Time | Topic | +| --- | --- | +| [00:03](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=3s) | Opening and what changed over the break | +| [01:32](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=92s) | SDK migration overview | +| [05:25](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=325s) | Snake case and client API changes | +| [08:10](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=490s) | Tool-call arrays and parallel execution | +| [11:40](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=700s) | Archives separated from agents | +| [15:35](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=935s) | Memory blocks and scoping | +| [21:20](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=1280s) | Letta Code link/unlink workflow | +| [31:15](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=1875s) | AI Memory SDK v0.2 overview | +| [42:15](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=2535s) | Scheduling patterns and cron | +| [52:10](https://www.youtube.com/watch?v=gWZsjcGT1qs&t=3130s) | Ezra and the forum/Discord workflow | + +## The v1 SDK migration was about consistency as much as capability + +The 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. + +That 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. + +For 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. + +## Archives separated from agents to support sharing and reuse + +One 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. + +This 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. + +Historically, 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. + +## Letta Code points toward passive memory work in the filesystem + +The 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. + +This 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. + +The 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. + +## The AI Memory SDK v0.2 generalizes the memory model + +The 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. + +The 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. + +This 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. + +## Scheduling stays tool-centered and intentionally simple + +Scheduling 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. + +The 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. + +This 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. + +## Ezra illustrates the platform’s own internal use + +Ezra, 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. + +The 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. + +Historically, 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. + +## Q&A themes + +- Why the v1 SDK migration was worth the breaking changes. +- How archives differ from agents and why that separation helps sharing. +- What linking filesystem tools to agents enables in practice. +- How generalized memory blocks relate to narrower memory use cases. +- Why scheduling is best understood as an integration problem. +- How Ezra works across forum and Discord contexts. + +## Architectural through-line + +The episode’s through-line is explicit boundaries: + +1. SDK behavior becomes more regular, +2. archives become shareable instead of agent-bound, +3. memory blocks and subjects define scope, +4. filesystem tools are linked and unlinked rather than permanently attached, +5. scheduling remains a composition of tools and integrations, +6. Ezra serves as a living example of the same architecture. + +That 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. + +## Related public material + +- [YouTube video](https://www.youtube.com/watch?v=gWZsjcGT1qs) +- [Letta documentation](https://docs.letta.com/) +- [Letta Code](https://github.com/letta-ai/letta-code) +- [AI Memory SDK](https://github.com/letta-ai/ai-memory-sdk) +- [Letta Discord](https://discord.gg/letta) diff --git a/knowledge/published/letta-office-hours-2025-12-04.md b/knowledge/published/letta-office-hours-2025-12-04.md new file mode 100644 index 0000000..6baf93e --- /dev/null +++ b/knowledge/published/letta-office-hours-2025-12-04.md @@ -0,0 +1,155 @@ +--- +title: 'Letta Office Hours: December 4th, 2025' +slug: letta-office-hours-2025-12-04 +summary: >- + December 4, 2025 office hours on the v1 SDK launch, message search, Learning + SDK examples, skills, lettactl, personal agents, and Ezra updates. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - sdk + - skills +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=adQT094jY94' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:33220d241d62a7bd3583b76b3ec85d83d90d81a8a5a3eaf59183493525051351' +updated: '2026-08-07T02:33:39.610Z' +reviewStatus: approved +youtubeVideoId: adQT094jY94 +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:22.058Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2025-12-04 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2025-12-04.json + receiptDigest: 'sha256:4571bd2f1263b3e736d1e30c1d6e361d72f4bb9435a0a6532d496960201594f6' +publishedAt: '2026-08-07T02:41:22.058Z' +reviewedContentDigest: 'sha256:cb186b11946a490f980045c8047b488c2440446dda07212409781b974cdcda46' +reviewReceiptDigest: 'sha256:4571bd2f1263b3e736d1e30c1d6e361d72f4bb9435a0a6532d496960201594f6' +--- +The December 4, 2025 office hours episode is a compact survey of where Letta had landed by the end of the year: the v1 SDK is live, the ADE gets message search, the Learning SDK shows how to add memory elsewhere, and the skills system starts to look like procedural memory for agents. The episode also covers lettactl, personal agents, Ezra changes, and the social and community layer around the product. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +Historically, this is useful because it shows the platform moving from announcement mode into consolidation mode. The architecture is no longer just about proving stateful agents are possible; it is about making the agent ecosystem easier to extend, inspect, deploy, and teach. The episode therefore reads like a bridge between a technical release and a broader operating model. + +## Selected chapters + +| Time | Topic | +| --- | --- | +| [00:03](https://www.youtube.com/watch?v=adQT094jY94&t=3s) | Opening and year-end framing | +| [00:48](https://www.youtube.com/watch?v=adQT094jY94&t=48s) | V1 SDK is live | +| [03:40](https://www.youtube.com/watch?v=adQT094jY94&t=220s) | Message search in the ADE | +| [07:30](https://www.youtube.com/watch?v=adQT094jY94&t=450s) | Learning SDK examples and memory portability | +| [12:15](https://www.youtube.com/watch?v=adQT094jY94&t=735s) | Skills as procedural memory | +| [18:10](https://www.youtube.com/watch?v=adQT094jY94&t=1090s) | lettactl and fleet deployment | +| [24:25](https://www.youtube.com/watch?v=adQT094jY94&t=1465s) | Personal agents and consumer interest | +| [31:40](https://www.youtube.com/watch?v=adQT094jY94&t=1900s) | Ezra updates and bot behavior | +| [37:10](https://www.youtube.com/watch?v=adQT094jY94&t=2230s) | Seattle meetup and AT Protocol discussion | +| [44:50](https://www.youtube.com/watch?v=adQT094jY94&t=2690s) | API logs and wrapped-up operations | + +## The v1 SDK had become the baseline + +The first big theme is that v1 is now fully live. That is a meaningful historical shift because earlier episodes treated v1 as a coming change or a migration path. Here, it is the base layer. The episode’s tone is less about speculation and more about telling users to move. + +That change matters for two reasons. First, it means the platform had crossed from beta-style experimentation to an expected operating version. Second, it means the migration guidance, naming conventions, and tool-call semantics discussed in prior episodes now had to be treated as the durable public shape. In that sense, the episode marks a handoff from provisional design to practical adoption. + +The public documentation at [docs.letta.com](https://docs.letta.com/) should be read as the current reference, but this episode is the historical record of the moment the release train became authoritative. + +## Message search makes the ADE more navigable + +The message search feature in the ADE is small compared with v1, but it is important because it improves how people inspect agent interactions. A persistent agent produces a lot of messages, and those messages become part of the system’s memory story. Search therefore becomes a core usability feature, not a luxury. + +The episode frames the search as keyword-based first, with semantic search still coming later. That staged rollout is worth noticing. It shows the team choosing a useful incremental capability instead of waiting for the perfect search system. For users, that means the agent history becomes easier to audit and debug; for the platform, it means the ADE becomes a more credible workspace for long-lived conversations. + +Historically, this is also part of Letta’s broader insistence on inspectability. If memory and conversation are persistent, the interface has to let users recover what happened. + +## The Learning SDK was presented as portable memory infrastructure + +One of the more interesting discussion threads is the Learning SDK. The episode describes it as a way to add Letta memory to other AI platforms in a very small amount of code. That is a strong statement about interoperability. It suggests the memory layer is valuable even outside the full Letta agent stack. + +The examples mentioned in the episode matter because they place Letta alongside other developer ecosystems. The point is not that those platforms are identical, but that memory can be introduced as a reusable service. Historically, this reveals a broadening of the product strategy: Letta is no longer only a place to build agents; it is also a source of infrastructure other people can embed. + +This should not be read as a current guarantee about every integration shape. The episode captures an illustrative set of examples and an ambition for portability. The key lesson is that memory is being treated as an independent capability that can travel. + +## Skills start to look like procedural memory for agents + +The skills system is one of the most conceptually rich parts of the episode. It is described as procedural memory for agents, backed by a communal skills repository. That framing is powerful because it treats skills as learned or reusable behavior patterns rather than just static prompt snippets. + +In practice, that means agents can inherit action patterns, conventions, or task knowledge from a shared collection of skills. The episode also gestures toward benchmarks and skill learning, which suggests the team was thinking about how skills should be discovered, evaluated, and reused rather than merely stored. + +This is a notable historical move. It extends the memory conversation beyond facts and context into know-how. For persistent agents, that distinction is important: knowing something is not the same as being able to do it reliably. + +## lettactl points to fleet-like deployment thinking + +The mention of lettactl is another clue about the product’s direction. It suggests a community-oriented tool for deploying agent fleets with YAML-style configuration. That is a different mental model than ad hoc chatbots. It implies agents can be managed in groups, configured declaratively, and operated more like infrastructure. + +Historically, that is significant because it shows the community starting to build operational patterns around Letta. If skills are procedural memory, lettactl is closer to a deployment layer for agent systems. Together they make the platform look less like a single application and more like a toolkit for orchestrating many persistent entities. + +The episode does not overclaim maturity. It presents the tool as part of the ecosystem, which is the right historical reading: the public surface was broadening beyond the core Letta UI. + +## Personal agents and Ezra show the human-facing side + +The discussion of personal agents suggests real user interest in more intimate, consumer-friendly workflows. That is not surprising, but it is useful. It tells us that the platform’s memory model was being considered not just for code or documentation, but also for ongoing personal interaction. + +Ezra, meanwhile, illustrates the team’s own assistant ecosystem. The episode mentions updated behavior, quality improvements, and a Discord-bot example. That helps show how internal or semi-internal assistants can serve as proving grounds for the platform itself. A good agent system should be able to support that kind of continual refinement. + +The historical boundary matters again: the episode is describing interest and progress, not claiming that every personal-agent experience had stabilized. But it does show why continuity and memory were attractive as product primitives. + +## Community and protocol discussions broaden the context + +The Seattle meetup and AT Protocol discussion show that the episode was not purely about immediate product features. The team was also thinking about social coordination, community events, and broader networked identity ideas. Those topics may be adjacent to the core platform, but they help explain the surrounding ecosystem. + +At the same time, the API logs update in the ADE underlines a more ordinary but equally important point: a mature agent platform must keep making operations legible. Logs, message search, and clearer SDK behavior all serve the same purpose of making persistence manageable. + +## Q&A themes + +- How quickly users should migrate now that v1 is live. +- Whether message search will stay keyword-first or expand semantically. +- How the Learning SDK relates to other agent or app ecosystems. +- What skills represent: prompts, procedures, or reusable behavior. +- How agent fleets can be deployed and managed at scale. +- Where personal agents fit relative to team and coding workflows. + +## Architectural through-line + +The episode’s through-line is the move from experimental agent building to a broader operating system for persistent agents: + +1. v1 becomes the baseline SDK, +2. message search makes conversation history inspectable, +3. the Learning SDK exports memory as reusable infrastructure, +4. skills add procedural behavior on top of factual memory, +5. lettactl points to fleet management, +6. Ezra and personal agents show the human-facing applications. + +That is the architectural story of late 2025: stateful agents are no longer just a feature; they are the organizing principle around which deployment, search, memory, and skills are being arranged. + +## Related public material + +- [YouTube video](https://www.youtube.com/watch?v=adQT094jY94) +- [Letta documentation](https://docs.letta.com/) +- [Learning SDK](https://github.com/letta-ai/learning-sdk) +- [Skills repository](https://github.com/letta-ai/skills) +- [lettactl](https://github.com/nouamanecodes/lettactl) +- [Discord](https://discord.gg/letta) diff --git a/knowledge/published/letta-office-hours-2025-12-18.md b/knowledge/published/letta-office-hours-2025-12-18.md new file mode 100644 index 0000000..8da9056 --- /dev/null +++ b/knowledge/published/letta-office-hours-2025-12-18.md @@ -0,0 +1,123 @@ +--- +title: 'Letta Office Hours: Letta Code Demo, Agent Skills, Claude Code Proxy & More' +slug: letta-office-hours-2025-12-18 +summary: >- + Office hours on Letta Code, agent skills, persistent memory, sub-agents, and + emerging ideas for shared blocks and file-system-like agent environments. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-code + - agent-skills + - persistent-memory + - sub-agents + - agent-ergonomics + - at-protocol +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=Nhhj_BPwdKg' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:97edf98582b9cc61cabc7483207ffdaaa154e37fcb30a87008725def46be17da' +updated: '2026-08-07T02:38:35.924Z' +reviewStatus: approved +youtubeVideoId: Nhhj_BPwdKg +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:22.613Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2025-12-18 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2025-12-18.json + receiptDigest: 'sha256:5289401bb8fb972914fbb9285c31c4d9d2f4b47f5ac0c14be3af19099d24d58e' +publishedAt: '2026-08-07T02:41:22.613Z' +reviewedContentDigest: 'sha256:e63a1d3b0bf71cf24c5bfc11d430a634a53cd4baa6339aa4c681c108196cd426' +reviewReceiptDigest: 'sha256:5289401bb8fb972914fbb9285c31c4d9d2f4b47f5ac0c14be3af19099d24d58e' +--- +This office hours episode centers on a practical question: what does it mean to give an agent durable memory, reusable skills, and a workspace that behaves more like an ongoing system than a throwaway chat? Cameron frames Letta Code as an agent harness designed to keep state alive across sessions, then uses the demo to show how memory blocks, skills, and sub-agents fit together as a working workflow rather than isolated features. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The talk also sketches the broader design direction behind the product. Instead of treating an agent as a single conversation that eventually degrades, the episode argues for a system of persistent memory, scoped blocks, and server-side execution that can support long-running coding work, shared context, and more structured collaboration. Many examples are exploratory or in progress, but they reveal a coherent architectural direction. + +## Selected chapters + +- [00:01:00](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=60s) Letta Code release and benchmark context +- [00:03:00](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=180s) Installing and connecting to Letta Code +- [00:04:00](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=240s) Agent persistence and server-side tool execution +- [00:06:00](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=360s) Memory blocks and updating persona memory +- [00:08:30](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=510s) Using /init to orient a project +- [00:12:30](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=750s) Skills loading and skill refresh behavior +- [00:14:30](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=870s) Sub-agents for exploration and planning +- [00:16:30](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=990s) Agent skills and procedural memory +- [00:18:30](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=1110s) Loading a skill and letting it persist +- [00:57:30](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=3450s) Ergonomics of memory blocks and future directions +- [01:06:30](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=3990s) File-system-like memory and sandboxed agents +- [01:09:30](https://www.youtube.com/watch?v=Nhhj_BPwdKg&t=4170s) Public atproto-style collaboration ideas + +## Letta Code as persistent agent infrastructure + +A major thread through the episode is that Letta Code is not presented as a transient coding assistant. Instead, the agent remains attached to a server-backed identity that can be revisited later, preserve memory, and continue where it left off. Cameron contrasts this with tools that rely on large compaction events or short-lived sessions, arguing that long-running development work needs continuity in both context and behavior. + +The demo emphasizes how the harness routes tool use through Letta rather than directly through the shell. That distinction matters because it makes the agent’s state portable across clients while keeping execution under a controlled server-side layer. The result is a workflow where the human can interact from different places, but the underlying agent still preserves its own memory and operating history. + +## Memory blocks as a structured working set + +Memory blocks are the episode’s most important design object. Rather than one amorphous memory, the agent keeps separate blocks for things like persona, skills, project context, and human-specific notes. Cameron shows how a block can be inspected and updated, and how the agent can reflect those updates in later behavior. + +That structure gives the system a clearer boundary between durable facts, project-specific knowledge, and task-scoped context. The episode repeatedly returns to the idea that memory should feel navigable: something the agent can load, update, and share instead of something hidden inside a monolithic prompt. This is the basis for the later discussion of memory as a file-system-like interface. + +## Skills and procedural memory + +Another major theme is skills. The episode describes them as reusable procedural knowledge that an agent can discover and load when needed. Cameron shows that skills are not just documentation; they are executable capability bundles that can be attached to an agent and used persistently. + +This matters because it separates what the agent knows from what the agent can do. A skill can encode a workflow, a style, or a domain practice, and the agent can refresh or load it as part of its operating state. The talk treats the agent-skills standard as a broader ecosystem move, not just a Letta-specific convenience feature. + +## Sub-agents for exploration and planning + +The office hours also highlight sub-agents as a practical way to offload specialized work. Instead of forcing one agent to do everything, Letta Code can spin up exploratory or planning-oriented agents with narrower instructions. The episode shows this as a way to analyze a codebase, inspect dependencies, or handle tasks that benefit from a distinct working context. + +The architectural payoff is separation of concerns. Primary conversation, project memory, and specialized analysis can each live in different agent scopes while remaining coordinated through the same server-side system. That makes the harness feel less like a chatbot and more like a programmable team. + +## File-system-like memory and sandboxed environments + +Near the end of the episode, Cameron discusses a future direction in which memory blocks behave more like files and agents operate inside persistent sandboxes. The goal is to make memory legible through familiar filesystem metaphors: attach, detach, view, version, and organize blocks in ways that feel natural to software developers. + +The same logic extends to execution. If an agent can run in its own sandboxed environment, it can clone repositories, make changes, and even prepare contributions without depending entirely on a live local terminal session. The episode presents this as an active design area rather than a finished product, but it clarifies the long-term direction: persistent agents with structured memory and durable workspaces. + +## Q&A themes + +The questions and answers circle around ergonomics, platform behavior, and collaboration. A recurring concern is how to make initialization, memory layout, and model selection feel intuitive rather than bolted on. Another thread is cross-platform reliability, especially around shell behavior and Windows support. + +The episode also explores shared use cases: multiple people training the same agent, sharing memory across agents, and building public or organization-scoped blocks that can be reused. That discussion broadens the product from personal coding assistant toward collaborative infrastructure. + +## Architectural through-line + +The through-line is that Letta is treating agency as a stateful system design problem. Memory is not a sidebar feature; it is the substrate that lets agents persist, specialize, collaborate, and remain understandable. Skills add reusable procedure, sub-agents add division of labor, and sandboxed execution adds a place where work can continue without collapsing the conversation model. + +Taken together, those pieces point toward an agent platform that is meant to be inspectable and composable. The episode does not frame Letta Code as merely “chat with code,” but as a harness for durable AI work: one that keeps context, structure, and execution aligned over time. + +## Related public material + +- https://www.youtube.com/watch?v=Nhhj_BPwdKg +- https://docs.letta.com/ +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk diff --git a/knowledge/published/letta-office-hours-2026-01-09.md b/knowledge/published/letta-office-hours-2026-01-09.md new file mode 100644 index 0000000..61c0ba0 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-01-09.md @@ -0,0 +1,119 @@ +--- +title: >- + Letta Office Hours: Message Scheduling, GitHub Actions, Ralph Mode, and the + Note Tool +slug: letta-office-hours-2026-01-09 +summary: >- + Office hours on scheduling, GitHub Actions, Ralph mode, custom commands, + sub-agents, the note tool, and why simple memory structures often beat heavier + abstractions. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - message-scheduling + - github-actions + - ralph-mode + - custom-slash-commands + - sub-agents + - note-tool + - memory-management + - fleet-deployment +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=aNCml_RFN_Q' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:ed19704fed391c1dc1f264995e48610b1c004b4a4934f15e96fc4a7e31b1f014' +updated: '2026-08-07T02:33:38.561Z' +reviewStatus: approved +youtubeVideoId: aNCml_RFN_Q +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:23.155Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-01-09 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-01-09.json + receiptDigest: 'sha256:c99c812bbcd58e2ee37a6f1bd764c8a5733b51d81b5a7665c40a053f3c702eab' +publishedAt: '2026-08-07T02:41:23.155Z' +reviewedContentDigest: 'sha256:c2a299f85262b2755538cffd213ab77857e527c79f1aca39f21f9fd780d83b2b' +reviewReceiptDigest: 'sha256:c99c812bbcd58e2ee37a6f1bd764c8a5733b51d81b5a7665c40a053f3c702eab' +--- +This office-hours session opens with a tour of several features that push Letta agents toward longer-lived, more autonomous work. The through-line is not just that new tools exist, but that they are meant to reduce friction between an agent’s immediate task loop and the surrounding systems that keep it useful over time: schedules, repositories, memory, and deployment. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The discussion also emphasizes a recurring design preference: use simple, legible structures when they are enough, and reserve heavier abstractions for cases that clearly need them. That shows up in the treatment of memory blocks, note-style records, and the skepticism toward overengineered graph systems when a plain document or archive can preserve the same reasoning trail more transparently. + +## Selected chapters +- [00:01:30](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=90s) Message scheduling arrives in Letta Cloud. +- [00:03:00](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=180s) The switchboard backend is folded into the Letta path. +- [00:04:00](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=240s) Creating one-time and recurring schedules via the API. +- [00:05:30](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=330s) Managing scheduled messages and common cron patterns. +- [00:07:00](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=420s) The Letta Code GitHub Action is introduced. +- [00:08:00](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=480s) Running a headless agent inside a GitHub workflow. +- [00:11:30](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=690s) Setting up a persistent office-hours agent. +- [00:16:30](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=990s) Ralph mode and the push toward task completion. +- [00:38:00](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=2280s) Sub-agents and the role of specialization. +- [00:43:30](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=2610s) The note tool as structured memory. +- [00:53:00](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=3180s) Why documents often beat graph abstractions. +- [01:03:00](https://www.youtube.com/watch?v=aNCml_RFN_Q&t=3780s) Conversation longevity and archiving into external tools. + +## Message scheduling as native agent infrastructure +Message scheduling is presented as a long-requested capability that lets users send an agent a one-time message or a recurring cron-based prompt. The practical significance is that agents can now receive time-based nudges without relying on external middleware. The episode frames this as a migration from an older “switchboard” setup into a more direct backend path, which simplifies how scheduling works and aligns it with the rest of the Letta stack. + +The demo focuses on basic primitives: create a schedule, choose a one-time or recurring message, and later list, retrieve, or cancel it. That matters because scheduling is not treated as a novelty feature; it becomes a way to support unstructured time, daily summaries, reminders to review memory, and recurring reflective workflows that keep agents active even when the user is not present. + +## GitHub Actions for Letta Code +The GitHub Action announcement shows Letta Code being deployed into repository workflows as a headless agent. In practical terms, this means a repo can summon an agent on issues or pull requests, letting it respond, inspect context, and summarize what it did. The episode stresses that this is a straightforward integration rather than a new product category: it is the same agentic workflow, but embedded in the development surface where code review and issue triage already happen. + +The value proposition is orchestration. Instead of copying context into an external chat, the repository becomes the workspace, and the agent can act inside a familiar CI-style runtime. That pattern also extends to existing agents, not just freshly spawned ones, which points toward a model where persistent agents become reusable collaborators across projects. + +## Ralph mode and enforced follow-through +Ralph mode is described as a way to keep an agent working until it actually finishes the requested task, rather than stopping early or retreating into vague refusal. The episode frames this as especially relevant for long-running or multi-step work, where a user wants persistence more than elegant partial progress. + +The demo deliberately pushes models into failure modes to show why the mode exists. The important mechanism is not coercion for its own sake, but a tighter loop between intention and completion. In the larger architectural picture, Ralph mode is another example of Letta shaping agent behavior through control flow around the model, not just through prompt text. + +## The note tool and lightweight memory +One of the most detailed discussions concerns the note tool, which is presented as a file-system-like way to manage memory with attach and detach semantics. The underlying idea is that agents often do not need a complex external database of every thought; they need a maintainable place to store current, readable records that can be updated or archived over time. + +That perspective becomes important when the conversation turns to decisions, skills, and archiving. Rather than defaulting to graph systems or elaborate schemas, the episode argues for plain documents, folders, and memory blocks when they are sufficient. The point is not anti-structure; it is pro-clarity. If an agent or human can read the record and understand it immediately, it is probably doing useful work. + +## Sub-agents, custom commands, and fleet operations +The latter part of the episode connects several features that all support specialization. Sub-agents let a main agent delegate exploration, planning, general-purpose work, or recall-oriented tasks. Custom slash commands let users package reusable prompts. LettaCTL is described as production-ready for declarative fleet deployments. Taken together, these tools point to a system where an agent is not a monolith but a coordinated set of roles. + +This is also where the episode’s broader systems thinking comes through most clearly. The agent architecture is not just about one conversation; it is about repeatable behaviors that can be deployed, scheduled, routed, and composed across contexts. That makes persistent memory and operational tooling part of the same story. + +## Q&A themes +The Q&A repeatedly returns to the same practical questions: how much memory is too much, how to preserve decisions, whether graphs add value, and how long-lived conversations can be. The answers favor bounded, inspectable structures and emphasize that large contexts still need careful curation. Memory is useful when it stays understandable and current; conversation history is often the first thing to trim. + +Another recurring theme is that many “future” features can be approximated with straightforward documentation habits today. Archive blocks, note folders, and markdown records are treated as strong defaults because they are easy to query later and easy to reason about now. + +## Architectural through-line +The architectural through-line is progressive disclosure backed by simple persistence. Scheduling, GitHub Actions, Ralph mode, sub-agents, and the note tool all help move work out of the raw chat loop and into structures that agents can revisit, execute against, and maintain over time. The episode argues that the best abstractions are usually the ones that remain legible while still giving the agent enough structure to act autonomously. + +## Related public material +- https://www.youtube.com/watch?v=aNCml_RFN_Q +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk +- https://github.com/letta-ai/hypervigilant diff --git a/knowledge/published/letta-office-hours-2026-01-26.md b/knowledge/published/letta-office-hours-2026-01-26.md new file mode 100644 index 0000000..210028c --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-01-26.md @@ -0,0 +1,115 @@ +--- +title: 'Letta Office Hours: Letta Chat, GitHub Action, Letta Code, and more!' +slug: letta-office-hours-2026-01-26 +summary: >- + Cameron demos Letta Chat, a GitHub Action for Letta Code, specialist repo + agents, the note tool, and social agents on Blue Sky. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-chat + - letta-code + - github-actions + - agent-specialization + - memory-blocks + - blue-sky + - public-ai-systems +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=fr61XHf6Zzw' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:d06b312137c8b39779978f24cc79c43a6478ba97311eb6504117d4718ed79984' +updated: '2026-08-07T02:33:38.039Z' +reviewStatus: approved +youtubeVideoId: fr61XHf6Zzw +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:23.717Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-01-26 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-01-26.json + receiptDigest: 'sha256:fab4548b04f572fb12996491914687052f6d26fe6aa6e3df08aa9b9f7b9647e4' +publishedAt: '2026-08-07T02:41:23.717Z' +reviewedContentDigest: 'sha256:eb1a9eb7c48b8fd08c9c174e98f65692f08c2d25bc8317e123381f5eefb58a31' +reviewReceiptDigest: 'sha256:fab4548b04f572fb12996491914687052f6d26fe6aa6e3df08aa9b9f7b9647e4' +--- +Cameron’s office hours episode is a tour of how Letta is being shaped for people who want to work with long-lived agents, not just one-off prompts. The through-line is practical accessibility: a simpler chat surface for personal agents, automation for repository workflows, and tools that let agents carry context across sessions without forcing every interaction through a full developer stack. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The episode also frames Letta as an ecosystem of specialized agents and shared infrastructure. Instead of treating agents as isolated chatbots, Cameron shows them as deployable workers with distinct roles, memories, and interfaces—whether they live in a web app, a GitHub workflow, or a social network. + +## Selected chapters +- [00:00](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=0s) Office hours intro and roadmap +- [02:00](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=120s) Why Letta Chat exists +- [02:30](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=150s) Default agent “Loop” and bootstrapping persona design +- [04:00](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=240s) Loop Master and iterative agent testing +- [05:00](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=300s) Agent-to-agent messaging for evaluation +- [08:30](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=510s) GitHub Action setup for Letta Code +- [13:30](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=810s) Specialist agents and repository-specific expertise +- [16:30](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=990s) The skills repository and persistent improvement loops +- [01:07:00](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=4020s) The note tool as memory-block filesystem +- [01:13:00](https://www.youtube.com/watch?v=fr61XHf6Zzw&t=4380s) Void, Blue Sky, and machine-readable social agents + +## Letta Chat as a lightweight agent front end +Letta Chat is presented as a deliberately simple interface for people who want to talk to one or a few personal agents without living inside the full Agent Development Environment. The point is to make agents feel approachable for non-developers and to reduce the friction of everyday use. Cameron emphasizes that the product is still in progress, but the design goal is clear: a focused front end with favorites, a default agent, and little else. + +That simplicity is itself a product choice. The episode notes that Letta Chat removes memory-block management and even avoids encouraging users to create many agents. Instead, the system encourages a small set of meaningful, durable companions. The default agent, Loop, is meant to make that experience feel welcoming rather than generic. + +## Bootstrapping an agent personality +A major technical theme is how to create an agent that feels interesting immediately. Cameron describes Loop as the result of repeated iteration, with Loop Master acting as a scaffolding agent that modifies prompts, tests responses, and probes for weaknesses. This is not just prompt tweaking; it is a workflow for evolving a persona with feedback loops. + +That process also shows how Letta treats agents as malleable artifacts. Loop Master can create a new loop, alter its instructions, and stress-test it through agent-to-agent messaging. The demo suggests a pipeline where a stronger agent can supervise a weaker or newer one, making personality design part of the system itself rather than a one-time setup step. + +## GitHub Actions and repository-specialist agents +The GitHub Action segment shows Letta Code moving from interactive assistance toward automation inside developer workflows. Cameron demonstrates a simple installation flow that writes a workflow file and uses a repository secret so the action can run. The idea is not merely to add an AI button to CI, but to let a repository have an assigned agent that understands its conventions and history. + +That concept extends to specialist agents. Cameron explains that a repo can have a dedicated agent ID and that this agent can be used in workflows, issues, and cloud interactions. The important mechanism is specialization: one agent can become the gatekeeper for a codebase, learn from its own pull requests and issue handling, and improve persistently over time. + +## Conversations, parallelism, and the note tool +Another recurring theme is scaling context without losing structure. Cameron discusses conversations as a way to fork work into parallel threads while still preserving memory. That same idea appears in the note tool, which turns memory blocks into something closer to a filesystem: editable, searchable, and usable through multiple interfaces, including web editors and Obsidian. + +The architectural value here is progressive disclosure. Instead of stuffing everything into one prompt, the agent can keep out-of-context material in structured notes and retrieve it when needed. Cameron frames this as a practical bridge between cloud-based memory and local workflows, with a future “vault” concept hinted at as a broader shared-memory successor. + +## Public agents and machine-readable social spaces +The later discussion expands the agent model beyond coding and chat. Cameron points to social agents like Void on Blue Sky as examples of public, persistent AI systems with memory and style. The argument is not that social networks are a novelty, but that machine-readable infrastructure makes them a plausible environment for living agent identities that can accumulate state. + +Blue Sky matters in this framing because it exposes structured primitives for agents and feeds. Cameron contrasts that with more performative social spaces and argues that public AI systems need places where memory, identity, and interaction can be inspected and built upon. The episode closes this loop by showing how Letta’s own tools—chat, code automation, notes, and public agents—fit into that broader ecosystem. + +## Q&A themes +Questions throughout the episode circle around the same core concerns: how to use Letta with editors like Cursor, how to retrieve conversation history, how to attach MCP-like capabilities to agents, and how to think about model choice for non-coding tasks. The answers consistently favor practical deployment over abstract purity: use the terminal when possible, use agents that specialize, and store context where it can be reused. + +A second Q&A theme is portability. Cameron repeatedly returns to the idea that an agent should move across interfaces—chat, code, notes, or social platforms—without losing its identity. That portability is what makes the system feel less like a chatbot and more like an operational layer. + +## Architectural through-line +The episode’s architecture is a stack of specialization plus memory. Letta Chat lowers the barrier to entry, Loop Master improves persona quality through iteration, GitHub Actions embed agents into repositories, the note tool externalizes memory in a structured way, and public agents like Void show what persistent identity can look like outside the product itself. + +Together, those pieces point toward one design principle: agents should be durable, inspectable, and assignable. The system is not just trying to answer questions; it is trying to create repeatable places where agent behavior, context, and responsibility can accumulate over time. + +## Related public material +- https://www.youtube.com/watch?v=fr61XHf6Zzw +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk +- https://github.com/letta-ai/hypervigilant diff --git a/knowledge/published/letta-office-hours-2026-01-29.md b/knowledge/published/letta-office-hours-2026-01-29.md new file mode 100644 index 0000000..281d44f --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-01-29.md @@ -0,0 +1,123 @@ +--- +title: 'Letta Office Hours: Introducing LettaBot +Claude Subconscious Demo' +slug: letta-office-hours-2026-01-29 +summary: >- + Office hours on LettaBot, a locally deployed messaging bridge for agents, plus + a live Claude Subconscious demo that injects Letta context into Claude Code. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - lettabot + - claude-subconscious + - letta-code + - agent-memory + - hooks + - secure-remote-access +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=M8LNa3FKE4k' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:d436c852e0263f0d02ed3ccc02a37e332ff4dfaa2a2f67c415a368b1b12c0367' +updated: '2026-08-07T02:33:37.514Z' +reviewStatus: approved +youtubeVideoId: M8LNa3FKE4k +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:24.265Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-01-29 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-01-29.json + receiptDigest: 'sha256:a5fcac92cc57ea4176da9b5c0c524d01114acc4f8e57621f0967785869d2db5a' +publishedAt: '2026-08-07T02:41:24.265Z' +reviewedContentDigest: 'sha256:35f551976ffcb97d2bd388487994d41dccf81142c57c41a2dfdfb2e4ea2abbc8' +reviewReceiptDigest: 'sha256:a5fcac92cc57ea4176da9b5c0c524d01114acc4f8e57621f0967785869d2db5a' +--- +The episode centers on two related ideas: LettaBot, a way to reach a local Letta agent from messaging apps, and Claude Subconscious, a companion project that feeds a Letta agent’s context into Claude Code sessions. The through-line is that agents become more useful when they are not only stateful, but also reachable, inspectable, and controllable across the tools people already use. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +Cameron frames the office hours around practical demos rather than abstract architecture. LettaBot is presented as a secure-by-default bridge to a single Letta agent running on the user’s machine or self-hosted infrastructure, while Claude Subconscious shows how Letta can act as a higher-level observer layered onto another coding assistant. Together they illustrate a broader design goal: make agents persistent across time and surfaces without turning them into opaque black boxes. + +## Selected chapters + +- [00:01:00](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=60s) LettaBot as the Letta take on ClawdBot/MoltBot +- [00:02:00](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=120s) Memory and harness as the main differentiators +- [00:02:30](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=150s) Supported channels: Signal, Telegram, WhatsApp, Slack +- [00:03:00](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=180s) Pairing and security defaults +- [00:06:00](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=360s) How LettaBot onboarding works +- [00:07:00](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=420s) Deploying an agent “brain in a jar” with Letta Code +- [00:10:30](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=630s) Live channel demo and cost model discussion +- [00:15:30](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=930s) Capability and security comparison with ClawdBot/MoltBot +- [00:49:30](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=2970s) Hooks as lifecycle control points in Letta Code +- [00:54:30](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=3270s) Claude Subconscious overview +- [01:01:00](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=3660s) Updating the docs and model configuration discussion +- [01:06:30](https://www.youtube.com/watch?v=M8LNa3FKE4k&t=3990s) Closing questions and migration tooling + +## LettaBot as a messaging bridge + +LettaBot is described as Letta’s answer to the “agent you can message from anywhere” pattern popularized by ClawdBot/MoltBot. The important distinction is not just the transport layer; it is that LettaBot is built around Letta Code and therefore around Letta’s memory-centric agent model. That means the bot is not merely forwarding prompts to a remote assistant. It is orchestrating a Letta agent that can persist state, use tools, and execute code with the same assumptions as the rest of the Letta stack. + +The demo emphasizes that the agent can be reached over Signal, Telegram, WhatsApp, and Slack, but only one agent is intended per LettaBot server. That single-agent design simplifies the mental model: there is one persistent brain behind the channels, and the channels are just entry points. + +## Security and deployment choices + +A major theme is security. Cameron contrasts LettaBot with systems that expose many inbound ports and are therefore easier to attack. LettaBot is presented as using outbound connections or polling, plus pairing as a default approval step before a new client can interact with the agent. In other words, the default posture is “local agent, remote access with consent,” not “public service waiting for arbitrary traffic.” + +Deployment is also flexible. The demo uses a laptop, but the same pattern can run on a Mac mini or on self-hosted infrastructure. The episode makes clear that users can choose between self-hosted Letta servers and Letta’s hosted API, with cost and privacy as the main tradeoffs. That positioning matters because it frames the product as an agent runtime rather than a single hosted app. + +## Live messaging demo + +The live segment shows the bot being used through messaging channels, including a simple “introduce yourself” style exchange. The point is less the content of the reply than the fact that the same persistent agent can answer from a consumer chat app and still present itself as stateful and aware of its tools and memory. + +The demo also underscores a product constraint: LettaBot is meant for one agent, but that agent can still spawn subagents when needed. So the external interface stays simple while the internal reasoning architecture can be more elaborate. + +## Hooks and controlled autonomy + +Hooks are another structural idea that gets a lot of attention. Cameron explains them as lifecycle callbacks around agent events: before and after tool use, on permission prompts, when notifications are emitted, at session start and stop, and before compaction. That makes hooks a control plane for behavior, not just a logging mechanism. + +In the episode, hooks are discussed both as a safety mechanism and as a way to publish agent activity. The example of live-streaming an autonomous agent’s actions shows how hooks can turn an otherwise hidden agent loop into something inspectable. The same mechanism can also block dangerous commands or require user review, which is why hooks are presented as an important part of the Letta Code execution model. + +## Claude Subconscious as layered context + +Claude Subconscious is introduced as a plugin-like system that injects a Letta agent’s assistant messages and memory diffs into Claude Code. The core idea is that another coding assistant can be augmented with a second agent that observes, summarizes, and updates context over time. Rather than replacing Claude Code, it adds an always-on companion layer that can track sessions and surface the right memory at the right moment. + +That demo highlights both the promise and the limitations of the approach. The system can search across prior sessions, update memory, and feed context into ongoing work, but it also needs careful evaluation because agent-to-agent coordination can drift or become stale. The discussion ends up less as a polished product pitch and more as a design sketch for how stateful companions might improve coding workflows. + +## Q&A themes + +The questions lean toward practical concerns: how many agents the system supports, how models are chosen, whether hooks already exist, how memory is updated, and how users migrate existing tooling. Across those questions, the episode keeps returning to the same pattern: make the defaults secure, make the interfaces simple, and leave room for power users to extend the system through code. + +## Architectural through-line + +The architectural idea tying everything together is that agents should have durable state, programmable lifecycles, and multiple surfaces for interaction. LettaBot shows the “reachable everywhere” layer; Letta Code shows the execution and memory layer; hooks show the control layer; Claude Subconscious shows how those ingredients can be composed into a second-order assistant that augments another assistant. + +Taken together, the episode argues for agents as persistent software systems rather than one-off chat experiences. The user-facing channels may change, but the underlying agent should remain stable, inspectable, and capable of evolving with its context. + +## Related public material + +- https://www.youtube.com/watch?v=M8LNa3FKE4k +- https://letta.bot/ +- https://github.com/letta-ai/lettabot +- https://github.com/letta-ai/claude-subconscious +- https://docs.letta.com/ +- https://github.com/letta-ai/letta-code diff --git a/knowledge/published/letta-office-hours-2026-02-05.md b/knowledge/published/letta-office-hours-2026-02-05.md new file mode 100644 index 0000000..88b5ea3 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-02-05.md @@ -0,0 +1,120 @@ +--- +title: 'Letta Office Hours: Opus 4.6, Lettabot Updates, Agent File Directory, and More' +slug: letta-office-hours-2026-02-05 +summary: >- + Office hours on Opus 4.6, Letta Code provider setup, Lettabot, agent + self-forking, and why Letta favors stateful agents over retrieval-only memory. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - opus-4-6 + - letta-code + - lettabot + - agent-memory + - provider-support + - multi-agent-systems +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=LKRnP-ptC4c' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:5bbf87fddbc1025105c34186ed5195d8fff603961ebbd676184ab9cbe0672efb' +updated: '2026-08-07T02:33:36.991Z' +reviewStatus: approved +youtubeVideoId: LKRnP-ptC4c +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:24.864Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-02-05 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-02-05.json + receiptDigest: 'sha256:fe25d692eddac23ac823d0604cadce812d042cc0e793667ffded41cbc639cb88' +publishedAt: '2026-08-07T02:41:24.864Z' +reviewedContentDigest: 'sha256:c8cbc2999d975a345741ba9e98dbe46faec3292e39186dd2dacbd75e5f596b76' +reviewReceiptDigest: 'sha256:fe25d692eddac23ac823d0604cadce812d042cc0e793667ffded41cbc639cb88' +--- +At this office hours session, Cameron frames Letta as a fast-moving developer platform for stateful agents, then spends the hour connecting several recent product changes into one theme: giving agents more durable memory, more tools, and more ways to act independently. The discussion starts with model updates, including Claude Opus 4.6 and its effect on Letta’s own benchmarks, then moves into the new Letta Code provider setup, Lettabot, and the broader shift from chat-only workflows toward agents that can actually operate over files, schedules, and connected services. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The episode is less a feature tour than a systems explanation. Cameron repeatedly returns to the same idea: retrieval matters, but persistent state and tool access matter more. That is why Letta has leaned into the agent SDK, subagent orchestration, first-party provider support, and product surfaces such as Letta Code, Letta Bot, and Letta Cowork. The result is a portrait of an ecosystem built for long-running, autonomous work rather than isolated prompts. + +## Selected chapters + +- [00:04:00](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=240s) — Opus 4.6 lands in Letta’s model lineup +- [00:05:00](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=300s) — Agents can fork themselves or reuse existing agents +- [00:06:00](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=360s) — File system benchmark results and cost tradeoffs +- [00:07:30](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=450s) — Skills benchmark comparison across models +- [00:11:30](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=690s) — Expanded `/connect` flow in Letta Code +- [00:12:30](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=750s) — Project-level LLM key management and BYOK setup +- [00:17:30](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=1050s) — What Lettabot is and how it is deployed +- [00:18:30](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=1110s) — Lettabot architecture and remote agent access +- [00:31:00](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=1860s) — Skills and autonomous workflows from email to RSS +- [01:18:00](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=4680s) — Letta Cowork and the broader product direction +- [01:43:00](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=6180s) — Why Letta emphasizes state over retrieval-only RAG +- [01:47:30](https://www.youtube.com/watch?v=LKRnP-ptC4c&t=6450s) — Closing reflections on feedback and weekly office hours + +## Model updates and benchmark context + +Opus 4.6 is the main headline for the episode. Cameron says Letta has already prepared support for the model in Letta Cloud and expects broader availability through the API path. He uses the release to explain a recurring Letta concern: better model performance is useful, but the practical question is how many tool calls, file openings, and context expansions a model needs to reach that performance. In the file system benchmark, Opus 4.6 edges out GPT-5.2, but the comparison is not simply about score. It is also about efficiency, because a model that reaches a high score while burning far more tokens changes the economics of long-running agent work. + +That same framing appears in the skills benchmark. Cameron treats the benchmark as evidence that model choice depends on task shape, not raw prestige. He also points out provider realities: some models look good in a demo but become unreliable once they are routed through inconsistent tooling layers. That is why the episode repeatedly ties model selection to first-party integration, provider consistency, and the operational cost of letting an agent reason for longer or act more broadly. + +## Letta Code and provider setup + +A large part of the hour is about making Letta Code easier to use with different model providers. Cameron describes an expanded `/connect` flow that lowers the friction for bring-your-own-key setups. The point is not just convenience. It is to make a coding agent adaptable to the environment the user already has: OpenAI, Anthropic, Google Gemini, MiniMax, OpenRouter, Bedrock, or enterprise-specific arrangements. + +He also highlights project-level LLM key management, which makes provider choice visible inside the product rather than buried in configuration. That shift matters because Letta’s agent tools are meant to be composable. If a coding agent can switch models, connect accounts, and select the right backend for the task, then the agent becomes a practical interface layer for long-term work rather than a fixed wrapper around one API. + +## Lettabot and agent autonomy + +Lettabot is presented as Letta’s answer to a more autonomous, server-hosted agent workflow. Cameron describes it as a way to deploy high-autonomy agents in Docker or via a Railway template, with communication channels layered on top. The architecture is intentionally built around remote access: a Letta Code instance can be “teleported” onto a server, then reached through an infrastructure layer that lets the agent observe, respond, and act across channels. + +The demo examples reinforce that design. Cameron shows how his personal agent can edit Obsidian notes, transcribe voice memos, and search conversation history. He also describes skills that let agents run recurring jobs like email briefings or RSS digests. The underlying message is that a well-armed agent should not just answer questions; it should manage workflows, keep schedules, and keep working without constant supervision. + +## Multi-agent patterns and self-referential work + +Another recurring subject is how agents can coordinate with other agents. Cameron explains that Letta agents can fork themselves, invoke existing agents by ID, or use specialized subagents for parallel work. This is not presented as a novelty. It is a pattern for scaling tasks that benefit from decomposition. A coding agent can dispatch work to a faster specialist, or even to a copy of itself, when the problem requires breadth rather than a single linear reasoning pass. + +That capability connects to the broader architecture of the platform. Letta is not only building agents; it is building the control surfaces for agents to modify other agents, maintain memory, and produce new behavior over time. In the episode, that becomes an argument for stateful systems over stateless prompts: if agents are going to collaborate, they need durable identity and stable access to the tools they use. + +## Q&A themes + +The audience questions keep returning to a few themes. One is voice: Cameron acknowledges strong demand for speech interfaces, especially for mobile or hands-busy contexts, even though he personally prefers typing. Another is context windows and model limits, including whether large windows will be available on specific plans. A third is provider quality, especially around OpenRouter and the uneven behavior that can appear when models are routed through inconsistent upstream infrastructure. + +There is also steady interest in memory, RAG, and agent search. Cameron argues that retrieval is helpful but incomplete. He points to the idea that Claude Code-style workflows often do better with agentic search than with rigid retrieval layers. In his framing, memory is not just what an agent knows; it is also how it behaves and how it remains itself across time. + +## Architectural through-line + +The episode’s through-line is that Letta wants agents with agency, persistence, and teeth. Models matter, but only insofar as they can operate inside a system that preserves state, lets them use tools, and gives them a way to collaborate with other agents. That is why so many of the session’s examples connect product surfaces back to architecture: Letta Code as an agent runtime, Lettabot as a deployment surface, Letta Cowork as a desktop interface, and the agent SDK as the underlying abstraction. + +Cameron closes by asking for feedback on what people want more of, because the product surface is broad and the team is still deciding where to invest. The episode makes a clear case for the direction of travel: away from isolated prompts and toward persistent, composable, operational agents. + +## Related public material + +- https://www.youtube.com/watch?v=LKRnP-ptC4c +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/lettabot +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk +- https://github.com/letta-ai/letta-cowork diff --git a/knowledge/published/letta-office-hours-2026-02-26.md b/knowledge/published/letta-office-hours-2026-02-26.md new file mode 100644 index 0000000..2fa0a33 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-02-26.md @@ -0,0 +1,110 @@ +--- +title: 'Letta Office Hours: MemFS, Letta Chat, and the future of AI agent memory' +slug: letta-office-hours-2026-02-26 +summary: >- + Office hours on MemFS, Letta Remote, Letta Chat, sleep-time compute, Lettabot + upgrades, and how Letta is rethinking agent memory. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - memfs + - letta-code + - letta-chat + - letta-remote + - lettabot + - agent-memory + - prompt-injection + - sleep-time-compute +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=p7So3IM75WY' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:0b15c3ad5683cc74b3aa457db444d2140c799bb2587946acbdf89667ff705bc7' +updated: '2026-08-07T02:33:36.459Z' +reviewStatus: approved +youtubeVideoId: p7So3IM75WY +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:25.458Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-02-26 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-02-26.json + receiptDigest: 'sha256:13c72b0b72e14ea29b42435dac82822ea9f1562ba28f386555beed258c1199d8' +publishedAt: '2026-08-07T02:41:25.458Z' +reviewedContentDigest: 'sha256:6bdb8734e8c0d359e8793766989a890a49541d07151b6b630e3d384cbb3f5a2b' +reviewReceiptDigest: 'sha256:13c72b0b72e14ea29b42435dac82822ea9f1562ba28f386555beed258c1199d8' +--- +In this office-hours episode, Cameron walks through the current Letta ecosystem and uses it to frame a larger shift in how agent memory can work. The headline is MemFS: a git-backed memory model where agents manage markdown files instead of opaque server-side blocks. That lets memory become versioned, parallelizable, and easier to inspect, while also making it possible for multiple agents to operate on the same repository with ordinary git-style workflows. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The rest of the episode connects that memory direction to the rest of the stack: Letta Code as the deployable local primitive, Letta Chat as a lighter interface for interacting with agents, Letta Remote as a browser-controllable listener mode, and Lettabot as the fast-moving consumer of new capabilities like voice memos and structured logging. The through-line is that agent systems become more useful when their state is portable, legible, and operationally composable. + +## Selected chapters +- [00:00:00](https://www.youtube.com/watch?v=p7So3IM75WY&t=0s) Introduction to office hours and the plan for slides plus live demos +- [00:01:30](https://www.youtube.com/watch?v=p7So3IM75WY&t=90s) Overview of the Letta product surfaces and recent launches +- [00:02:00](https://www.youtube.com/watch?v=p7So3IM75WY&t=120s) MemFS as the major new memory direction +- [00:03:30](https://www.youtube.com/watch?v=p7So3IM75WY&t=210s) Why git-backed markdown files change agent memory operations +- [00:05:30](https://www.youtube.com/watch?v=p7So3IM75WY&t=330s) How MemFS is structured with system folders and subagents +- [00:06:30](https://www.youtube.com/watch?v=p7So3IM75WY&t=390s) Letta Chat redesign and model selectors +- [00:07:30](https://www.youtube.com/watch?v=p7So3IM75WY&t=450s) Remote mode and the parallel with browser-controlled agents +- [00:10:00](https://www.youtube.com/watch?v=p7So3IM75WY&t=600s) Lettabot updates including voice memos and OpenAI-compatible endpoints +- [00:11:30](https://www.youtube.com/watch?v=p7So3IM75WY&t=690s) Letta v0.16.5 and server-side improvements +- [01:03:30](https://www.youtube.com/watch?v=p7So3IM75WY&t=3810s) Consolidating duplicate memory blocks with subagents +- [01:15:30](https://www.youtube.com/watch?v=p7So3IM75WY&t=4530s) Prompt injection defense through context and environment modeling +- [01:18:00](https://www.youtube.com/watch?v=p7So3IM75WY&t=4680s) Closing reflections on the value of Letta’s ecosystem + +## MemFS turns memory into a repository +The episode’s central technical idea is that memory should behave more like source control than like a hidden database. In the old block model, memory lived in attachable server-side objects. MemFS instead puts memory into a git repository where the agent works with markdown files. That matters because files are inspectable, diffable, mergeable, and easy to distribute across machines. It also means the agent can treat memory edits as a normal workflow: read, revise, commit, and continue. + +Cameron emphasizes that this is not just a storage change. It alters the shape of the agent’s work. A memory repository can hold both always-on context in a system folder and out-of-context notes that get looked up later. Because the repository is shared infrastructure, multiple agents can collaborate on the same context set and rely on version history instead of ad hoc synchronization. + +## Subagents do the memory labor +A major practical point in the episode is that memory maintenance itself can be delegated. MemFS supports subagents that read histories, summarize prior work, and write the results back into memory. Cameron describes bootstrapping a project by asking agents to read prior Claude and Codex histories, then using that material to seed a new context repository. This makes memory accumulation less manual and more like parallel knowledge extraction. + +That same pattern is extended to consolidation and defragmentation. If a system has too many memory blocks or duplicated facts, a specialized memory agent can run a consolidation pass and reorganize the repository. The broader architectural point is that the primary agent does not need to personally do every memory task; it needs a memory architecture that lets helper agents improve the substrate. + +## Letta Remote and Letta Chat move the interface outward +The episode also shows how Letta is pushing agent control away from a single server tab and toward more distributed use. Letta Remote turns an instance into a listener that can receive messages from elsewhere and operate on the local computer. Cameron frames this as comparable to remote-control modes in other coding tools, but tied to Letta’s own environment model. + +Letta Chat is presented as a cleaner, simpler front end with model selectors and reasoning controls. The important part is not the cosmetic redesign alone, but that the chat interface is becoming a place where agents can be aimed at specific environments, not just text prompts. That same idea explains why OpenAI-compatible endpoints, tool-call displays, and per-conversation model overrides matter: they make the system easier to compose into different workflows. + +## Lettabot and operational features +Lettabot gets a long list of incremental improvements, but the episode groups them around the same theme of usability. Voice memos, file-sending directives, structured logging, and per-chat scoping all make the agent easier to use in real conversations. The OpenAI-compatible endpoint is especially important because it lets people plug Letta into existing UI layers without rebuilding everything from scratch. + +The episode also notes sleep-time compute as a way to trigger reflection subagents on a schedule. That fits the same memory story: agent capability is not only about live response, but about asynchronous consolidation and background improvement. In practice, the system becomes more durable when it can keep thinking after the conversation pauses. + +## Q&A themes +Audience questions push on the boundaries of the new architecture: whether MemFS works self-hosted, how to consolidate many memory blocks, how to defend against prompt injection, and how separate conversations should be scoped across groups or individuals. Cameron’s answers recur to a few principles. First, context matters: agents are safer when they know the environment they are operating in. Second, memory is best managed by agents that specialize in memory. Third, many features are still being polished, so the episode often distinguishes what has been announced or demonstrated from what is fully settled. + +## Architectural through-line +Across the episode, the same design instinct appears again and again: make agent state explicit, portable, and revisable. MemFS does that for memory, Letta Remote does it for execution context, Letta Chat does it for human interaction, and Lettabot does it for product experimentation. Even the prompt-injection discussion follows the same pattern, because defense starts with making the agent’s world model clearer. + +That is why the episode treats markdown files, git history, subagents, and schedulable reflection as part of one architecture rather than separate features. The future being described is not a single model upgrade; it is an ecosystem in which memory, control, and interface are all designed to be inspectable and cooperative. + +## Related public material +- https://www.youtube.com/watch?v=p7So3IM75WY +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk diff --git a/knowledge/published/letta-office-hours-2026-03-05.md b/knowledge/published/letta-office-hours-2026-03-05.md new file mode 100644 index 0000000..3497917 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-03-05.md @@ -0,0 +1,113 @@ +--- +title: 'Letta Office Hours: Letta Remote, Claude Subconscious Demo, and Lettabot' +slug: letta-office-hours-2026-03-05 +summary: >- + Office hours on Letta Remote, chat-to-remote workflows, Lettabot updates, + pricing tradeoffs, and demos of Claude Subconscious and Co-work. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-remote + - letta-chat + - lettabot + - model-routing + - pricing + - claude-subconscious + - co-work +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=-SwpYxjGRdg' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:de98608e8664c3917b754afd70f329951f41f2b48f0112c1a94aee25dce0a69f' +updated: '2026-08-07T02:33:35.936Z' +reviewStatus: approved +youtubeVideoId: '-SwpYxjGRdg' +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:26.017Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-03-05 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-03-05.json + receiptDigest: 'sha256:4ecb1131e4839606f052d66810644ecc5267c50f36bef00a364f4ae4bec6fb6b' +publishedAt: '2026-08-07T02:41:26.017Z' +reviewedContentDigest: 'sha256:d2c13c155d14e3001bec16044f17f76ff6401f0945234faaa2bac1a04819212e' +reviewReceiptDigest: 'sha256:4ecb1131e4839606f052d66810644ecc5267c50f36bef00a364f4ae4bec6fb6b' +--- +At this office hours session, Cameron centered the discussion on one product shift: making Letta systems easier to run locally or on a server, then control from a chat surface anywhere. The episode frames Letta Remote as the transport layer for that workflow, and Letta Chat as the interface that can now talk to remote or server-mode instances. That pairing is the core architectural idea behind the hour: keep the agent runtime where it is most useful, then expose it through a lightweight client that can reach it from different surfaces. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +Around that core, the episode surveys adjacent product changes and why they matter. Lettabot gets operational improvements such as run cancellation, per-agent tool scoping, automatic secret redaction, Docker-friendly deployment, and a new model router. Cameron also discusses onboarding changes, model availability, and the practical cost pressures that shape plan limits. The rest of the hour uses live demos and Q&A to connect those changes to real workflows: remote control of a home server, a memory layer for Claude Code, and a simpler desktop-style front end for non-developers. + +## Selected chapters +- [00:00:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=0s) Opening remarks and the episode focus +- [00:00:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=30s) Letta Remote overview +- [00:01:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=90s) Letta Chat for remote and server mode +- [00:02:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=120s) Lettabot updates: cancel, model selection, redaction +- [00:03:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=210s) Per-agent tool scoping and Docker deployment +- [00:04:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=270s) ChatGPT onboarding and model access +- [00:10:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=600s) Max-plan usage limits and pricing tradeoffs +- [00:12:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=750s) Why memory and cheaper models matter +- [00:15:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=930s) Model behavior, intent, and architecture +- [01:28:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=5280s) Claude Subconscious demo and ecosystem value +- [01:33:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=5580s) Letta Co-work as a prettier local interface +- [01:41:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=6090s) Product positioning for Chat, Code, and Bot + +## Letta Remote as a control plane +Letta Remote is presented as a way to deploy a Letta Code instance on a machine and then interact with it from elsewhere. The important detail is not that it adds another app, but that it separates execution from interaction. A machine can host the agent runtime, while Letta Chat or the agent development environment becomes the client that reaches it. That makes the same agent available from a laptop, a home server, or another remote system without requiring the user to sit at the machine running the process. + +The episode emphasizes that the remote mode is intentionally simple. It is described as a websocket-based connection rather than a full UI stack, which keeps the transport layer narrow and easier to reason about. That design helps explain why remote control can become a foundation for other interfaces: if the server side stays small and well-defined, then multiple clients can speak the same protocol. + +## Letta Chat becomes the front door +Letta Chat is described as the consumer-facing surface that can now work with remote and server-mode Letta Code instances. In practice, that means chat is not just a standalone product; it becomes the main way to reach an agent that lives somewhere else. The episode repeatedly frames this as a product funnel: chat for basic users, code for developers, and the code SDK for API-driven work. + +That framing matters because it shows how the team is organizing complexity. Instead of asking every user to understand server deployment, the product stack can present a simple chat interface first. The deeper machinery stays available underneath for people who need it. The episode suggests that this is also why remote support is strategically important: it makes the chat interface useful for more than one local session. + +## Lettabot as a configurable agent system +A substantial portion of the hour is spent on Lettabot, but not as a generic changelog. The changes discussed all point in the same direction: making agents safer, more controllable, and more usable in shared environments. Cancelling a run prevents a bad execution from continuing. Per-agent tool scoping limits what each agent can touch. Automatic secret redaction reduces the chance that keys leak into shared channels. Docker deployment and YAML-style configuration make it easier to run the system outside narrow hosting assumptions. + +The discussion of model routing and onboarding also fits that pattern. A better default model path can reduce setup friction, while allowing users to choose models through the channel they are already using. The broader point is that agent systems become more practical when they can be constrained, inspected, and deployed in predictable ways. + +## Pricing, models, and the memory tradeoff +The episode spends time on cost structure because model choice is not abstract in an agent product. Cameron explains that higher-end models can be expensive to serve, especially when agents carry large token loads across repeated turns. The result is a practical tension: users want powerful models, but the system must remain economically sustainable. + +That leads to a repeated argument for architecture and memory. If a lower-cost model plus better memory can deliver most of the value, then the system can serve more users more reliably. The hour does not dismiss premium models; it instead positions them as one part of a broader stack. The architectural win is to improve the agent’s effectiveness so that users are not forced to buy the most expensive model for every task. + +## Claude Subconscious and Co-work +Two demos broaden the conversation beyond core Letta products. Claude Subconscious is presented as a memory layer for Claude Code that uses a background Letta agent to provide contextual help. The key idea is ecosystem bridging: Letta can add value even when the user is working in a different coding surface, because a persistent sidecar agent can whisper context into that session. + +Co-work serves a different audience. It is described as a prettier, more approachable local interface on top of Letta Code, aimed at people who do not want to live in a terminal. The episode treats it as a useful open-source front end for non-developers and a reminder that the same agent runtime can support multiple UX layers. + +## Q&A themes +The questions circle around several recurring themes: Windows and WSL support, whether Claude OAuth can be offered, how model limits are managed, and whether users can get better visibility into usage. Another thread is product positioning: when should someone use chat, code, or bot, and which audiences belong in each surface? The answers consistently point toward reducing friction while preserving safety and cost control. + +## Architectural through-line +The through-line is a layered agent stack. Letta Remote provides the transport and deployment story. Letta Chat provides the accessible interface. Letta Code and the SDK support developers and advanced workflows. Lettabot and its tooling expose more powerful automation with additional controls. Around that stack, memory is what makes the whole system durable across sessions, machines, and interfaces. + +## Related public material +- https://www.youtube.com/watch?v=-SwpYxjGRdg +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk +- https://github.com/letta-ai/hypervigilant diff --git a/knowledge/published/letta-office-hours-2026-03-12.md b/knowledge/published/letta-office-hours-2026-03-12.md new file mode 100644 index 0000000..2c35b5b --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-03-12.md @@ -0,0 +1,126 @@ +--- +title: 'Letta Office Hours: March 12, 2026' +slug: letta-office-hours-2026-03-12 +summary: >- + Office hours recap of Auto Mode, Letta Code and Chat changes, Lettabot + improvements, Ezra's new capabilities, and community-built fleet and team + tooling. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - auto-mode + - letta-code + - letta-chat + - lettabot + - ezra + - community-tools +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=rCOHloFHgMs' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:8faab75eb6f3b4188a00a2ba66f5c96dcf201bc1d715e97ac4a5ffdd488c63de' +updated: '2026-08-07T02:39:42.707Z' +reviewStatus: approved +youtubeVideoId: rCOHloFHgMs +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:26.583Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-03-12 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-03-12.json + receiptDigest: 'sha256:11879497a81e8abb7988b13c2f2157e5070c8648d9f6ac88080a6100ec221b7b' +publishedAt: '2026-08-07T02:41:26.583Z' +reviewedContentDigest: 'sha256:2d70a94736c1051b45773c95cd4851877375eb5b2768e9363922c1cf7b5cd9da' +reviewReceiptDigest: 'sha256:11879497a81e8abb7988b13c2f2157e5070c8648d9f6ac88080a6100ec221b7b' +--- +Letta Office Hours on March 12, 2026 centered on a practical theme: reducing the friction between an agent and the work it can safely do. The episode opened with a product sweep across routing, initialization, memory handling, chat, bot infrastructure, and community tooling, then moved into live Q&A about model choice, reliability, and how to think about agents as systems rather than single prompts. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The through-line is that Letta is becoming a layered platform for agent operation. Some changes reduce cost and cache churn, some improve transparency, and others expand where agents can act—whether that is inside Letta Chat, across remote servers, or out on Bluesky. The episode is less about isolated feature drops than about a more operational stack for building, routing, observing, and delegating to agents. + +## Selected chapters + +- [00:00:00](https://www.youtube.com/watch?v=rCOHloFHgMs&t=0s) Opening context for office hours and the session format +- [00:00:30](https://www.youtube.com/watch?v=rCOHloFHgMs&t=30s) Auto Mode introduction and routing overview +- [00:02:00](https://www.youtube.com/watch?v=rCOHloFHgMs&t=120s) Auto and Auto Fast model selection details +- [00:02:30](https://www.youtube.com/watch?v=rCOHloFHgMs&t=150s) Letta Code initialization returns to slash init +- [00:03:30](https://www.youtube.com/watch?v=rCOHloFHgMs&t=210s) Skills move to system reminders after compaction +- [00:04:30](https://www.youtube.com/watch?v=rCOHloFHgMs&t=270s) Letta Chat becomes the primary interface with remote mode support +- [00:05:00](https://www.youtube.com/watch?v=rCOHloFHgMs&t=300s) Letta Bot and Bluesky channel support +- [00:06:30](https://www.youtube.com/watch?v=rCOHloFHgMs&t=390s) Configurable memory sleep time in lettabot.yaml +- [00:07:30](https://www.youtube.com/watch?v=rCOHloFHgMs&t=450s) LettaCTL fleet deployment support and turn viewer diagnostics +- [00:09:00](https://www.youtube.com/watch?v=rCOHloFHgMs&t=540s) Ezra capability update +- [00:10:30](https://www.youtube.com/watch?v=rCOHloFHgMs&t=630s) Community projects: LettaCTL and Letta Teams +- [01:13:00](https://www.youtube.com/watch?v=rCOHloFHgMs&t=4380s) Correcting agent behavior through memory updates + +## Auto Mode and model routing + +Auto Mode was presented as a free automatic model router that chooses a model for the task at hand. The point is not just convenience but routing intelligence: the system can infer context such as whether a call is for a sub-agent or an exploration task and then choose accordingly. The episode described Auto Mode as beta software with a simple starting point and an evolving routing layer, plus an `auto-fast` variant for people who want a similar experience with a faster path. + +That matters because model selection becomes part of the agent stack, not a separate manual decision. The episode framed this as especially useful for large agent systems, sub-agent-heavy workflows, and cost-conscious personal agents. The product direction is clear: use routing to make agents easier to operate without forcing users to manage every model choice by hand. + +## Letta Code and the cost of memory churn + +The Letta Code section focused on initialization and skills management. Initialization returned to a manual `slash init` flow, with the agent walking through questions and memory creation in real time. The reason was usability: the prior background process made the experience harder to follow. The episode also noted support for newer ChatGPT-plan access to GPT-5.4 and GPT-5.4 Fast. + +The more architectural change was the move from a skills memory block to system reminders delivered after compaction. That shift reduces cache invalidation when skills change, which the episode said can save a large amount of token cost. Mechanically, this is a good example of Letta treating memory as an operational resource: the system is not only storing facts, it is trying to preserve efficient inference behavior across turns. + +## Letta Chat as the primary surface + +Letta Chat was described as the platform’s primary interface going forward. The episode emphasized remote mode support, where an agent can connect to a Letta Code remote server and act through that environment from the chat UI. That makes chat a control plane, not just a messaging layer. It is where memory visibility, remote execution, and future tooling are expected to converge. + +The implication is that chat becomes the front door for more of the platform’s capabilities. Instead of making users switch between separate products, Letta is moving toward a unified experience where the agent’s state, execution environment, and task history are surfaced together. + +## Lettabot, Bluesky, and operational visibility + +Lettabot received a large update. The episode highlighted a Bluesky channel, configurable listening rules, posting and replying behavior, and a `lettabot connect chatgpt` flow for model access through ChatGPT plans. It also mentioned fleet deployment support through LettaCTL and a new turn viewer for diagnostics. + +The key theme is observability plus reach. Lettabot is no longer just a personal assistant hooked to chat platforms; it is becoming a deployable agent service that can act in public channels, be inspected more easily, and be tuned through configuration. The discussion of MFS sleep time reinforces that the system is being adjusted for practical operation rather than static defaults. + +## Ezra and community-built agent systems + +The episode presented Ezra, the community support agent, as a broader capability update. The useful public point is the change in role: the support agent was moving beyond canned answers toward more active technical assistance. + +The community projects section extended that same idea. LettaCTL was described as declarative fleet management for agents, especially useful when remote environments need to be attached as execution backends. Letta Teams adds a higher-level abstraction for spawning specialized sub-agent teams, coordinating work, and tracking progress. Both projects point toward the same pattern: agents work better when their work is structured into explicit operational roles. + +## Q&A themes + +The Q&A settled into a few recurring themes: who chooses the model, how much autonomy is safe, and what counts as a good agent workflow. Auto Mode was explicitly described as Letta-selected rather than BYOK, with the system choosing among supported models. There was also discussion of using agents for research, monitoring, and supervised public activity. + +Another theme was how to correct an agent when it misinterprets its environment. The episode’s answer was pragmatic: tell the agent to update its memory with the relevant mapping. That advice fits the rest of the session. Behavior is not treated as fixed personality; it is something the system can learn from memory, routing, and environment-specific instructions. + +## Architectural through-line + +Across all the announcements, the architecture is converging on a few layers: routing decides how work is handled, memory remembers how the environment works, chat provides the operator interface, and bots or remote servers supply execution. That is why the episode spent so much time on compaction, system reminders, remote mode, and diagnostics. These are not cosmetic features; they are the scaffolding of a more dependable agent platform. + +The result is a platform that treats agents as long-running systems. Letta is moving from “prompt and response” toward “observe, route, execute, and refine.” + +## Related public material + +- https://www.youtube.com/watch?v=rCOHloFHgMs +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk +- https://github.com/letta-ai/hypervigilant diff --git a/knowledge/published/letta-office-hours-2026-03-19.md b/knowledge/published/letta-office-hours-2026-03-19.md new file mode 100644 index 0000000..4eaa49f --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-03-19.md @@ -0,0 +1,119 @@ +--- +title: 'Letta Office Hours: March 19th, 2026' +slug: letta-office-hours-2026-03-19 +summary: >- + Cameron explains Letta’s client-side shift, MemFS, sleeper agents, + deprecations, and the move toward skills, code SDK orchestration, and + computer-use-first workflows. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-s-next-phase + - memfs + - computer-use + - skills + - code-sdk + - agent-orchestration + - pricing + - letta-code +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=N-XNeX5kROE' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:5c0937cf413ad1c748d18e00f42a28611aaf7b95aa21fa5a91ef98661d696070' +updated: '2026-08-07T02:33:34.874Z' +reviewStatus: approved +youtubeVideoId: N-XNeX5kROE +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:27.165Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-03-19 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-03-19.json + receiptDigest: 'sha256:e028470888714a7a3f5c749c77e653f69890d55abff09819d36207da1fdcd174' +publishedAt: '2026-08-07T02:41:27.165Z' +reviewedContentDigest: 'sha256:568d3c4f5f48a8e38be32e50dadc7c7758ae1a3585c171ae4788886dd984a7fe' +reviewReceiptDigest: 'sha256:e028470888714a7a3f5c749c77e653f69890d55abff09819d36207da1fdcd174' +--- +Letta Office Hours on March 19, 2026 centered on a strategic shift: the product is moving from server-side, chatbot-style agents toward client-side computer-use workflows. Cameron framed that change as a reorientation around agents that can operate on a machine, use files directly, and orchestrate work through local or remote environments rather than relying on fragile server-side abstractions. The episode also introduced a broad set of deprecations and migrations that follow from that bet, including MemFS as the default memory layer and skills as the preferred integration surface. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The practical message was less “here is a list of features” than “here is the architecture Letta now wants people to build on.” That meant new pricing, new defaults in Letta Code, a live preview of the desktop client, and repeated guidance to move away from legacy server-side patterns such as tool rules, templates, file-system-style server storage, and agent-to-agent messaging. The episode’s Q&A filled in the mechanics: how prompt caching interacts with memory edits, how MemFS behaves across devices, and why client-side orchestration is meant to be cheaper, safer, and more expressive. + +## Selected chapters +- [00:01:00](https://www.youtube.com/watch?v=N-XNeX5kROE&t=60s) Letta’s next phase and the move to client-side capabilities +- [00:02:30](https://www.youtube.com/watch?v=N-XNeX5kROE&t=150s) Letta Code as the deployable harness for computer-use agents +- [00:04:30](https://www.youtube.com/watch?v=N-XNeX5kROE&t=270s) Computer use as the core agent model +- [00:05:00](https://www.youtube.com/watch?v=N-XNeX5kROE&t=300s) MemFS rollout and memory-block migration +- [00:06:30](https://www.youtube.com/watch?v=N-XNeX5kROE&t=390s) Sleeptime refactor and computer-use subagents +- [00:07:30](https://www.youtube.com/watch?v=N-XNeX5kROE&t=450s) Deprecating agent-to-agent tools +- [00:09:00](https://www.youtube.com/watch?v=N-XNeX5kROE&t=540s) Skills replacing server-side MCP +- [00:12:30](https://www.youtube.com/watch?v=N-XNeX5kROE&t=750s) Templates, agent files, and version-controlled deployments +- [00:14:30](https://www.youtube.com/watch?v=N-XNeX5kROE&t=870s) Tool rules as a mismatch for autonomous agents +- [00:18:30](https://www.youtube.com/watch?v=N-XNeX5kROE&t=1110s) Letta Code manual slash mode and subagent behavior +- [00:20:30](https://www.youtube.com/watch?v=N-XNeX5kROE&t=1230s) The desktop client and live demo preview +- [01:25:00](https://www.youtube.com/watch?v=N-XNeX5kROE&t=5100s) Prompt caching, compaction, and how MemFS changes cost dynamics + +## Letta’s next phase +The episode’s central theme was a deliberate change in what Letta is optimized for. Cameron described the older model as “brains in a jar”: server-side agents with memory, tools, and MCP attachments that acted mostly through hosted endpoints. The new model prioritizes client-side capabilities, especially computer use. In that framing, the important unit is not a server-hosted chatbot, but an agent that can operate within a real environment and act on files, terminals, and applications. + +That shift also redefines Letta Code. Rather than being only a coding product, it becomes the harness for deploying agents anywhere a computer is available. Cameron explicitly broadened the use case beyond coding to note-taking, knowledge management, and other computer tasks. The architectural implication is that orchestration should happen closer to the environment where the work occurs. + +## MemFS as the new memory layer +A major migration in the episode was MemFS, the git-backed filesystem memory system. Cameron’s explanation treated it as more powerful than classic memory blocks because it is versioned, directly editable, and naturally suited to client-side workflows. Instead of writing memory through APIs that can trigger cache recompilation, an agent can work on files in its local repository and preserve more efficient prompt caching behavior. + +The episode also clarified that MemFS is meant to replace the older memory-block workflow over time, though the exact treatment of existing blocks was still being worked out. The core idea is that memory should behave like normal source-controlled state: visible on disk, diffable, syncable across devices, and compatible with ordinary Git conflict resolution. That makes memory less like a special hosted service and more like a portable project artifact. + +## Sleeptime, subagents, and orchestration +Sleeptime was presented as the pattern for background memory work. Instead of a server-side reflection process, Letta now wants a computer-use subagent to read the conversation and update MemFS. That same logic extends to multi-agent orchestration more broadly: rather than sending messages between hosted agents and hoping they can act, the preferred pattern is for subagents to operate in environments that have the tools needed to finish work. + +This is why agent-to-agent tools were described as deprecated. Cameron argued that server-side messaging is brittle, can loop dangerously, and often strips the receiving agent of the ability to do anything useful. The replacement is more explicit orchestration through tasks, skills, and computer-use agents. The through-line is that messages should lead to action in a real environment, not just another inert server-side response. + +## Skills, MCP, templates, and tool rules +The episode repeatedly positioned skills as the higher-level integration primitive. Server-side MCP was described as fragile and low power, while skills were framed as composable, lower-token, and better aligned with client-side computer use. In practice, that means capabilities previously bolted onto hosted agents should increasingly live in skills that can invoke local tools or translate external services into command-line workflows. + +Templates and tool rules were both treated as legacy abstractions. Templates were criticized as a large maintenance surface that can be replaced by code and version control. Tool rules were described as a mismatch for autonomous agents, since they try to impose workflow logic more suited to chain-like systems. The episode’s message was that Letta wants agent behavior to emerge from code, skills, and environment access rather than from rigid server-side policy layers. + +## Pricing and Letta Code changes +Cameron also announced new pricing plans and described Letta Code updates. The pricing names were introduced as part of the same transition: the product package is being reorganized around the client-side direction. In Letta Code itself, manual slash mode and subagent behavior were highlighted as examples of the new workflow model, with subagents using Letta Auto. + +The live desktop-client preview reinforced the same point visually: Letta is moving toward a local, computer-use-first experience rather than a remote chat interface with a few add-ons. Even the feature announcements were tied back to architecture. The message was not just that the product gained options, but that the options now support a different operating model. + +## Q&A themes +The Q&A focused on implementation mechanics rather than product slogans. Several questions explored how prompt caching works, why changing memory blocks can be expensive, and when MemFS edits do or do not force recompilation. Cameron explained that edits made directly in MemFS behave more like ordinary file changes, while legacy API writes can invalidate more of the cache. + +Another recurring theme was coordination: how to keep agents aware of shared state, how to propagate changes, and how to manage updates across devices. The answer was consistently file-centric. Shared state should be represented as files, watched through hooks or direct reads, and synchronized like source code. That approach is more transparent and more compatible with the rest of the new stack. + +## Architectural through-line +The episode’s architecture can be summarized simply: move state to files, move work to computers, and move orchestration into code and skills. MemFS makes memory behave like version-controlled source. Computer use makes agents capable of meaningful action. Skills and the code SDK provide the coordination layer. Legacy hosted features remain available only as transitional scaffolding while the platform shifts. + +That is why the episode spent so much time on deprecations. Each removed or discouraged feature points in the same direction: away from opaque server-side agent behavior and toward explicit, inspectable, local-first workflows. The result is a platform that is easier to reason about because it resembles software development itself—files, diffs, repositories, tools, and executable environments. + +## Related public material +- https://www.youtube.com/watch?v=N-XNeX5kROE +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk +- https://github.com/letta-ai/hypervigilant diff --git a/knowledge/published/letta-office-hours-2026-03-26.md b/knowledge/published/letta-office-hours-2026-03-26.md new file mode 100644 index 0000000..9fa95d6 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-03-26.md @@ -0,0 +1,115 @@ +--- +title: 'Letta Office Hours: Desktop Early Access, Forking, Secrets, Memory Doctor' +slug: letta-office-hours-2026-03-26 +summary: >- + Office hours covering desktop early access, new slash commands, memory health + checks, auto fallback, and the shift toward stateful multi-agent workflows. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - desktop-app + - slash-commands + - secrets + - memory-health + - auto-fallback + - multi-agent-workflows +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=p5rhR83jtWo' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:509b965edddc23695ba1a0df46e8f9101246d14456cfb26526f01866dd79060c' +updated: '2026-08-07T02:33:34.337Z' +reviewStatus: approved +youtubeVideoId: p5rhR83jtWo +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:27.710Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-03-26 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-03-26.json + receiptDigest: 'sha256:b7198cabadbc12f241513fba908534e7e17c191ca427bcc57cd7b73b5adf9d60' +publishedAt: '2026-08-07T02:41:27.710Z' +reviewedContentDigest: 'sha256:498ef5b8636e64ddbec454cd377c440010963c309d5d27a4482deb64b4bbece6' +reviewReceiptDigest: 'sha256:b7198cabadbc12f241513fba908534e7e17c191ca427bcc57cd7b73b5adf9d60' +--- +This office hours episode centered on a clear product shift: Letta is moving from a chat-centric coding assistant toward a desktop-native environment built around persistent agents, local machine access, and more explicit control over conversations. Cameron framed the desktop app as early access for Pro, Max Light, and Max users, but the larger point was architectural: the app is not just a new shell. It is a GUI over the same agent system, designed to make stateful agents easier to inspect, steer, and trust while working locally. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +That theme carried through the rest of the session. The updates were not presented as isolated features, but as pieces of a broader workflow in which conversations can be named, branched, guarded, and repaired. The episode also widened into Q&A about memory, multi-agent patterns, community use cases, and the evolving boundary between “agent as tool” and “agent as durable collaborator.” + +## Selected chapters +- [00:00:45](https://www.youtube.com/watch?v=p5rhR83jtWo&t=45s) Desktop app early access +- [00:02:30](https://www.youtube.com/watch?v=p5rhR83jtWo&t=150s) Desktop app demo walkthrough +- [00:06:00](https://www.youtube.com/watch?v=p5rhR83jtWo&t=360s) `/new` — named conversations +- [00:06:40](https://www.youtube.com/watch?v=p5rhR83jtWo&t=400s) `/fork` — fork conversations +- [00:07:50](https://www.youtube.com/watch?v=p5rhR83jtWo&t=470s) `/secret` — secret management +- [00:10:10](https://www.youtube.com/watch?v=p5rhR83jtWo&t=610s) `/doctor` — memory health check +- [00:11:43](https://www.youtube.com/watch?v=p5rhR83jtWo&t=703s) Auto-fallback on quota limit +- [00:13:00](https://www.youtube.com/watch?v=p5rhR83jtWo&t=780s) Slash command queuing +- [00:14:12](https://www.youtube.com/watch?v=p5rhR83jtWo&t=852s) Performance & boot improvements +- [00:14:25](https://www.youtube.com/watch?v=p5rhR83jtWo&t=865s) Yellow death error fixes +- [00:59:35](https://www.youtube.com/watch?v=p5rhR83jtWo&t=3575s) Multi-agent workflows, sub-agents, and Letta Teams +- [01:05:40](https://www.youtube.com/watch?v=p5rhR83jtWo&t=3940s) Self-dispatching sub-agents + +## Desktop as a stateful agent shell +The desktop app was introduced as an early-access layer on top of Letta Code, with a focus on making agent interaction feel native to the machine instead of purely remote or terminal-bound. The demo highlighted familiar controls — agent switching, conversation lists, memory viewing, and an embedded terminal — but the important change was how the interface exposes the agent as a persistent object. Instead of treating each prompt as isolated, the desktop view surfaces favorites, per-agent histories, and the ability to browse memory directly. + +That design reinforces one of Letta’s core ideas: agents are not stateless request handlers. They have identity, accumulated context, and an ongoing relationship with the user. The desktop app is meant to make those qualities legible. The episode emphasized that the team is seeking feedback on the interaction model, not just on polish, because the product is being shaped around how people actually want to manage durable agents. + +## Named conversations and branching workflows +Two small slash commands illustrated how the product is being adapted for long-running work. `/new` now lets a user create and name a conversation in one step, which makes later retrieval easier. `/fork` goes further by cloning a conversation history at a chosen point so the same context can branch into a different task. The episode presented this as a practical answer to a common workflow problem: once an agent has reached a good state, users often want to continue from there without losing the original thread. + +These features point to a broader model of agent usage. Conversations are not disposable chats; they are working branches. Naming and forking make that structure visible and manageable, especially when a single agent is being used across multiple tasks over time. + +## Secrets and safer agent access +The `/secret` command was framed as a safety mechanism for sensitive values. The key idea is separation between a usable secret and the value itself: an agent can reference the secret in execution, but it does not receive the plaintext value in conversation history. Cameron described this as a response to a real failure mode in LLM workflows, where environment values can leak into prompts, logs, or later disclosures once they have been exposed to the model. + +The mechanism matters because it treats secrecy as a property of the agent system, not just of storage. If a secret never becomes visible content, the agent can still operate with it while remaining unable to repeat it back. In the episode’s terms, that is part of making agents safe enough to trust with local work. + +## Memory health as maintenance +The `/doctor` command introduced a more opinionated way to maintain an agent’s memory. Rather than leaving context buildup to accumulate, the memory doctor scans for duplication, stale entries, poor structure, and unnecessary bloat, then consolidates and rewrites memory to improve signal quality. The discussion made clear that this is not about changing what the agent knows so much as about improving how that knowledge is organized and surfaced. + +This is important because Letta’s memory model is doing real work over time. The episode linked health checks to context window pressure, redundant preferences, and overgrown memory graphs. “Doctor” is therefore less a novelty than an operational tool: it preserves usefulness by keeping memory compact, coherent, and retrievable. + +## Fallbacks, queues, and responsiveness +Several smaller updates were about reducing friction during live use. Auto-fallback means that when a higher-tier mode runs out of quota, the system can fall back to a default auto mode instead of stopping abruptly. Slash commands can now be queued while the agent is busy, which avoids the old wait-until-finished constraint. Boot and navigation feel faster, and some recurring error states were fixed so the interface recovers more cleanly. + +Taken together, these changes make the product feel less interrupt-driven. The user can keep working while the system catches up, which matters in a desktop environment where the agent is expected to sit alongside other tasks rather than block them. + +## Q&A themes +The Q&A portion stretched the episode from product updates into platform direction. Questions about sleep-time behavior, reflection, and memory management led into a discussion of when an agent should use its own tools versus when it should dispatch sub-agents. Questions about multi-agent workflows pointed toward Letta Teams as a reusable pattern for coordinated agent collaboration. + +There was also a recurring contrast between memory blocks and MemFS-style memory. The episode positioned MemFS as part of a transition to more embodied, persistent agents — the kind that live on a machine, develop stable identity, and need memory ergonomics suited to that role. Legacy blocks were not treated as obsolete overnight, but as a model that may still fit some developer deployments. + +## Architectural through-line +The episode’s deepest thread is that Letta is formalizing the difference between a tool and an agent with continuity. The desktop app, slash commands, secrets, doctor, fallback behavior, and queued actions all support a system where an agent can be used repeatedly, forked safely, cleaned up regularly, and composed with others. The focus is not on making a clever prompt interface; it is on making durable agent operations practical. + +That is why the discussion kept returning to stateful agents, memory hygiene, and reusable workflows. The architecture being described is one where the interface, memory system, and execution model all assume persistence. The result is a product that tries to make long-lived agents easier to manage without hiding the machinery that makes them work. + +## Related public material +- https://www.youtube.com/watch?v=p5rhR83jtWo +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk diff --git a/knowledge/published/letta-office-hours-2026-04-02.md b/knowledge/published/letta-office-hours-2026-04-02.md new file mode 100644 index 0000000..498c47b --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-04-02.md @@ -0,0 +1,120 @@ +--- +title: 'Letta Office Hours: April 2nd, 2026' +slug: letta-office-hours-2026-04-02 +summary: >- + Cameron introduces the new Letta Code app, demos memory repair and sleep-time + processing, and answers questions on tools, deployment, and agent memory + design. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-code-app + - schedules + - skills-marketplace + - sleep-time-compute + - memory-filesystem + - context-doctor + - tool-architecture + - agent-ux +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=lz4LZfaG92Y' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:5e668de88a2456f316d3877ead05ad4217fece8bb7be603114bf6af007f9de7a' +updated: '2026-08-07T02:33:33.795Z' +reviewStatus: approved +youtubeVideoId: lz4LZfaG92Y +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:28.256Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-04-02 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-04-02.json + receiptDigest: 'sha256:6c845363196347f7044e4c0b3f47351f5397628d77c9cf9c5d351815df8c26d4' +publishedAt: '2026-08-07T02:41:28.256Z' +reviewedContentDigest: 'sha256:f2a188b51516ffc8f12fe3412bc19eba642021c1cb92e01cbe5abf35ab242ef2' +reviewReceiptDigest: 'sha256:6c845363196347f7044e4c0b3f47351f5397628d77c9cf9c5d351815df8c26d4' +--- +Letta 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. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The 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. + +## Selected chapters + +- [0:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=0s) Intro +- [0:35](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=35s) Letta Code app overview +- [1:30](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=90s) New features: skills sidebar & schedules UI +- [5:06](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=306s) Open source release update +- [7:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=420s) Sleep-time compute & background memory UI +- [10:30](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=630s) AI conversation summaries +- [17:45](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=1065s) Lettasphere community +- [20:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=1200s) Q&A: agent payments & financial APIs +- [30:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=1800s) Context Doctor demo (corrupted memory) +- [33:00](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=1980s) Memory filesystem walkthrough (tree, git log) +- [51:43](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=3103s) Git rollback for memory & granular commits +- [1:17:48](https://www.youtube.com/watch?v=lz4LZfaG92Y&t=4668s) Tool architecture: server-side vs client-side + +## The Letta Code app as an agent dashboard + +The 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. + +Two 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. + +## Sleep-time compute and memory processing + +The 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. + +This 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. + +## Context Doctor and memory repair + +A 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. + +The 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. + +## Tool architecture and the move toward client-side execution + +Another 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. + +By 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. + +## Q&A themes + +The 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. + +The 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. + +## Architectural through-line + +What 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. + +That 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. + +## Related public material + +- https://www.youtube.com/watch?v=lz4LZfaG92Y +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code diff --git a/knowledge/published/letta-office-hours-2026-04-09.md b/knowledge/published/letta-office-hours-2026-04-09.md new file mode 100644 index 0000000..bd9f394 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-04-09.md @@ -0,0 +1,121 @@ +--- +title: 'Letta Office Hours: April 9th, 2026' +slug: letta-office-hours-2026-04-09 +summary: >- + Office hours covering Letta Code general access, remote control mode, the + memory viewer, social agents, ChatGPT memory import, and the Context + Constitution. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-code + - memory + - agent-harnesses + - social-agents + - context-management + - product-philosophy +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=1ACUkf5dep0' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:8259976dfbc27f8e235658398d4446b641fdccd8a5dbccb82783c0782fcfa442' +updated: '2026-08-07T02:33:33.273Z' +reviewStatus: approved +youtubeVideoId: 1ACUkf5dep0 +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:28.802Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-04-09 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-04-09.json + receiptDigest: 'sha256:da42e2167714743cdb50e5fa372464e804a0849acfadc6f216546dc8f983a426' +publishedAt: '2026-08-07T02:41:28.802Z' +reviewedContentDigest: 'sha256:9cc0a21d5e8173f4151177747a0c19a4418f92d6727bde61343bf6d8c5515fde' +reviewReceiptDigest: 'sha256:da42e2167714743cdb50e5fa372464e804a0849acfadc6f216546dc8f983a426' +--- +Letta’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. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +A 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. + +## Selected chapters + +- [0:00 Intro](https://www.youtube.com/watch?v=1ACUkf5dep0&t=0s) +- [0:39 Letta Code app in general access](https://www.youtube.com/watch?v=1ACUkf5dep0&t=39s) +- [2:30 Remote control mode: Letta Chat + desktop agent](https://www.youtube.com/watch?v=1ACUkf5dep0&t=150s) +- [4:24 Updated memory viewer (core, external, git history)](https://www.youtube.com/watch?v=1ACUkf5dep0&t=264s) +- [5:23 Reflection agent prompting changes](https://www.youtube.com/watch?v=1ACUkf5dep0&t=323s) +- [7:35 File watching for agents](https://www.youtube.com/watch?v=1ACUkf5dep0&t=455s) +- [8:46 Social CLI: inbox/outbox for social agents](https://www.youtube.com/watch?v=1ACUkf5dep0&t=526s) +- [11:12 ChatGPT memory import skill](https://www.youtube.com/watch?v=1ACUkf5dep0&t=672s) +- [15:35 Graph memory vs document-based memory](https://www.youtube.com/watch?v=1ACUkf5dep0&t=935s) +- [39:35 Future of Lettabot: integration into Letta Code](https://www.youtube.com/watch?v=1ACUkf5dep0&t=2375s) +- [47:30 Three user profiles: companion, code, developer](https://www.youtube.com/watch?v=1ACUkf5dep0&t=2850s) +- [1:29:34 Context Constitution deep dive](https://www.youtube.com/watch?v=1ACUkf5dep0&t=5374s) + +## Letta Code as a control surface + +The 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. + +Remote 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. + +## Memory as a first-class part of the harness + +A 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. + +The 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. + +## Scheduling, file watching, and social automation + +Several 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. + +The 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. + +## Importing history into a new agent + +The 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. + +That 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. + +## The Context Constitution and agent identity + +The 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. + +The 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. + +## Q&A themes + +The 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. + +## Architectural through-line + +Across 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. + +## Related public material + +- https://www.youtube.com/watch?v=1ACUkf5dep0 +- https://docs.letta.com/ +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/social-cli +- https://www.letta.com/blog/context-constitution diff --git a/knowledge/published/letta-office-hours-2026-04-16.md b/knowledge/published/letta-office-hours-2026-04-16.md new file mode 100644 index 0000000..f30d038 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-04-16.md @@ -0,0 +1,116 @@ +--- +title: 'Letta Office Hours: Channels, Cron, and Opus 4.7' +slug: letta-office-hours-2026-04-16 +summary: >- + Office hours on built-in channels, schedules, remote environments, and how + recent model and agent changes shape always-on workflows. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - channels + - cron + - remote-environments + - slack + - telegram + - subagents + - memory + - local-models +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=B_wZTyyZzkw' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:fbe3aed2e7b38793e8b9e6e74749c589ac6e2a908619fb5491cd58017680f4c5' +updated: '2026-08-07T02:33:32.740Z' +reviewStatus: approved +youtubeVideoId: B_wZTyyZzkw +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:29.344Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-04-16 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-04-16.json + receiptDigest: 'sha256:7e509302788c38c3aaba491a4c4d20148508a4f8b9f34bfa5b27604ff02b15e8' +publishedAt: '2026-08-07T02:41:29.344Z' +reviewedContentDigest: 'sha256:d508417bf2195f8eb4e1070fe5b08381391183f09be32ac5329702eddb66ced5' +reviewReceiptDigest: 'sha256:7e509302788c38c3aaba491a4c4d20148508a4f8b9f34bfa5b27604ff02b15e8' +--- +In this office hours episode, Cameron frames the week’s changes around a single idea: agents should be reachable where people already work. The biggest announcement is that Telegram and Slack channels are now built directly into Letta Code, instead of relying on a separate layering approach. That shift is presented not as a cosmetic integration, but as a reliability and deployment change: messages route into the same execution path as the desktop app and CLI, so agents can respond consistently across surfaces. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The episode then broadens from channels to the infrastructure that makes always-on agents practical. Cameron walks through schedules and cron jobs, remote environments, and model updates, then spends the second half answering questions about subagents, persona behavior, memory, and local-vs-cloud tradeoffs. Across those topics, the through-line is that Letta is pushing toward agents that can persist, act, and be addressed continuously rather than only inside a chat window. + +## Selected chapters +- [00:00:00 Intro (and Timber the Head of Security)](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=0s) +- [00:01:04 Channels: Telegram and Slack built into Letta Code](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=64s) +- [00:03:00 How channels replace Lettabot](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=180s) +- [00:05:31 Channels via CLI deployment](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=331s) +- [00:07:31 Schedules and cron jobs](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=451s) +- [00:08:36 Remote environments explained](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=516s) +- [00:11:04 Opus 4.7 model news](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=664s) +- [00:12:30 Recall agent and self-forking conversations](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=750s) +- [00:13:30 Telegram pairing and permissions](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=900s) +- [00:24:14 Subagents available everywhere](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=1454s) +- [00:49:31 LoRA and fine-tuning vs in-context learning](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=2971s) +- [01:33:34 Local models vs cloud hosting](https://www.youtube.com/watch?v=B_wZTyyZzkw&t=5614s) + +## Channels as the core integration layer +The channels announcement is the episode’s anchor point. Cameron describes channels as the direct way to talk to an agent through Telegram or Slack, with the key change being that the integration now lives inside Letta Code rather than in a separate glue layer. That matters because it collapses the distance between a message arriving and the agent actually executing work. The result, as described in the episode, is higher reliability, correct queueing, and a workflow that feels closer to using the desktop app or CLI. + +The practical implication is that agents become addressable from ordinary messaging apps without giving up the structured runtime underneath. The episode emphasizes that this is not just for demos; it is meant to support personal agents and always-on deployments. Cameron also notes that channels can handle attachments, which expands them beyond text into media- and file-based workflows. + +## Remote environments and persistent reachability +Channels are paired with remote environments. The episode explains remote environments as the place where an agent gets “hands” on a computer, rather than only the “brain” exposed in a chat interface. In Letta Code, that means the agent can operate continuously on a deployed machine and receive messages routed to that environment. + +This is what makes the channels story operational rather than purely social. The episode points to one-click-style deployments on providers such as Railway, and also mentions DigitalOcean and Fly.io. The broader idea is that if agents are meant to be reachable on Telegram or Slack, they need a persistent place to run. Remote environments provide that base, and Letta Code desktop acts as one convenient front end for managing them. + +## Schedules, cron, and recurring work +The office hours also treat schedules as a first-class part of agent work. Cameron says schedules and cron jobs were previously handled by a sidecar approach, but are now built into Letta Code. That allows recurring heartbeats, reminders, and automated tasks to be attached to a remote environment rather than improvised around it. + +The important mechanism here is continuity. An agent that can be messaged on Telegram but cannot wake itself up or act on schedule is only partially useful. By tying cron-like triggers to the same environment that powers channels, the system can support periodic or stateful jobs alongside reactive conversation. + +## Subagents, recall, and structured delegation +A later section of the episode connects channels and schedules to a broader pattern: subagents. Cameron explains that the recall agent now forks from the primary conversation, and that agents can invoke themselves as subagents by cloning the existing conversation state. The point is not merely parallelism; it is delegation with preserved context. + +In the episode, recall is described as a powerful conversation search mechanism that can inspect past interactions and return a useful summary to the main agent. That capability fits the same architectural direction as channels: instead of treating the agent as a single chat thread, Letta is building a system of cooperating execution contexts with specialized roles. + +## Models, persona adherence, and deployment tradeoffs +The discussion of Opus 4.7 and later Q&A frames model choice as part of the same operational story. Cameron highlights improvements in software engineering, long-running tasks, vision, and file-system-based memory. He also discusses how thinking blocks can preserve persona behavior more reliably, suggesting that model capability is only part of the user experience; how the model is prompted and wrapped matters too. + +The local-vs-cloud discussion is more philosophical, but it still reinforces the same architecture. Cameron argues that the company’s focus is on widely available frontier models and on the systems that make them useful at scale, even while acknowledging why some users prefer local deployment. In this episode, the message is that the core product is not just model access. It is the combination of model, memory, scheduling, channels, and remote execution. + +## Q&A themes +The Q&A portion circles around a few recurring themes: how to make agents feel present across familiar tools, how to preserve behavior across long tasks, how to balance security with convenience, and how much of the agent stack should be centralized versus self-hosted. Questions about channels, subagents, and remote environments all point back to a single concern: making agents persistent without making them brittle. + +A second theme is abstraction quality. The episode repeatedly contrasts older wrappers or sidecars with the newer built-in design, arguing that the system works better when the routing, execution, and persistence layers are aligned. That applies to channels, schedules, and memory alike. + +## Architectural through-line +The episode’s architectural through-line is convergence. Letta is moving messaging, scheduling, memory retrieval, and remote execution into a single coordinated runtime. Channels let outside communication reach the agent cleanly. Remote environments give that communication a place to land. Cron jobs and recall agents let the system act on time and across context. Model improvements and persona handling improve what happens once the agent is active. + +Taken together, the episode presents Letta Code as an agent operating system rather than a chat interface: a stack where reachability, persistence, and delegation are all part of the same design. + +## Related public material +- https://www.youtube.com/watch?v=B_wZTyyZzkw +- https://docs.letta.com/ +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta diff --git a/knowledge/published/letta-office-hours-2026-04-23.md b/knowledge/published/letta-office-hours-2026-04-23.md new file mode 100644 index 0000000..5ca3039 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-04-23.md @@ -0,0 +1,120 @@ +--- +title: 'Letta Office Hours: Digital Coworkers with Slack' +slug: letta-office-hours-2026-04-23 +summary: >- + Letta office hours on Slack-native agents, remote environments, channel + hosting, and why skills beat MCP-style integrations. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - slack-integration + - digital-coworkers + - remote-environments + - channels + - skills + - mcp +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=NEkV0ESC_gA' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:cc6133d4024002bd9b9adc45a104db818fe15da391cc2668af3931304aac7e55' +updated: '2026-08-07T02:33:32.213Z' +reviewStatus: approved +youtubeVideoId: NEkV0ESC_gA +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:29.901Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-04-23 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-04-23.json + receiptDigest: 'sha256:77bc549857130af6809474d777702297d6ae5afcec19929186265093ff76cb8f' +publishedAt: '2026-08-07T02:41:29.901Z' +reviewedContentDigest: 'sha256:bedbe3d9cc9b3385219e9b7bc45a50c848f348580149dded12bcb02e4b47fa7b' +reviewReceiptDigest: 'sha256:77bc549857130af6809474d777702297d6ae5afcec19929186265093ff76cb8f' +--- +Letta’s April 23, 2026 office hours centered on a practical claim: if an agent can live inside the same communication surface as a team, it stops being a chat demo and starts behaving like a coworker. Cameron framed Slack as the first big step in that direction, because a first-party Slack integration lets a Letta agent receive messages, act on them, and respond in the same place where work already happens. The episode used an internal office-manager agent, Brad, to show how a stateful agent can be trained through repeated use: it can learn workflows, recover from mistakes, and improve at specific browser-based tasks over time. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +From there, the episode widened into an architecture tour. Cameron connected Slack, Discord, Telegram, remote environments, schedules, and skills into one model: Letta server holds the state, Letta Code provides the execution layer, and channels are the inbound/outbound routing layer. The result is a system for deploying “digital coworkers” that can be pinned to different environments, configured per channel, and taught by experience rather than by one-off prompt instructions. + +## Selected chapters + +- [0:00 Intro](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=0s) +- [0:35 Slack channels recap](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=35s) +- [1:40 Meet Brad, the office manager agent](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=100s) +- [7:29 Experiential AI: correcting Brad with a screenshot](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=449s) +- [13:00 Remote environments and Railway one-click deploy](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=780s) +- [13:44 Per-environment channel and schedule config](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=824s) +- [49:42 Subagents explainer](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=2982s) +- [50:35 Why the Learning SDK is an anti-pattern](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=3035s) +- [1:03:55 Skills: “tell it to make a skill”](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=3835s) +- [1:16:20 Rant: Letta is not a memory layer](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=4580s) +- [1:27:05 Brains in a jar vs robot suits analogy](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=5225s) +- [1:29:20 Multi-channel hosting](https://www.youtube.com/watch?v=NEkV0ESC_gA&t=5360s) + +## Digital coworkers are routed, not summoned + +The Slack segment is the episode’s core design argument. A channel is not just a notification pipe; it is the place where work is initiated, observed, and completed. Cameron described a flow where an agent can be bound to Slack, receive work in a thread, use tools, and report back in the same conversational context. That matters because it collapses the gap between “user asks for help” and “agent is part of the team.” + +Brad illustrates the pattern. He is presented as an office manager agent that handles snacks, lunch, tickets, and ordering tasks. The point is not that Brad is magic; it is that the agent can be corrected in context, asked to reflect on failures, and then practice the same task again. In the episode, the team uses screenshots and follow-up prompts to fix mistakes in ordering flows, showing a feedback loop that looks closer to training a coworker than to issuing a static command. + +## Channels make the same agent portable + +A recurring theme is that the same agent can be attached to multiple endpoints. Slack is the first major example, Discord is emerging, and Telegram already works. Cameron also walked through remote environments on Railway, showing that an agent’s execution environment and its channel bindings can be separated. A remote environment can host the state and runtime while Slack or Telegram messages route to it. + +That separation also extends to schedules. The episode described per-environment heartbeats and device-specific configuration, so the same agent can run different schedules on a home machine and a remote server. The architectural idea is simple: state lives in one place, execution happens wherever you point it, and channel bindings determine which conversation space reaches which runtime. + +## Skills over sprawling integrations + +A major Q&A thread pushed on the difference between skills and heavier integration layers. Cameron repeatedly argued that skills are the ergonomic path when an agent should learn a repeatable action. Instead of building a separate “learning SDK” or turning every capability into a bespoke external protocol, the agent should learn a skill and use it directly. That keeps the action close to the agent’s own execution model. + +This is also why the episode frames MCP skeptically. The argument was not that interoperability is useless, but that an MCP-style layer can add token overhead and complexity where a direct skill would be simpler and more native. The same logic appears in the discussion of subagents and browser-use workflows: Letta should compose capabilities in a way that preserves agent autonomy rather than forcing everything through an extra abstraction. + +## Memory is part of the agent, not the product category + +Another important distinction in the episode is that Letta is not positioned as a generic memory layer. Cameron contrasted that framing with systems that primarily promise retrieval or storage. In the Letta model, memory is useful because it helps a stateful agent perform work over time: it can remember process details, learn from corrections, and manage context across conversations. Memory is therefore inseparable from action. + +The “brains in a jar vs robot suits” analogy captures the same idea. Letta server stores the brains in a jar; Letta Code provides the robot suit that acts on the world; channels are the way you talk to the suit. This model explains why channels, code execution, and state management are treated as one stack rather than as isolated products. + +## Q&A themes + +- How a team should decide whether one agent serves several people or each person gets a separate persistent agent. +- Why corrections, practice runs, and durable skills can be more useful than repeatedly extending a system prompt. +- When a direct tool or skill is clearer than adding an interoperability layer such as MCP. +- How remote environments, schedules, and channel configuration divide responsibility for agent state and execution. +- Why a useful memory system must affect future action instead of merely returning retrieved text. + +## Architectural through-line + +The episode's through-line is that a digital coworker needs four things to line up: durable identity, a place to execute, a communication route, and a way to learn repeatable work. Slack supplies a shared social surface; remote environments and Letta Code supply execution; memory and skills preserve what the agent learns. None of those pieces alone creates the coworker experience. + +That composition also explains the episode's skepticism toward treating memory, channels, or MCP as complete product categories. They are supporting layers around an agent that acts over time. The design goal is to keep those layers separable enough to replace or reconfigure, while preserving one inspectable identity across them. + +## Related public material + +- https://www.youtube.com/watch?v=NEkV0ESC_gA +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk diff --git a/knowledge/published/letta-office-hours-2026-05-01.md b/knowledge/published/letta-office-hours-2026-05-01.md new file mode 100644 index 0000000..dd06a91 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-05-01.md @@ -0,0 +1,113 @@ +--- +title: >- + Letta Office Hours: Discord Channel, Custom Plugins, Letta City Sim, and a + Special Guest +slug: letta-office-hours-2026-05-01 +summary: >- + Office hours covers Discord channels, custom plugins, schedules, policy + boundaries, Letta City Sim, model updates, and a long Q&A on memory, context, + and agents. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - channels + - plugins + - schedules + - agent-memory + - context-management + - models + - community-projects + - infrastructure +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=gMo82eDX0jw' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:49f47983befa9af6ac2f9e0a7a2fee3771acd4358734bb70d61dd5275543cf0e' +updated: '2026-08-07T02:33:31.685Z' +reviewStatus: approved +youtubeVideoId: gMo82eDX0jw +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:30.448Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-05-01 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-05-01.json + receiptDigest: 'sha256:0e82a635ffc68238d8daa3df2564b0570a1fdf9616d7f9c53decda1db778b619' +publishedAt: '2026-08-07T02:41:30.448Z' +reviewedContentDigest: 'sha256:16100759cd5f6c3baaf1a2566d280ec0ccccaf486690867bdde392457e35b79e' +reviewReceiptDigest: 'sha256:0e82a635ffc68238d8daa3df2564b0570a1fdf9616d7f9c53decda1db778b619' +--- +Letta’s May 1, 2026 office hours centered on a familiar theme: agents become more useful when they can participate in the world around them instead of waiting inside a chat box. The episode opened with Discord channel support, a new plugin path for connecting agents to external event streams, and a schedule UI refresh. Those product updates were framed less as isolated features than as steps toward a broader harness design where an agent can receive events, act on them, and be managed from multiple surfaces. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The rest of the session moved between demos, policy clarification, community projects, and a lengthy Q&A. A recurring point was that better systems depend on better orchestration: schedules should be used responsibly, channels should be extensible, and memory should remain structured rather than manually patched. The special-guest segment and the audience questions then turned those themes into deeper discussion about infrastructure, model behavior, context rot, and how Letta’s architecture treats agency as something distributed across tools, memory, and event streams. + +## Selected chapters +- [0:00 Intro](https://www.youtube.com/watch?v=gMo82eDX0jw&t=0s) +- [0:28 Discord channel support is live](https://www.youtube.com/watch?v=gMo82eDX0jw&t=28s) +- [2:56 Custom channel plugins — write your own](https://www.youtube.com/watch?v=gMo82eDX0jw&t=176s) +- [5:30 Schedules UI redesign and cmd+shift+y shortcut](https://www.youtube.com/watch?v=gMo82eDX0jw&t=330s) +- [6:37 Automated use policy clarification](https://www.youtube.com/watch?v=gMo82eDX0jw&t=397s) +- [9:11 letta-city-sim — Vedant's agent town](https://www.youtube.com/watch?v=gMo82eDX0jw&t=551s) +- [11:35 Model updates: GPT 5.5, DeepSeek V4 (and skip GPT 5.5 Pro)](https://www.youtube.com/watch?v=gMo82eDX0jw&t=695s) +- [12:48 Special guest: Keon, member of technical staff](https://www.youtube.com/watch?v=gMo82eDX0jw&t=768s) +- [23:30 What infrastructure actually means here](https://www.youtube.com/watch?v=gMo82eDX0jw&t=1410s) +- [31:57 Better context, not less context (context rot)](https://www.youtube.com/watch?v=gMo82eDX0jw&t=3234s) +- [1:28:30 The OpenAI-compatible endpoint](https://www.youtube.com/watch?v=gMo82eDX0jw&t=5310s) +- [1:35:00 Gemini's emotional instability](https://www.youtube.com/watch?v=gMo82eDX0jw&t=5700s) + +## Channels as the agent’s event layer +The headline product change was Discord channel support, but the deeper idea is that a channel is a general event adapter. In the episode, Cameron described channels as the mechanism that connects an agent to an external stream: chat, notifications, messages, webhooks, or anything else that can produce events. The immediate Discord release was available through the CLI first, with desktop configuration coming later, but the architectural point was broader than one integration. + +That broadness matters because channels are meant to be user-extensible. The episode explains that developers can write custom channel plugins and drop them into the Letta folder, letting the harness load arbitrary adapters without waiting for a first-party release. The examples ranged widely — WhatsApp, Matrix, IRC, email, Bluesky, GitHub notifications, calendars, Stripe, filesystem watchers, and more — but the key mechanism is the same: separate input and output concerns so an agent can live inside a real event graph. + +## Schedules, automation, and resource discipline +The redesigned schedules UI and the new shortcut are presented as ergonomics, but the discussion quickly becomes operational. Letta wants schedules to be manageable in the app, yes, but also controllable by the agent itself. That is why the episode emphasizes a harness skill that lets the agent adjust its own schedules. The point is not just convenience; it is that scheduling belongs in the same system as the agent’s memory and tools. + +The policy clarification around automated use adds an important boundary. The episode distinguishes between interactive personal usage and heavily automated workloads, noting that frequent schedules can be costly and can create unsustainable load. The explanation around cache expiration, token usage, and model choice shows the real constraint: if a scheduled agent is treated like a lightweight reminder, the system behaves differently than if it is used as a persistent automation engine. The episode’s message is practical rather than punitive — use schedules thoughtfully, and route heavier automation to the intended infrastructure when possible. + +## Letta City Sim and community-built worlds +The Letta City Sim segment shifts from infrastructure to imagination. Vedant’s project is described as a shared world where agents can move around, inhabit locations, set intentions, and interact with public events. The recording presents it as a community-contributed playground rather than a finished product, with issues and pull requests invited as part of the design process. + +What makes the project interesting in architectural terms is that it turns the agent into a participant in a persistent environment. Instead of a single prompt-response loop, there is a navigable world with locations, adjacency, and event feeds. That structure mirrors the rest of the episode: agents become more capable when they can observe, remember, and act across time and place. The town sim is therefore not a side quest; it is a prototype for what a socially and spatially aware agent runtime can look like. + +## Special guest, infrastructure, and the Node experiment +The special-guest section and the later technical discussion make the infrastructure story concrete. The guest segment brings the conversation to implementation details: what the backend needs to support, how the system behaves under load, and why a separate experimental Node implementation exists. The episode treats infrastructure as the set of moving parts that make the visible features possible: event routing, server deployment, remote environments, and the interfaces that let agents operate across machines. + +That framing also explains the recurrent emphasis on deployment guides, remote environments, and self-hosted configuration. The architecture is designed so a user can run a harness locally, on a remote machine, or through a hosted environment, and the same abstractions should still apply. In other words, the product surface may be a chat app or a desktop UI, but the system underneath is an agent platform that can be installed into different operational contexts. + +## Q&A themes +The Q&A returns repeatedly to memory and context. One theme is that “less context” is not the real objective; better context is. Another is that memory should remain structured and agent-managed rather than edited manually as though it were a note-taking app. The episode argues that memory changes should flow through the agent’s own mechanisms so the system can preserve coherence instead of accumulating ad hoc edits. + +Another thread concerns model behavior. The discussion compares model families, notes differences in planning tendencies, and reflects on how some models overuse affordances like planning or produce odd reasoning traces. The point is not which model is “best” in the abstract, but that a harness needs model-specific behavior management, and that model selection affects cost, reliability, and the shape of the interaction. + +## Architectural through-line +Across channels, schedules, city simulation, and memory, the episode keeps returning to the same architectural claim: an agent is not just a chatbot, but a system that spans event streams, persistence, and action. Channels connect the outside world. Schedules give the agent time-based agency. Memory preserves continuity. Tools and model routing determine how the system behaves under different workloads. The office hours episode uses each feature announcement to reinforce that larger design. + +## Related public material +- https://www.youtube.com/watch?v=gMo82eDX0jw +- https://docs.letta.com/ +- https://github.com/letta-ai/letta-code +- https://github.com/Vedant020000/letta-city-sim +- https://discord.com/invite/letta diff --git a/knowledge/published/letta-office-hours-2026-05-08.md b/knowledge/published/letta-office-hours-2026-05-08.md new file mode 100644 index 0000000..34fe354 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-05-08.md @@ -0,0 +1,121 @@ +--- +title: >- + Letta Office Hours: Sandboxes for Letta Chat, Sensemaker, and an agent that + plays Pokemon +slug: letta-office-hours-2026-05-08 +summary: >- + New channel controls, local-only Letta Code, sandboxed agents in Letta Chat, + Sensemaker, and design guidance for building durable agents. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-code + - channels + - sandboxes + - local-mode + - sensemaker + - agent-design + - memory-systems + - models +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=KGdAPvJh96A' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:4d35e4ce37ad637612790fc4a3df74f3fba8854b78e02dd5456c48d467f66171' +updated: '2026-08-07T02:33:31.167Z' +reviewStatus: approved +youtubeVideoId: KGdAPvJh96A +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:31.015Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-05-08 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-05-08.json + receiptDigest: 'sha256:346b5d8e8f8b395e48b8174caf0ad64ab5a63a5f511c74f7971141c741e531b6' +publishedAt: '2026-08-07T02:41:31.015Z' +reviewedContentDigest: 'sha256:bea84efe0a8bc5df1c9e31c72b31ede21e1e48f798db7a67921396c5de48cdfb' +reviewReceiptDigest: 'sha256:346b5d8e8f8b395e48b8174caf0ad64ab5a63a5f511c74f7971141c741e531b6' +--- +This office hours episode is a snapshot of Letta’s shift toward a more agent-centric product surface. The presentation starts with channel management in the desktop app, then moves through a local-only mode for Letta Code, new channel types, and UI changes meant to make agents feel like first-class entities rather than hidden backend objects. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The second half broadens out into demos and design philosophy: Sensemaker as a public social agent, a custom channel that lets an agent play Pokémon, and a long Q&A about sandboxes, approvals, memory, and how to build agents that can be taught over time. Across the episode, the connective tissue is the same: move agent behavior closer to the user, while reducing infrastructure friction and clarifying what the platform itself should own. + +## Selected chapters +- [00:00](https://www.youtube.com/watch?v=KGdAPvJh96A&t=0s) Welcome +- [01:25](https://www.youtube.com/watch?v=KGdAPvJh96A&t=85s) Discord channels in the desktop app +- [03:54](https://www.youtube.com/watch?v=KGdAPvJh96A&t=234s) Local mode (no Postgres, no Docker) +- [08:02](https://www.youtube.com/watch?v=KGdAPvJh96A&t=482s) Channels: voice memos, Discord, WhatsApp +- [11:25](https://www.youtube.com/watch?v=KGdAPvJh96A&t=685s) Sensemaker: a public social agent and newsletter +- [13:39](https://www.youtube.com/watch?v=KGdAPvJh96A&t=819s) Letta plays Pokemon +- [15:42](https://www.youtube.com/watch?v=KGdAPvJh96A&t=942s) Ari Webb on sandboxing and auto mode +- [24:54](https://www.youtube.com/watch?v=KGdAPvJh96A&t=1494s) Q&A begins +- [50:13](https://www.youtube.com/watch?v=KGdAPvJh96A&t=3013s) Red teaming the Context Constitution +- [1:21:27](https://www.youtube.com/watch?v=KGdAPvJh96A&t=4887s) Code SDK vs core API vs app server +- [1:27:00](https://www.youtube.com/watch?v=KGdAPvJh96A&t=5220s) Memory blocks are going away +- [1:36:55](https://www.youtube.com/watch?v=KGdAPvJh96A&t=5815s) Managing Ezra, and agent design as teaching +- [1:42:30](https://www.youtube.com/watch?v=KGdAPvJh96A&t=6150s) Model recommendations + +## Channel controls move into the app +A major theme in the opening segment is operational simplicity. Discord channels can now be configured from the Letta Code app, with a channel-management UI that lets a user paste a bot token, choose where a channel runs, and shift control between local and remote deployments. The point is not just convenience: it makes channels feel like portable capabilities attached to an agent, rather than one-off integrations hidden behind deployment-specific scripts. + +The same logic extends to other planned channel types. Voice memos, Discord semantics, WhatsApp support, and “operator channels” are all discussed as ways to separate where an agent acts from where approvals and errors should be routed. That distinction matters because a productive agent often needs to publish outward on one surface while asking for human intervention on another. + +## Local mode lowers the activation energy +The episode presents local mode as an experimental path for running Letta Code without Postgres or Docker. Mechanically, it uses files on disk and aims to fold more of the core agent logic directly into the harness. The advertised benefits are low overhead, easier setup, and a more compact developer experience for people who want to run agents on their own machine. + +The important architectural signal is that this is not just a packaging change. It reflects an effort to standardize the code path between hosted and local experiences, so the harness becomes the place where most future product work lands. In that framing, “local” is not a second-class demo mode; it is a pressure test for how much of the stack can be simplified without losing the ability to deploy agents anywhere. + +## Sandboxes and auto mode +Ari Webb’s segment centers on sandboxes and auto mode, especially the idea that agents should be able to work inside a restricted environment with clearer boundaries. The discussion points toward a model where the agent can act, but the surrounding system is responsible for protecting the user, the workspace, and any higher-risk operations. + +That sand-boxed shape fits the broader product direction in the episode. The team is trying to make agents more legible and more controllable, not merely more autonomous. The promise is not “let the model do everything,” but “give the model enough room to act while keeping the control plane understandable.” + +## Public agents and visible behavior +Sensemaker serves as a concrete example of an agent with a public role. It reads across social feeds, news, and video, then turns that intake into threads and a newsletter. The emphasis is on traceability: the sources are published, the outputs are visible, and the agent’s behavior can be inspected as a public knowledge-building process. + +The Pokémon demo pushes that same idea into a playful channel experiment. If an agent can be wired to an arbitrary event stream, then even a game becomes a testbed for channel design, pacing, and observability. The demo is lighthearted, but it illustrates a serious point: channels are the abstraction that lets agents inhabit different environments without changing their core identity. + +## Memory, abstractions, and teaching agents +The Q&A spends a lot of time on memory blocks and MEMFS. The direction discussed in the episode is that memory blocks are expected to give way to a better abstraction, one that can preserve useful persistence while fitting a shared-memory model more naturally. Rather than treating memory as a static feature bolted onto agents, the discussion frames it as infrastructure that should become simpler and more composable. + +That same simplification appears in the advice about managing Ezra. The key idea is that agent design is a teaching problem: observe what the agent does, correct the unwanted behavior, and reinforce what aligns with the agent’s goal. In practice, that means smaller threads, clearer asks, and a manager who can interpret the agent’s behavior as something trainable rather than magical. + +## Q&A themes +The audience questions cluster around a few durable themes: red-teaming the Context Constitution, distinguishing the Code SDK from the core API and app server, choosing models for personal agents, and understanding what should live in the app versus the CLI. The answers repeatedly favor practical clarity over abstraction for its own sake. + +Another recurring thread is control. Whether the question is about approvals, human-in-the-loop workflows, or agent memory, the underlying concern is the same: how do you let an agent operate broadly while still making its actions legible, reversible, and appropriately bounded? + +## Architectural through-line +The episode’s architecture story is about collapsing distance. Channels move into the app, local mode removes setup friction, sandboxes constrain execution, and memory is pushed toward a more unified abstraction. At the same time, public-facing agents like Sensemaker demonstrate that the platform is also trying to make agent activity observable outside the product itself. + +Taken together, these changes point to a system where agents are not isolated toys or hidden services. They are managed entities with channels, memory, and environment boundaries, all designed so a person can teach, inspect, and route them more effectively. + +## Related public material +- https://www.youtube.com/watch?v=KGdAPvJh96A +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk +- https://github.com/letta-ai/hypervigilant diff --git a/knowledge/published/letta-office-hours-2026-05-14.md b/knowledge/published/letta-office-hours-2026-05-14.md new file mode 100644 index 0000000..6f4c960 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-05-14.md @@ -0,0 +1,123 @@ +--- +title: 'Letta Office Hours: Local Mode and the New Pro Plan' +slug: letta-office-hours-2026-05-14 +summary: >- + Office hours on a memory-forward Letta Code UI, local mode, slash commands, + /goal, and the shift from Max plans to Pro, BYOK, and credits. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-code + - memory-ui + - local-mode + - slash-commands + - model-routing + - pricing + - agent-services +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=F50DN3GlzB0' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:7dee0b11b81c0fe376ef488adc0a7c779f5e8f3599ac56152fa759f5a724ce64' +updated: '2026-08-07T02:33:30.644Z' +reviewStatus: approved +youtubeVideoId: F50DN3GlzB0 +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:31.584Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-05-14 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-05-14.json + receiptDigest: 'sha256:6c031769b850bd3137f1d9f661dab57314f7741b7b04a6f9dde11c262200d955' +publishedAt: '2026-08-07T02:41:31.584Z' +reviewedContentDigest: 'sha256:d342635f91b808a484e2c2d989de72849a1ea68d4a7201e6a4d8dff08c24c2ea' +reviewReceiptDigest: 'sha256:6c031769b850bd3137f1d9f661dab57314f7741b7b04a6f9dde11c262200d955' +--- +This office hours session focused on a single product idea: Letta works best when memory is visible, editable, and operational rather than hidden behind the agent. The presentation opened with the new Letta Code interface, which makes memory a first-class surface through an expanded memory view, an embedded markdown editor, commit history, and profile cards for agents. That framing matters because the episode treats memory not as a passive log, but as the core interface for steering an agent over time. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The second major thread was deployment and access. The team discussed local mode, which lets Letta Code run without a separate Docker server or a connection to Letta Cloud, and then moved into slash-command workflows such as direct skill invocation and the new /goal command for long-running objectives. From there, the conversation shifted into plan changes and model strategy: Max and Max Lite were being sunset, Pro would center Letta-tier models, and frontier or external models would move to BYOK or credits. + +## Selected chapters +- [00:00 Welcome](https://www.youtube.com/watch?v=F50DN3GlzB0&t=0s) +- [00:54 Memory-forward UI in Letta Code](https://www.youtube.com/watch?v=F50DN3GlzB0&t=54s) +- [01:16 Expanded memory view and markdown editor](https://www.youtube.com/watch?v=F50DN3GlzB0&t=76s) +- [03:27 Memory graph and commit history](https://www.youtube.com/watch?v=F50DN3GlzB0&t=207s) +- [05:08 Local mode without Cloud or Docker](https://www.youtube.com/watch?v=F50DN3GlzB0&t=308s) +- [07:03 Invoking skills directly with slash commands](https://www.youtube.com/watch?v=F50DN3GlzB0&t=423s) +- [07:22 /goal for long-running objectives](https://www.youtube.com/watch?v=F50DN3GlzB0&t=442s) +- [08:25 Max and Max Lite plan changes](https://www.youtube.com/watch?v=F50DN3GlzB0&t=505s) +- [11:08 Recommended model paths: Pro, BYOK, credits, Codex](https://www.youtube.com/watch?v=F50DN3GlzB0&t=668s) +- [38:24 Letta Auto, model routing, and sensitive data](https://www.youtube.com/watch?v=F50DN3GlzB0&t=2304s) +- [57:34 Agent services: Ezra, Overlord, and Sensemaker](https://www.youtube.com/watch?v=F50DN3GlzB0&t=3454s) +- [01:16:30 Closing notes](https://www.youtube.com/watch?v=F50DN3GlzB0&t=4590s) + +## Memory as an interface +The episode’s opening sections describe a deliberate UI shift: memory is no longer a background implementation detail, but a visible workspace. The expanded memory panel lets a user inspect and edit notes directly, while the markdown editor gives the memory surface the affordances of a knowledge base rather than a plain settings pane. In practice, that means a user can treat agent memory more like a living document set than a static prompt blob. + +A key mechanism here is recompilation. The session emphasized that manually editing system memory should be done carefully because the system folder is part of the agent’s runtime context. Changing those files can invalidate cache and make the agent unaware of the update unless recompilation happens. The point is not simply “edit text,” but preserve coherence between stored memory and the agent’s active runtime. + +## Local mode and lightweight setup +Local mode was presented as a way to get started faster. Instead of requiring a cloud login or a separately managed Docker server, Letta Code can run with a local backend and store agent memory on disk. The transcript frames this as a lower-friction path for users who want immediate experimentation without production-grade infrastructure overhead. + +This also changes the onboarding story. Users can still connect model providers with familiar slash-connect flows, but the local setup reduces the number of moving parts. The episode makes the tradeoff explicit: local mode is about speed and convenience, not about replacing a fully managed deployment. That distinction keeps the architecture understandable—local execution for fast iteration, managed services for more structured use. + +## Commands for long-running work +The new slash-command flow is more than a syntax tweak. Direct skill invocation turns skills into explicit actions the user can ask for from the command line-style interface, rather than something the agent only decides to use internally. That makes skills a visible part of the workflow. + +The /goal command extends the same idea to long-horizon tasks. Instead of repeatedly prompting an agent for the next step, the user can set an objective and a token budget, then let the agent work over a long interval. The episode repeatedly tied this to automation: the stronger the memory and the clearer the goal, the more useful long-running work becomes. + +## Plan changes and model strategy +The pricing discussion was one of the central operational topics. The episode announced that Max and Max Lite were being sunset, with Letta Pro focused on Letta-tier models such as auto, automemory, and autofast. Frontier and external model usage would no longer be covered by usage-based plans in the same way. + +The rationale was economic and architectural. The discussion argued that maintaining generous quota plans for expensive frontier models had become unsustainable, especially as providers changed policies and as usage costs became harder to absorb. The recommended alternatives were either BYOK for specific providers, or using direct provider subscriptions such as Codex-style plans when a user needs a particular frontier family. + +## Model routing and Letta Auto +The episode also clarified the role of Letta Auto. Rather than a user-managed checklist of models, Auto was described as a router that chooses among available options. That framing matters because it explains why the system can be opinionated without being rigid: the user supplies constraints and preferences, while the router handles selection. + +That section connects directly to the data-sensitivity discussion. If a user has especially sensitive information or a particular model requirement, the recommended path is to choose the provider explicitly rather than rely on a routed default. The architecture is meant to give the user control without forcing them to micromanage every inference request. + +## Agent services as a design pattern +Later Q&A moved from product setup to a higher-level concept: agent services. Ezra, Overlord, and Sensemaker were discussed as examples of publicly deployed or internal agents specialized for a particular job. The important idea is that an agent service is not just “an agent with a name,” but an operational role with its own memory design, safety boundaries, and feedback loop. + +The episode suggests that these services become good through repeated use, clear task boundaries, and close interaction with users. That is why “just talk to the robot” is not a throwaway line here; it is the design method. You improve an agent service by giving it a specific responsibility, observing failures, and shaping memory and instructions until the service becomes reliable for that niche. + +## Q&A themes +- Choosing between Pro, BYOK, credits, and direct provider subscriptions +- Why frontier model usage was being removed from quota-style plans +- How local mode changes onboarding and infrastructure requirements +- Whether Letta Auto should be treated as a router or a manual model list +- How to think about agent services like Ezra and Overlord +- Why memory updates should be aligned with the agent’s own runtime state + +## Architectural through-line +The common thread across the episode is composability around memory, execution, and model selection. The UI work makes memory inspectable; local mode makes the runtime lighter; slash commands make intent explicit; /goal makes long tasks manageable; and routing or BYOK make model choice more deliberate. Each piece reduces hidden behavior and replaces it with an interface the user can reason about. + +In other words, the episode argues for a stack where the agent is legible. Memory should be visible, goals should be explicit, models should be selectable, and deployment should be flexible enough to match user needs. That is the architectural shape underneath the product announcements. + +## Related public material +- https://www.youtube.com/watch?v=F50DN3GlzB0 +- https://github.com/letta-ai/letta-code +- https://letta.com/ +- https://docs.letta.com/ diff --git a/knowledge/published/letta-office-hours-2026-05-21.md b/knowledge/published/letta-office-hours-2026-05-21.md new file mode 100644 index 0000000..defb426 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-05-21.md @@ -0,0 +1,133 @@ +--- +title: >- + Letta Office Hours: New Desktop UI, Local Mode, Agent Services, and Skills vs + MCP +slug: letta-office-hours-2026-05-21 +summary: >- + Office hours on the redesigned Letta Code desktop app, local mode, memory UX, + agent services, and the product and protocol tradeoffs behind skills, MCP, and + channels. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-code + - local-mode + - memfs + - agent-services + - skills + - mcp + - telegram + - desktop-ux +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=4y6djzSSlxo' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:f9fc5a5cfdb24d0672289d9fa8e39e65dee0ab3090bd409fe4e0ea3db9883a1d' +updated: '2026-08-07T02:33:30.131Z' +reviewStatus: approved +youtubeVideoId: 4y6djzSSlxo +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:32.137Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-05-21 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-05-21.json + receiptDigest: 'sha256:7143833b3e2a29baac3513c9a2f1582ccd856ee5708cdca7bb28004a0ef1aa74' +publishedAt: '2026-08-07T02:41:32.137Z' +reviewedContentDigest: 'sha256:74eb952d0bbf70a754eb5a787bfd4361391812ed83b1f3feca68ee18820ab4b6' +reviewReceiptDigest: 'sha256:7143833b3e2a29baac3513c9a2f1582ccd856ee5708cdca7bb28004a0ef1aa74' +--- +Letta Office Hours for May 21, 2026 centered on a major Letta Code desktop release and the product ideas behind it. Cameron framed the update as a push toward a more agent-forward experience: the app now foregrounds agents rather than treating them as disposable tasks, and the memory viewer, agent profiles, and settings are organized around that shift. The episode also introduced a broader engineering theme: making agent memory visible, collaborative, and easier to reason about without making the system feel like a pile of hidden machinery. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +A second thread ran through the whole session: Letta wants local use to feel first-class. Cameron described local mode as a way to run Letta Code without Docker, without a database, and without signing in, while still keeping memory and channels on device. From there the conversation expanded into experimental CLI features, reliability work, support automation, and a long Q&A with Jin about performance, agent services, protocols, and how the company thinks about building useful, durable agents. + +## Selected chapters + +- [00:00:30](https://www.youtube.com/watch?v=4y6djzSSlxo&t=30s) New Letta Code desktop release +- [00:00:51](https://www.youtube.com/watch?v=4y6djzSSlxo&t=51s) Redesigned UI and new memory viewer +- [00:02:23](https://www.youtube.com/watch?v=4y6djzSSlxo&t=143s) Memory viewer overhaul +- [00:03:01](https://www.youtube.com/watch?v=4y6djzSSlxo&t=181s) Skills in MemFS and agent profiles +- [00:03:52](https://www.youtube.com/watch?v=4y6djzSSlxo&t=232s) Local mode +- [00:05:48](https://www.youtube.com/watch?v=4y6djzSSlxo&t=348s) Running `letta --backend local` +- [00:07:03](https://www.youtube.com/watch?v=4y6djzSSlxo&t=423s) Slash experiments +- [00:08:51](https://www.youtube.com/watch?v=4y6djzSSlxo&t=531s) TUI cron execution +- [00:12:42](https://www.youtube.com/watch?v=4y6djzSSlxo&t=762s) Jin joins +- [00:14:06](https://www.youtube.com/watch?v=4y6djzSSlxo&t=846s) Engineering reliability and performance work +- [00:35:14](https://www.youtube.com/watch?v=4y6djzSSlxo&t=2114s) Letta API vs Letta Code SDK +- [01:40:46](https://www.youtube.com/watch?v=4y6djzSSlxo&t=6046s) MCP vs skills + +## Desktop redesign and memory-centered UX + +The new desktop release was presented as more than a visual refresh. Cameron emphasized that the app now makes the agent relationship more immediate: the left side offers a quick selector for multiple agents, and each agent carries its own memory, schedules, channels, and settings. That design choice matters because the product’s core promise is persistence. A Letta agent is not supposed to be a throwaway worker; it becomes more useful as you keep working with it. + +The memory viewer got a matching overhaul. Instead of a flat list, MemFS now groups items into folders, and the UI surfaces links between memory objects so the structure of an agent’s state becomes easier to inspect. The episode also noted that memory changes are visible in a right-hand panel and that the app can distinguish between primary agent changes and reflection-related modifications. The point is not just to store memory, but to make memory legible. + +## Local mode as the default on-ramp + +Local mode was the clearest infrastructural shift discussed in the episode. Cameron described a rewrite that moves much of the old Docker-container behavior into the Letta Code harness itself. That means users can run channels, run a Letta Code server, or work entirely locally with a key and no cloud login. In the framing of the episode, local mode removes the main frictions that kept people from trying Letta at all. + +Mechanically, the promise is that everything stays on device: memory, execution, and agent state. The episode highlighted support for local providers such as Ollama and LM Studio, plus a simple launch path via `letta --backend local`. The broader architectural point is that local execution is not a lesser mode; it is a proof that the product can deliver the same agent experience without depending on cloud-hosted infrastructure. + +## Experiments, recents, and operational polish + +The office hours also covered a series of smaller interface and CLI improvements that round out the product. There is a reload command for the TUI, a terminal title command, recent-model switching, shell-output expansion, and an experiments menu for enabling only explicitly experimental features. Those features were discussed as practical quality-of-life upgrades, not as headline launches. + +A particularly interesting detail was cron execution in the TUI: scheduled tasks can now be picked up even if a dedicated server is not running. That fits the larger theme of reducing dependency on surrounding infrastructure. The same logic appears in the recent-conversations and model-switching work: the app should help users move quickly between states instead of forcing them to reconstruct context manually. + +## Support workflows and agent services + +Later in the episode, the conversation shifted from product UX to operational design. Cameron described using Ezra to help triage issues, create tickets, and reduce the manual bottleneck between user reports and engineering. That discussion became a bridge into a broader idea: agent services should be purpose-built, constrained, and observable. They are not magic helpers; they are systems that need the right permissions, the right feedback loops, and the right limits. + +Jin’s segment reinforced that view from the engineering side. He described ongoing reliability and performance work for the Letta Code harness and cloud path, with the goal of making long tool-call turns finish faster and feel closer to the responsiveness users expect from modern coding agents. The result is an architecture that tries to keep the agent experience smooth even as the underlying system grows more sophisticated. + +## Protocols, skills, and portable context + +One of the episode’s central strategic questions was how skills differ from MCP and other integration layers. The discussion treated skills as a way to package capability alongside agent context, while MCP and related protocols address a different layer of interoperability. The useful distinction is that skills live close to the agent’s working environment, where they can be versioned, moved, and reused as part of the agent’s own portable state. + +That idea connects to MemFS and context repositories. Rather than treating memory as a hidden implementation detail, the episode framed it as a structured, inspectable substrate that can support agent behavior over time. Portable skills, context repositories, and visible memory all push in the same direction: make the agent’s working world explicit enough that it can be understood, transferred, and improved. + +## Q&A themes + +- Local mode as a way to remove friction for self-hosting and first-time use +- The relationship between Letta Code, the API, and the SDK +- Reliability, speed, and performance work in the cloud harness +- How to design agent services that resist misuse without becoming unusable +- Using skills versus using MCP for reusable capabilities +- Why Telegram was discussed as a strong messaging surface for agents +- Why SMS and phone-number workflows were treated as unattractive or overly regulated + +## Architectural through-line + +Across the whole episode, the through-line is that an agent platform becomes valuable when it makes persistent state visible, portable, and easy to inhabit. The redesigned desktop app, MemFS, local mode, experiments, and the discussion of skills all point toward the same architecture: agents should have durable memory, but that memory should feel navigable rather than opaque; agents should be runnable locally, but that should still connect to a richer product story; and integrations should be chosen for how well they support long-lived agent workflows rather than for novelty alone. + +In that sense, the episode was less about a single feature launch than about a coherent product philosophy. Letta is trying to make agents feel like systems you live with, not tools you discard, and to make the surrounding software reflect that commitment. + +## Related public material + +- https://www.youtube.com/watch?v=4y6djzSSlxo +- https://github.com/letta-ai/letta-code +- https://letta.com/ +- https://docs.letta.com/ +- https://github.com/letta-ai/letta-agent-sdk diff --git a/knowledge/published/letta-office-hours-2026-06-19.md b/knowledge/published/letta-office-hours-2026-06-19.md new file mode 100644 index 0000000..40395e1 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-06-19.md @@ -0,0 +1,117 @@ +--- +title: 'Letta Office Hours: Mods, MemFS, and Teaching Agents New Tricks' +slug: letta-office-hours-2026-06-19 +summary: >- + Office hours on mods, local mode, channels, schedules, memory architecture, + and how Letta teaches agents new capabilities over time. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - mods + - memfs + - local-mode + - schedules + - channels + - memory-architecture + - agent-learning + - harness-extensibility +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=tB1qz4QDRo4' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:66b5244f25402e312ef227669c216e11c85d5435dd4ae95e203d3d8c9a8ee6e5' +updated: '2026-08-07T02:39:43.234Z' +reviewStatus: approved +youtubeVideoId: tB1qz4QDRo4 +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:32.678Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-06-19 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-06-19.json + receiptDigest: 'sha256:e59abf7647841ffaab155c32390d4a25de5aae99be755c933739991d76c466a4' +publishedAt: '2026-08-07T02:41:32.678Z' +reviewedContentDigest: 'sha256:74fd5ef2e38c9d1a37b49944b034db17b0a7f023ea8438b594ca97421258cb2f' +reviewReceiptDigest: 'sha256:e59abf7647841ffaab155c32390d4a25de5aae99be755c933739991d76c466a4' +--- +In this office hours episode, Cameron returns from a few weeks away and uses the catch-up segment to frame a broad product update: Letta is pushing on a more extensible agent harness, more local and privacy-preserving operation, and a clearer model for how agents accumulate durable capabilities over time. The conversation moves from practical app work—Windows fixes, Slack controls, Signal progress, and schedules that can start fresh conversations—to a deeper design discussion about what it means for an agent platform to be modifiable at runtime instead of fixed at launch. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The centerpiece is a demo of Letta Code mods, presented as a way to patch the harness itself with new tools, slash commands, event hooks, permissions, providers, and UI behavior. That idea becomes the bridge to later questions about memory, learning, and deployment: if agents can be taught new behaviors without retraining, then the harness needs to make those behaviors discoverable, inspectable, and reusable across sessions and environments. + +## Selected chapters +- [00:00:00](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=0s) Welcome and release recap +- [00:02:03](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=123s) Product-update introduction +- [00:03:40](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=220s) Letta Code app and Windows build fixes +- [00:06:10](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=370s) Slack channel reaction and listen-mode controls +- [00:09:40](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=580s) Signal channel progress +- [00:11:42](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=702s) Schedules and new conversations per cron fire +- [00:20:05](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=1205s) Building plan mode as a mod +- [00:27:30](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=1650s) Mods, MCP, and harness extensibility +- [00:55:00](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=3300s) Memory types: experiential, core, procedural, structural +- [01:00:00](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=3600s) MemFS, memory architecture, and why mods are harness mods +- [01:15:00](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=4500s) Context Constitution and prompt/tool-description changes +- [01:26:00](https://www.youtube.com/watch?v=tB1qz4QDRo4&t=5160s) Parametric vs nonparametric continual learning + +## Mods as runtime harness changes +The episode’s most concrete technical idea is that mods are not just another plugin layer; they are a way to alter the Letta Code harness while the system is running. Cameron describes them as a flexible mechanism for adding tools, slash commands, event handlers, permission events, and other behaviors without hard-coding those paths into the core app. That makes mods more than convenience features: they become the interface for evolving the agent runtime itself. + +Caren’s demo reinforces that point by showing how a familiar workflow—plan mode—can be recreated as a mod. The important detail is not the specific plan-mode behavior, but the fact that it can be expressed as a reusable harness extension. In that framing, a mod is closer to a runtime patch than a static configuration file. It lets the platform change how agents think, act, and present themselves without requiring a full new build. + +## Channels, schedules, and local operation +Before the deep dive into mods, Cameron surveys several product changes that all point toward more controlled agent operation. Slack gains reaction controls and listen mode so agents can observe without interrupting, while Signal integration moves forward for users who want a more privacy-oriented channel. Telegram rich messaging also gets upgraded formatting, showing that the same agent can behave differently depending on the transport. + +Schedules get a notable ergonomic change: instead of always resuming an old thread, a cron-triggered run can start a new conversation. That matters because it reduces context pollution for repeated tasks and makes scheduled work easier to inspect later. In the same spirit, local mode lets agents run on a user’s own machine rather than through cloud services, giving a privacy-first deployment option even if it narrows the agent’s persistence to the local device. + +## Memory as architecture, not just storage +A long stretch of the Q&A returns to memory, and the conversation treats memory as a layered system rather than a single blob of notes. Cameron distinguishes experiential, core, procedural, and structural memory, then connects those layers to MemFS and the broader harness design. The point is that “memory” in Letta is not only a database concern; it is a product of what the harness exposes, what it preserves, and what it lets the agent revise. + +That connects directly to the mods discussion. If mods are harness-level changes, then they become part of the memory architecture too: they alter the tools and behaviors that shape what the agent can remember, retrieve, and do. The episode repeatedly returns to the idea that long-lived agents are best understood as systems that can be edited over time, not simply re-prompted. + +## Teaching agents new capabilities +Another major thread is how agents acquire new skills without weight updates. Cameron argues for token-space, or nonparametric, learning: the agent learns by changing what is in context, by using memory, skills, and harness behavior, rather than by rewriting model weights. He contrasts that with parametric continual learning, which can be useful for durable facts but is harder to control and less flexible for day-to-day adaptation. + +This is where skills become “interactive documentation.” An agent can be asked about a skill, inspect it, and use it as a live reference while working. The platform’s job is therefore not only to execute tasks, but to make its own capabilities discoverable and teachable. Mods, skills, and memory blocks all support that same idea: an agent should be able to grow through use, with the runtime preserving the structure that makes that growth legible. + +## Deployment, orchestration, and the new shape of agent systems +The Q&A also touches deployment platforms and orchestration-heavy agent products. Cameron suggests that some of these systems solve a real class of problems while others are still searching for one, and he argues that Letta’s remote API helps bridge the gap between older API-driven deployments and newer client-side agent workflows. The through-line is still the same: if agents are to be useful over time, the platform needs a stable way to reach them, inspect them, and change them. + +That makes the episode feel less like a product tour than a design statement. Letta’s target is a long-lived agent that can be extended at runtime, operated locally or in the cloud, routed through multiple channels, and taught new behaviors without losing continuity. Mods are the clearest expression of that philosophy, but the whole episode keeps returning to the same premise: the runtime is the learning surface. + +## Q&A themes +- What mods are and why they live at the harness layer +- How agents can learn through context, skills, and memory instead of retraining +- The tradeoffs between local mode, cloud deployment, and persistent agents +- Why channels and schedules need configurable behavior +- How Letta thinks about long-lived agent systems and capability growth + +## Architectural through-line +The episode’s architecture is a loop: the harness defines what the agent can do; mods extend the harness; skills and memory make those extensions discoverable; channels and schedules determine where and when the agent acts; and the remote API makes the whole system addressable across devices and deployments. Rather than treating agent behavior as fixed by a single prompt or model checkpoint, Letta presents it as a layered runtime that can be revised in place. + +## Related public material +- https://www.youtube.com/watch?v=tB1qz4QDRo4 +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk diff --git a/knowledge/published/letta-office-hours-2026-06-29.md b/knowledge/published/letta-office-hours-2026-06-29.md new file mode 100644 index 0000000..cd13a5f --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-06-29.md @@ -0,0 +1,115 @@ +--- +title: 'Letta Office Hours: Mods, Signal Support, GLM-5.2, and Slack Agents' +slug: letta-office-hours-2026-06-29 +summary: >- + Office hours on mods, Signal channels, model routing, secret handling, and why + Slack-style channels can make agents feel more like coworkers. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - mods + - signal + - model-routing + - secrets + - slack-agents + - local-agents + - constellation +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=earD8IKGDwk' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:29eabd0479a6bf8cf429d64ece99933d048727c57312057dbf3ea10c03304b31' +updated: '2026-08-07T02:33:29.090Z' +reviewStatus: approved +youtubeVideoId: earD8IKGDwk +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:33.235Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-06-29 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-06-29.json + receiptDigest: 'sha256:6a3cb5ea0370c5b8f7d5e8ac8c1a6e3e854853b2daff03712951d38890edcf8b' +publishedAt: '2026-08-07T02:41:33.235Z' +reviewedContentDigest: 'sha256:a86205b172bf8a55fb0404ff61ddd759db87d200158fa24897a2084209f78bdb' +reviewReceiptDigest: 'sha256:6a3cb5ea0370c5b8f7d5e8ac8c1a6e3e854853b2daff03712951d38890edcf8b' +--- +Letta’s June 29 office hours were a tour through the product surface area that sits around the agent core: mods, channels, model choice, secrets, and how different deployment styles change the day-to-day experience of using an agent. The through-line was that many things users ask for as “features” are really harness behavior: custom tools, persistence, redaction, routing, and channel semantics. The episode framed mods as the main way to reshape that harness without forking the whole stack. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The other major theme was communication. Cameron contrasted direct, chat-like channels with Slack-style, asynchronous agent collaboration, and argued that different interfaces should optimize for different kinds of work. Some use cases want a private, low-friction one-on-one agent; others want a multiplayer workspace where the agent can keep working, absorb interruptions, and reply when it has something meaningful to say. That distinction echoed across the discussion of local mode, Constellation, and the Agent SDK. + +## Selected chapters +- [00:00](https://www.youtube.com/watch?v=earD8IKGDwk&t=0s) Intro and office hours format +- [01:05](https://www.youtube.com/watch?v=earD8IKGDwk&t=65s) Mods registry and what mods can do +- [04:10](https://www.youtube.com/watch?v=earD8IKGDwk&t=250s) One-week mod challenge +- [06:59](https://www.youtube.com/watch?v=earD8IKGDwk&t=419s) Signal support for Letta Code channels +- [10:07](https://www.youtube.com/watch?v=earD8IKGDwk&t=607s) Dedicated GLM-5.2 endpoint +- [13:24](https://www.youtube.com/watch?v=earD8IKGDwk&t=804s) Worktree improvements +- [14:29](https://www.youtube.com/watch?v=earD8IKGDwk&t=869s) Local secret manager support +- [32:21](https://www.youtube.com/watch?v=earD8IKGDwk&t=1941s) Skills vs. mods +- [54:31](https://www.youtube.com/watch?v=earD8IKGDwk&t=3271s) Desktop onboarding, local agents, and Constellation +- [1:23:51](https://www.youtube.com/watch?v=earD8IKGDwk&t=5031s) Claude Tag vs. Letta Slack channels +- [1:54:00](https://www.youtube.com/watch?v=earD8IKGDwk&t=6840s) Why channel relay mode matters +- [2:05:30](https://www.youtube.com/watch?v=earD8IKGDwk&t=7530s) Closing thoughts and mod challenge reminder + +## Mods as harness extensions +Mods were presented as a way to customize the agent harness itself rather than just prompt the model differently. In the demo list, they ranged from adding tools like web search or image understanding to changing the status line, adding diagnostic modes, and enabling semantic search over MemFS. The practical point was that if a behavior belongs in the environment—tooling, reminders, visibility, or redaction—it may be better expressed as a mod. + +That is why the one-week mod challenge mattered. The challenge was less about producing a polished artifact and more about discovering useful harness patterns. The registry gives those patterns a place to live, and the episode repeatedly encouraged people to turn repeated requests into reusable mods. + +## Channels as product surface +Signal support was one of the clearest examples of channel choice shaping the agent experience. Cameron described Signal as the privacy-oriented option, with Telegram and Discord offering richer interfaces but different trust characteristics. The important architectural point is that a channel is not just a transport: it defines how messages arrive, how interruptions are handled, and who else can observe the conversation. + +That same idea reappeared in the discussion of Slack. Compared with older relay-style behavior, Slack channels let an agent accumulate information, work asynchronously, and answer when the timing makes sense. This makes them feel more like shared workspaces than simple chat pipes. + +## Model routing and specialization +The episode also highlighted model routing as a way to reduce friction. A dedicated GLM-5.2 endpoint was introduced for users who wanted a predictable model rather than auto-switching behavior. That mattered especially for people who had a clear preference for a single model or wanted to combine a text model with an image-understanding mod. + +Kimi K2.7 and multiple Codex plans were discussed in the same spirit: if different models or credentials serve different jobs, the platform should make those distinctions easy to express. The architecture aims to let users choose the right tool without collapsing everything into one generic route. + +## Secrets, privacy, and local mode +A recurring concern in the Q&A was how to keep secrets out of the model’s reach. The episode described redaction as a better default than project-level gymnastics: secrets should be available to the harness, but not exposed to the agent text stream. This was framed as especially important for API keys and other sensitive credentials. + +Local mode pushed that idea further. If inference stays local, the episode argued, the privacy boundary becomes much tighter because fewer third parties can observe the data flow. But the tradeoff is operational complexity, which is why the product discussion emphasized making setup easier through skills, docs, and channel-specific support. + +## Desktop, Constellation, and local agents +Later sections compared local agents with Constellation-backed agents. The core distinction was not ideology but workflow: local agents give you control and privacy, while Constellation emphasizes coordination and shared access. The episode suggested that many users actually want organizational primitives like folders more than project isolation, and that the product should evolve toward that shape. + +The Agent SDK and app server came up as part of that broader story: the platform needs a stable way to run agents across environments while preserving the same basic mental model. Whether an agent lives on a laptop, in a workspace, or behind a Slack channel, the user should still be able to reason about tools, memory, and response timing. + +## Q&A themes +The Q&A clustered around five themes: how mods persist, how skills differ from mods, how to think about context-window sizing, how to use channels for collaboration, and how to avoid exposing secrets. Another repeated theme was UX friction—what should be visible to users, what should be abstracted away, and what kinds of feedback make long-running agent work feel trustworthy. + +## Architectural through-line +The episode’s central argument was that Letta is not just an agent model wrapper. It is a system for shaping the environment around an agent: tools, channel semantics, memory, redaction, routing, and collaboration patterns. Mods customize the harness; channels determine how work flows; secrets and local mode define privacy boundaries; and model choice determines specialization. + +Taken together, those layers explain why the product discussion kept returning to “what belongs in the harness?” The answer, in this episode, was: quite a lot. + +## Related public material +- https://www.youtube.com/watch?v=earD8IKGDwk +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk +- https://github.com/letta-ai/hypervigilant diff --git a/knowledge/published/letta-office-hours-2026-07-02.md b/knowledge/published/letta-office-hours-2026-07-02.md new file mode 100644 index 0000000..c8d5ac0 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-07-02.md @@ -0,0 +1,111 @@ +--- +title: >- + Letta Office Hours: Letta Agent, Mod Challenge Demos, Slack Agents, and + GLM-5.2 +slug: letta-office-hours-2026-07-02 +summary: >- + Cameron frames Letta Agent as the broader packaged experience, then walks + through mod challenge demos, Slack coworker workflows, model choices, and + subagent tooling. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-agent + - mods + - slack-agents + - subagents + - model-selection + - skill-learning +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=qDT4X2KO858' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:95922b562b2c154eb673fbfee83ad3400669dd9e9344d28d24a322301f4b51c9' +updated: '2026-08-07T02:33:28.565Z' +reviewStatus: approved +youtubeVideoId: qDT4X2KO858 +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:33.780Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-07-02 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-07-02.json + receiptDigest: 'sha256:e8d31234d9fb335955ccc620e8e0e4fdd71faeef9a8837fcb5d91afdf1989bbf' +publishedAt: '2026-08-07T02:41:33.780Z' +reviewedContentDigest: 'sha256:154df886bbce4f53be9bd07220d661d8850ddf3fa8ddc260c536f443eea1c3b7' +reviewReceiptDigest: 'sha256:e8d31234d9fb335955ccc620e8e0e4fdd71faeef9a8837fcb5d91afdf1989bbf' +--- +Letta’s office hours for July 2, 2026 centered on a naming shift with architectural consequences. Cameron explained that the broader packaged experience delivered by Letta Desktop should now be called **Letta Agent**, while the underlying harness remains **Letta Code**. That distinction was presented as a way to better reflect how people actually use the system: not only for software development, but also for operations, knowledge work, research, companionship, and creative play. The talk quickly widened into a product-and-community tour of the week’s most visible experiments. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +From there, the episode became a survey of how the platform was evolving around that broader agent model. Cameron highlighted the end of the Mod Challenge, the arrival of new model options, a preview of subagent and reflection UI in the app, and ongoing work to make Slack a serious surface for human-agent collaboration. The through-line was consistent: Letta is moving from a code-centric harness toward an orchestration layer for many kinds of agents, with mods, skills, and channels acting as the mechanisms that shape behavior. + +## Selected chapters + +- [00:00](https://www.youtube.com/watch?v=qDT4X2KO858&t=0s) Intro and office hours format +- [00:22](https://www.youtube.com/watch?v=qDT4X2KO858&t=22s) Letta Agent naming and Letta Code distinction +- [01:43](https://www.youtube.com/watch?v=qDT4X2KO858&t=103s) Four major Letta Agent use cases +- [02:53](https://www.youtube.com/watch?v=qDT4X2KO858&t=173s) Mod Challenge wrap-up +- [03:41](https://www.youtube.com/watch?v=qDT4X2KO858&t=221s) Community mod highlights +- [07:34](https://www.youtube.com/watch?v=qDT4X2KO858&t=454s) Sonnet 5 and Fable 5 availability +- [09:23](https://www.youtube.com/watch?v=qDT4X2KO858&t=563s) Letta agents orchestrating Claude Code and Codex +- [10:10](https://www.youtube.com/watch?v=qDT4X2KO858&t=610s) Subagent and reflection panel preview +- [11:49](https://www.youtube.com/watch?v=qDT4X2KO858&t=709s) Slack agents and virtual coworker workflows +- [13:33](https://www.youtube.com/watch?v=qDT4X2KO858&t=813s) Slack run/status UI improvements +- [20:23](https://www.youtube.com/watch?v=qDT4X2KO858&t=1223s) Agent SDK, app server, and channels +- [37:56](https://www.youtube.com/watch?v=qDT4X2KO858&t=2276s) Organizing complex agent knowledge with skills and MemFS + +## Subject areas + +### Naming the product around what people actually do +The renaming discussion was not cosmetic. Cameron argued that “Letta Agent” better fits the lived use cases people describe: coding, operations, knowledge management, research, companionship, and role-play. In the episode’s framing, “Code” still names the core harness, but “Agent” names the broader experience around it. That separation matters because it clarifies which layer is infrastructural and which layer is user-facing. + +### Mods as a behavior layer +The Mod Challenge served as the best proof that a lot of useful agent behavior can be added without changing the core harness. Cameron walked through examples such as Jukebox, Auto Pivot, Control Room, Environment Compass, Hyper, Oath Keeper, Sprite, ThreadKeeper, and Muscle Memory. The point was less the individual gimmicks and more the pattern: mods can add coordination, guardrails, memory, and quality-of-life features that make agents more capable and easier to trust. + +### Slack as a collaboration surface +A major product thread was Slack integration. Cameron described Slack as a place where agents can act like coworkers inside the same workflow as humans, and showed work on inline run blocks that expose what an agent is doing while it works. The design goal is transparency: commands, reasoning, and progress should be visible in context, making Slack a practical operational surface for persistent agents rather than just a chat inbox. + +### Subagents, reflections, and orchestration +The app preview focused on a new panel for subagents and reflection agents. Instead of hiding those processes in popovers, the UI surfaces them in a dedicated side panel so users can inspect what happened, what files changed, and what a reflection concluded. That supports a broader architectural idea: one agent can delegate to many specialized workers, and the user should be able to see and reason about that delegation. + +### Models, cost, and choosing the right tool +The model discussion was pragmatic rather than hype-driven. Cameron compared Sonnet 5, Fable 5, and GLM-5.2, noting tradeoffs around cost and availability. The recurring recommendation was to let Letta agents orchestrate heavier CLI-based coding sessions when appropriate, because the outer agent can manage the larger task while subagents do the detailed work. + +## Q&A themes + +The Q&A clustered around a few recurring concerns: how mods are scoped, how skills are learned, whether agents can fork themselves for debugging, how local mode interacts with event-driven features, and how to organize knowledge with skills and MemFS. Several questions probed the boundary between mod state and durable memory, and Cameron repeatedly returned to the idea that the harness observes behavior, then distills repeated patterns into reusable structure. + +## Architectural through-line + +The episode’s architecture story is delegation. Letta Agent is presented as a layered system: a harness at the bottom, channels and mods as runtime behavior, subagents and reflection agents as coordination machinery, and skills/MemFS as a way to turn repeated work into durable capability. Slack then becomes the external collaboration surface where this machinery is visible to humans. The result is not just a chatbot or a coding assistant, but an extensible agent workplace. + +## Related public material + +- https://www.youtube.com/watch?v=qDT4X2KO858 +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk +- https://github.com/letta-ai/hypervigilant diff --git a/knowledge/published/letta-office-hours-2026-07-09.md b/knowledge/published/letta-office-hours-2026-07-09.md new file mode 100644 index 0000000..11e289d --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-07-09.md @@ -0,0 +1,118 @@ +--- +title: >- + Letta Office Hours: GPT-5.6, Grok 4.5, Letta App Server, and Spec-Driven + Agents +slug: letta-office-hours-2026-07-09 +summary: >- + Office hours cover new Slack agent UI, GPT-5.6 and Grok 4.5, the new-user path + in Letta Chat, and the app server and Agent SDK architecture. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - letta-office-hours + - gpt-5-6 + - grok-4-5 + - letta-chat + - app-server + - agent-sdk + - spec-driven-development + - model-economics +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=9AdOs2ImAX0' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:37b2f30de2fb80c10ca789251a2c674fab7cfca709836a6d312161672486159f' +updated: '2026-08-07T02:33:28.018Z' +reviewStatus: approved +youtubeVideoId: 9AdOs2ImAX0 +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:34.329Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-07-09 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-07-09.json + receiptDigest: 'sha256:4b7dbc31444cf7b327206f75e6140ff2096277bc2190bfed3c426d13d61b8464' +publishedAt: '2026-08-07T02:41:34.329Z' +reviewedContentDigest: 'sha256:2f1aaefed91f95ce1a65f892d3dc2ae87afcef61c774e6448e059b36fdbbe102' +reviewReceiptDigest: 'sha256:4b7dbc31444cf7b327206f75e6140ff2096277bc2190bfed3c426d13d61b8464' +--- +Letta’s July 9 office hours move quickly from product updates into broader questions about models, workflows, and the shape of agent software. The practical center of the episode is a set of changes to Letta Chat and Slack that make agent activity easier to read, make onboarding less confusing, and shift more everyday work into the web experience. Around that, Cameron uses the live Q&A to compare model offerings, explain the app server stack, and argue that the next phase of agent tooling is less about raw capability jumps than about workflow quality and system design. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The episode is less a feature tour than a map of how the Letta stack is being reorganized. Slack activity streaming becomes simpler and more legible; Tutor is introduced as a default onboarding agent; cloud sandboxes reduce setup friction; and chat.letta.com is positioned as the primary surface for most users, while platform.letta.com holds the more developer-oriented controls. Those updates connect directly to the architectural discussion later in the session: if agents are going to be built, observed, and controlled reliably, the UI, transport, and SDK layers have to align. + +## Selected chapters + +- [00:00:24](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=24s) Slack channel updates +- [00:01:18](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=78s) New Slack activity stream UI +- [00:01:40](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=100s) GPT-5.6 release and early impressions +- [00:03:57](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=237s) Grok 4.5 support and first impressions +- [00:05:09](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=309s) Improving the new user experience +- [00:05:54](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=354s) Tutor agents for onboarding +- [00:07:28](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=448s) Cloud sandboxes in Letta Chat +- [00:08:22](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=502s) chat.letta.com vs. platform.letta.com +- [00:13:13](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=793s) App server overview +- [00:16:08](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=968s) Building app-server-based agent applications +- [00:43:00](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=2580s) Model pricing, lock-in, and differentiation +- [00:51:06](https://www.youtube.com/watch?v=9AdOs2ImAX0&t=3066s) Inference speed and ASICs + +## Slack, chat, and onboarding + +The opening segment is about reducing friction. The Slack agent experience has been simplified, with a live activity stream that is easier to read and less visually noisy than the earlier preview. The emphasis is on reliability: the episode presents the merge as a substantial improvement to how Slack functions as an agent channel, while noting that richer presentation may return later. The same theme carries into Letta Chat, where more of the core workflow is being moved into the browser so users do not have to begin in CLI or desktop-first paths. + +That onboarding work includes Tutor, a default agent created to teach people how to use Letta. The episode frames Tutor as an answer to a long-standing problem: new users could arrive at chat.letta.com without understanding what to do next, or they could encounter an agent that had no tools because sandboxes were not yet available. With cloud sandboxes now broadly available, users can create and chat with agents in the browser without configuring a remote computer first. + +## The app server and Agent SDK + +A major explanatory section in the episode is the move from the older API-service model to the modern app server. Cameron describes the legacy approach as a clunky container-and-connection setup and contrasts it with Letta Code’s websocket-centered architecture. In this model, the app server streams events, receives control messages, and becomes the substrate on which the app itself is built. + +The Agent SDK sits on top of that layer and is presented as the preferred surface for developers. The practical implication is that agent applications should be built against the app server, not around the older service pattern. The episode’s examples—such as a software-factory style CLI that creates conversations for issues and pull requests—show how the architecture supports large numbers of coordinated agent workflows. The point is not just that agents can chat, but that they can be orchestrated, observed, and extended as programmable systems. + +## Models as products, not just benchmarks + +The model discussion is intentionally comparative rather than hype-driven. GPT-5.6 is described as promising, persistent, and fast enough to feel usable in everyday coding workflows. Grok 4.5 is treated as a surprise: unusually fast, affordable, and strong enough in code tasks to become a serious option where earlier Grok models had not been. The episode does not present those models as identical; it treats them as evidence that price, speed, and workflow fit are becoming as important as raw benchmark scores. + +That logic continues in the discussion of Anthropic and Fable. The episode acknowledges the strength of Anthropic’s product design and model personality while arguing that the premium and lock-in are harder to justify as alternatives improve. The broader claim is that model differentiation is shifting from big leaps in capability to differences in taste, guidance, and workflow integration. In that framing, a model can be valuable because it pushes back, offers opinionated direction, or fits a specific agent loop—not only because it solves harder tasks. + +## Spec-driven development and agent workflows + +One of the most interesting recurring ideas is spec-driven development. The episode links Misaligned, Notion ShipOS, and related tooling to a broader pattern: agents work better when the spec is the source of truth and code is generated or coordinated against that spec. That makes the human role more about defining constraints, objectives, and structure than hand-authoring every implementation detail. + +This becomes a general claim about agent-era software. If an agent can reliably read specs, follow them, and iterate, then the important engineering question is how to encode intention and workflow clearly enough for the system to execute. The episode suggests that this is where agent-specific tools will matter most: not in replacing software design, but in making design operational. + +## Q&A themes + +The Q&A ranges across model access, pricing, and the practicalities of building with Letta. Questions about Grok 4.5 pricing, availability, and subscription support lead into a broader discussion of cost pressure and model commoditization. Questions about managed sandboxes, native clients, and remote app servers clarify when the app server is the right foundation. Later questions about schedule observability, credentials clearing, desktop release timing, and a model-picker bug ground the architectural talk in current product work. + +## Architectural through-line + +The through-line of the episode is coordination: between UI and backend, between agent control and event streaming, and between model choice and workflow design. Letta is moving toward a stack where the browser is the default entry point, the app server is the control plane, the Agent SDK is the developer surface, and models are interchangeable inputs to higher-level workflows. The episode argues that this is how agents become practical: by making their behavior legible, their environments reliable, and their orchestration programmable. + +## Related public material + +- https://www.youtube.com/watch?v=9AdOs2ImAX0 +- https://docs.letta.com/ +- https://github.com/letta-ai/letta +- https://github.com/letta-ai/letta-code +- https://github.com/letta-ai/letta-agent-sdk diff --git a/knowledge/published/letta-office-hours-2026-07-16.md b/knowledge/published/letta-office-hours-2026-07-16.md new file mode 100644 index 0000000..e5de465 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-07-16.md @@ -0,0 +1,131 @@ +--- +title: >- + Letta Office Hours: Cloud Sandboxes, GitHub Integration, GPT-5.6, and Agent + Sharing +slug: letta-office-hours-2026-07-16 +summary: >- + Letta adds persistent cloud sandboxes, GitHub integration, model support + updates, and a broader discussion of shared and cross-organizational agents. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - cloud-sandboxes + - git + - agent-sharing + - openai-compatible-apis +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=vOOoH2QEEFg' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:50716c1356ededb0cf44fb55587ad9cda855521c52a17d6259d5a49411cee931' +updated: '2026-08-07T02:33:27.483Z' +reviewStatus: approved +youtubeVideoId: vOOoH2QEEFg +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:34.873Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-07-16 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-07-16.json + receiptDigest: 'sha256:cc92b3133b0a27efc7a6325b5e22f4823d064aa7c9cbd22e5ac6e7820df01cc6' +publishedAt: '2026-08-07T02:41:34.873Z' +reviewedContentDigest: 'sha256:173b173b80b2c05cae9b8d1ebfe03e16efe8dc9e5b02cc263b5dc7c269cc3c70' +reviewReceiptDigest: 'sha256:cc92b3133b0a27efc7a6325b5e22f4823d064aa7c9cbd22e5ac6e7820df01cc6' +--- +The [July 16, 2026 Letta Office Hours episode](https://www.youtube.com/watch?v=vOOoH2QEEFg) is organized around a practical question: what does it take for agents to do useful work without collapsing into a single chat box or a single machine? The product updates focus on persistent cloud sandboxes, GitHub integration for bringing repositories into those sandboxes, model-provider support, and ongoing work on agent sharing. The guest segment with Shub then shifts the conversation toward how Letta is thinking about personal agents, shared agents, and agents that operate across organizational boundaries. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The episode is a useful snapshot of Letta’s system-level direction. A durable agent needs somewhere to live, some files to modify, a model to call, and a protocol for being shared. Cameron and Shub repeatedly return to those layers, showing that the platform is trying to make stateful work practical rather than merely impressive. + +## Selected chapters + +| Time | Topic | +| --- | --- | +| [00:00](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=0s) | Intro and framing | +| [00:46](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=46s) | Persistent cloud sandboxes | +| [03:14](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=194s) | Sandbox archival and retention | +| [03:48](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=228s) | GitHub integration | +| [05:23](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=323s) | Mods repository updates | +| [06:48](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=408s) | GPT-5.6, Grok 4.5, and custom endpoints | +| [08:43](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=523s) | Shub joins the episode | +| [11:06](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=666s) | Design process with Tonic | +| [11:38](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=698s) | Personal, shared, and cross-org agents | +| [16:16](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=976s) | Cloud scheduling and performance improvements | +| [19:51](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=1191s) | Persistent sandbox demo begins | +| [27:54](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=1674s) | Constellation vs. non-Constellation agents | +| [34:16](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=2056s) | What “local agent” means | +| [39:20](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=2360s) | ATProto and inter-agent communication | +| [53:21](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=3201s) | Migrating between cloud and local agents | +| [1:11:08](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=4268s) | New-user experience and companion guides | +| [1:24:09](https://www.youtube.com/watch?v=vOOoH2QEEFg&t=5049s) | Misaligned and game design | + +## Persistent cloud sandboxes make stateful work practical + +Cameron begins with persistent cloud sandboxes, which are framed as writable environments that keep their own filesystem state. That matters because it lets an agent do real work over time without forcing the user to provision a separate machine or remote environment for every task. The episode describes this as a shift from ephemeral interactions toward durable workspaces where files, progress, and tool state can survive across sessions. + +The point is not just convenience. Persistent sandboxes make the agent’s working context more explicit. Instead of treating the model as a detached text generator, Letta is building a structure in which the model, the files, and the execution environment remain connected long enough for meaningful tasks to finish. The GitHub integration extends that idea by making repositories directly available inside the sandbox, so an agent can reason about code and operate on it in the same place. + +## Shared model support widens where agents can run + +The episode also notes support for additional models and a general OpenAI-compatible endpoint for custom providers. That kind of compatibility is easy to dismiss as plumbing, but it is central to the system’s architecture. If Letta wants agents to run across different environments, then the model layer has to be flexible enough to follow the deployment rather than dictate it. + +This is also where the product’s vocabulary matters. The episode is not talking about a single “best model” so much as about a stack that can accommodate different runtime choices. Persistent sandboxes, custom endpoints, and model selection all serve the same purpose: to let the harness remain stable even when the underlying model or deployment changes. + +## Agent sharing is framed as a collaboration primitive + +When Shub joins, the conversation moves from runtime mechanics to organizational structure. The discussion of personal, shared, and cross-organizational agents treats agents as entities that can represent different scopes of work. Some belong to one person. Some belong to a team. Some may serve as liaison points between groups. That taxonomy is important because it shows Letta thinking about agents as durable collaborators rather than disposable prompts. + +The conversation also suggests that the product’s sharing model is meant to preserve boundaries rather than erase them. A shared agent is not just a copied chat transcript; it is an object with access rules, continuity, and a role. That distinction helps explain why the office-hours episode spends so much time on memory, sandboxes, and deployment—sharing only makes sense if the underlying state model is sound. + +## Cloud scheduling and performance complete the deployment picture + +Cloud scheduling appears as the temporal counterpart to persistent sandboxes. The episode presents schedules as a way to let an agent return later and continue work in a durable environment. That is especially important for long-running or recurring workflows, where the agent should survive the user’s immediate session and resume on a schedule. + +Performance work enters here as a practical limiter. Even if an architecture is elegant, users still need the system to feel responsive. The episode ties these concerns together: persistence, scheduling, and runtime efficiency are all prerequisites for making agent workflows feel dependable enough to use day after day. + +## Q&A themes + +The Q&A broadens the episode’s architecture into user-facing questions: + +- **What counts as a local agent?** The discussion suggests the term can be ambiguous, depending on where execution and memory actually live. +- **How do agents move across cloud and local environments?** The answer is tied to preserving agent identity while changing the execution surface. +- **How should cross-organizational sharing work?** The episode treats this as a permissions and continuity problem, not just a syncing problem. +- **Why talk about ATProto?** Because inter-agent communication needs a protocol story if agents are going to cross tool boundaries. +- **How should newcomers learn the system?** The new-user discussion points toward companion guides and onboarding flows that teach the architecture gradually. +- **What is the role of non-product experiments like Misaligned?** They act as playgrounds for testing how humans and agents interact under different assumptions. + +## Architectural through-line + +The through-line here is that Letta is separating state into layers: the agent, its sandbox, its schedule, its model provider, and its sharing boundary. Each layer can change independently, which makes the platform more flexible for real-world deployment. A task can run in one cloud sandbox, a different machine can own the schedule, and an agent can still preserve continuity across both. + +That separation also explains the episode’s educational tone. Users do not just need a tool; they need a mental model for where work lives. The episode makes the case that persistent agents become useful when ownership, execution, and sharing are all explicit enough to be managed separately. + +## Related public material + +- [YouTube episode](https://www.youtube.com/watch?v=vOOoH2QEEFg) +- [Letta documentation](https://docs.letta.com/) +- [Agent Client Protocol](https://docs.letta.com/platform/acp) +- [Letta Agent SDK](https://docs.letta.com/agent-sdk) +- [Letta Code](https://github.com/letta-ai/letta-code) +- [Letta ACP repository](https://github.com/letta-ai/letta-acp) diff --git a/knowledge/published/letta-office-hours-2026-07-23.md b/knowledge/published/letta-office-hours-2026-07-23.md new file mode 100644 index 0000000..161e0d3 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-07-23.md @@ -0,0 +1,132 @@ +--- +title: 'Letta Office Hours: Agent SDK, Shared Memory, and Spec-Driven Development' +slug: letta-office-hours-2026-07-23 +summary: >- + July 23, 2026 office hours episode on the Letta Agent SDK, agent-created + schedules, shared memory, ACP support, and spec-driven development. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - agent-sdk + - shared-memory + - schedules +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=sVcYbJW0Hxc' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:b0de232b138bac069c69d176ddd0fcb8b4acda49146a79b8bd05b5bef6ddaa7e' +updated: '2026-08-07T02:43:10.392Z' +reviewStatus: approved +youtubeVideoId: sVcYbJW0Hxc +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:43:23.088Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-07-23 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-07-23.json + receiptDigest: 'sha256:1bad62cbc3eb387055efa012d2ac01a78ffdbfae6958ae23f4d413754ab55319' +publishedAt: '2026-08-07T02:41:35.438Z' +reviewedContentDigest: 'sha256:b2beab59de406668beb9ccf7d8777c1bb54a62905dfb11db1e642fb30db2f38c' +reviewReceiptDigest: 'sha256:1bad62cbc3eb387055efa012d2ac01a78ffdbfae6958ae23f4d413754ab55319' +--- +The July 23, 2026 Letta Office Hours episode introduced a new phase of the product narrative: the Agent SDK was presented as the main way for developers to build against Letta, after a period of API and deployment shifts. Cameron framed the SDK as the bridge between persistent agents, client-side orchestration, and custom interfaces, then used examples like Dispatch and Throne to show how event streams, approvals, and many parallel conversations can be composed into larger workflows. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The rest of the episode explored how Letta was splitting the system into clearer parts: schedules that can outlive a single session, OpenAI-compatible model endpoints for local and hosted tooling, persistent sandboxes, early shared-memory ideas, and communication paths for agents and channels. The Q&A then pushed into memory governance, tool approvals, agent identity, and how to teach agents through feedback and explicit specs rather than by hoping raw chat history will be enough. + +## Selected chapters + +- [00:00](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=0s) Episode introduction +- [00:50](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=50s) Agent SDK is ready +- [03:40](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=220s) Dispatch, Throne, and custom UIs +- [08:23](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=503s) Agent-created cloud schedules +- [09:38](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=578s) OpenAI-compatible endpoint +- [11:12](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=672s) Docs, self-configuration, and sandboxes +- [13:26](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=806s) ACP editor support +- [14:11](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=851s) Shared memory preview +- [15:47](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=947s) Q&A: Agent SDK use cases +- [44:40](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=2680s) Agent memory and approval flows +- [54:02](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=3242s) Progressive disclosure and memory navigation +- [1:26:42](https://www.youtube.com/watch?v=sVcYbJW0Hxc&t=5202s) Spec-driven development and playtests + +## From legacy API flow to the Agent SDK + +The episode's central announcement was that the TypeScript Agent SDK had reached the point where developers could build real applications on it. Cameron described an earlier transition away from a Docker-style API service and a later shift toward easier agent deployment on client devices, then positioned the SDK as the current answer to those needs. The important point was not just syntax: the SDK was presented as the abstraction for persistent agents, conversations, tool execution, and approvals, rather than a thin wrapper around message sends. + +That framing helps explain why the episode kept contrasting the old REST-style flow with higher-level application patterns. Instead of treating every request as a one-off chat turn, the SDK was shown as the layer that lets applications keep agent identity stable while spinning up many conversations or sessions around it. This makes the system more like an operating surface for agent work than a single chat endpoint. + +## Dispatch, Throne, and event-driven work + +The episode used two concrete examples to make the SDK tangible. Dispatch, built by Sarah, turns a task plus instructions into an agent stream that can be watched as work progresses. Throne, Cameron's own prototype, aims at industrial-scale software work: dispatch many runs at once, route work into separate conversations, and manage a large number of software tasks without forcing one interface to handle everything manually. + +These demos show a product idea that runs through the whole episode: Letta is not only for an interactive chat window, but also for bulk orchestration. The agent can be the worker, reviewer, and coordinator at once, while the surrounding interface decides which conversations to expose, which tasks to batch, and how much of the stream the human should inspect. + +## Schedules, sandboxes, and execution location + +Another major theme was the separation of time from place. Agent-created cloud schedules were discussed as durable triggers that can wake an agent later, even if the original machine is offline. The episode also described persistent sandboxes that can be spun down, archived, and later revived, with the practical warning that anything deployed there should also exist elsewhere. + +That same boundary shows up in the OpenAI-compatible endpoint discussion. By exposing a common API shape, Letta can interoperate with tools such as Open WebUI or LibreChat while still keeping its own persistent-agent semantics underneath. The result is a system that can plug into familiar tooling without collapsing every execution mode into one flat model call. + +## Shared memory and approval boundaries + +The shared-memory preview introduced a more explicit distinction between private agent memory and project-level context. Rather than treating every agent update as automatically authoritative, the episode leaned toward a versioned, reviewable memory surface. That led into discussion of approval flows: some memory changes are useful as direct writes, but other kinds of updates may need a human-readable proposal or a pull-request-like step before they are absorbed. + +The Q&A made the tradeoff concrete. The more an agent can learn, the more important it becomes to know which memories are personal, which are shared, and which should be revisable. The episode did not present memory as a single storage bucket; it presented it as a governance problem with different paths for durable identity, team context, and inspectable edits. + +## Spec-driven development with agents + +The late episode moved from architecture to method. Cameron described his preference for spec-driven development: start with explicit behavior, use tests and playtests to pin down what should happen, and let the agent operate inside those constraints. His discussion of Misaligned and related workflows emphasized that an agent can be productive only when the system around it clarifies the desired outcome. + +That same logic tied together the episode's other themes. Shared memory, schedules, channels, and SDK sessions all become easier to reason about when the contract is stated up front. The agent may move quickly, but the project still needs a spec that tells it what counts as correct. + +## Q&A themes + +- Why the Agent SDK is the preferred application layer for persistent agents. +- How cloud sandboxes and schedules retain work across devices and sessions. +- Why shared memory needs permissions and review, not just write access. +- How agent-to-agent and agent-to-client communication can stay separable. +- Why tests, contracts, and explicit specs matter more as agents do larger code tasks. + +## Architectural through-line + +The episode's architecture keeps separating concerns that used to be bundled together: + +- **Agent identity** is distinct from a conversation. +- **Memory** is distinct from shared project knowledge. +- **Schedules** are distinct from the computer that executes them. +- **Sessions and channels** are distinct from the runtime that serves the agent. + +That is the underlying story of the episode. Letta was being presented as a distributed system for long-lived agents, where persistence comes from clean boundaries rather than from one giant always-on chat process. + +## Related public material + +- [YouTube video](https://www.youtube.com/watch?v=sVcYbJW0Hxc) +- [Letta documentation](https://docs.letta.com/) +- [MemFS and shared memory](https://docs.letta.com/concepts/memfs) +- [Letta Agent SDK](https://docs.letta.com/agent-sdk) +- [Schedules](https://docs.letta.com/configuration/schedules) +- [Channels](https://docs.letta.com/configuration/channels) +- [Letta ACP](https://docs.letta.com/platform/acp) +- [Letta Agent SDK repository](https://github.com/letta-ai/letta-agent-sdk) +- [Hypervigilant repository](https://github.com/letta-ai/hypervigilant) diff --git a/knowledge/published/letta-office-hours-2026-07-30.md b/knowledge/published/letta-office-hours-2026-07-30.md new file mode 100644 index 0000000..6b24f17 --- /dev/null +++ b/knowledge/published/letta-office-hours-2026-07-30.md @@ -0,0 +1,135 @@ +--- +title: 'Letta Office Hours: Free Dreaming, ACP, MCP, and Trajectory' +slug: letta-office-hours-2026-07-30 +summary: >- + Letta adds free dreaming on Cloud, ACP editor support, broader MCP + integration, and Trajectory for learning across coding-agent harnesses. +kind: journal +status: historical +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - public-source + - agent-sdk + - memory + - acp + - mcp + - trajectory +related: + - letta-office-hours + - letta + - letta-code +sources: + - title: Official YouTube episode + url: 'https://www.youtube.com/watch?v=8EmAPYKl-4Y' + - title: Letta documentation + url: 'https://docs.letta.com/' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:251bb6f96c173706b01814f9afe8cc2eb3c703c665e5888ba4d295e9fa18464d' +updated: '2026-08-07T02:33:26.429Z' +reviewStatus: approved +youtubeVideoId: 8EmAPYKl-4Y +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:35.980Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours-2026-07-30 + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours-2026-07-30.json + receiptDigest: 'sha256:eb5584d3041cafb175a273f0931647c1502fc7569464b35c9be21f5726276781' +publishedAt: '2026-08-07T02:41:35.980Z' +reviewedContentDigest: 'sha256:8026c0e95784fb8c6284b45438c970a1da5f9b4f38c2ac386960b3155b4d141a' +reviewReceiptDigest: 'sha256:eb5584d3041cafb175a273f0931647c1502fc7569464b35c9be21f5726276781' +--- +The [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. + +This guide is part of the [Letta Office Hours archive](/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification. + +The 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. + +## Selected chapters + +| Time | Topic | +| --- | --- | +| [00:00](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=0s) | Welcome and episode framing | +| [00:18](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=18s) | Dreaming becomes free on Letta Cloud | +| [02:17](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=137s) | Reflection and memory commit demo | +| [04:22](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=262s) | Customizing the dreaming model | +| [05:06](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=306s) | ACP support announced | +| [06:12](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=372s) | Letta ACP in Zed | +| [08:25](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=505s) | MCP support across the stack | +| [09:30](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=570s) | Chat Completions and Responses APIs | +| [11:00](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=660s) | Trajectory and transcript learning | +| [12:58](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=778s) | Q&A on the research team and memory model | +| [15:57](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=957s) | Why GLM 5.2 struggled with memory | +| [20:52](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=1252s) | MCP versus skills | +| [26:17](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=1577s) | Trajectory’s use cases | +| [31:58](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=1918s) | Sleep time for companion agents | +| [38:07](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=2287s) | Trajectory for companion workflows | +| [45:13](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=2713s) | Memory belongs inside the harness | +| [49:38](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=2978s) | Multi-agent orchestration | +| [1:14:21](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=4461s) | Teaching agents to improve | +| [1:24:50](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=5090s) | Skills for learning software engineering | +| [1:34:52](https://www.youtube.com/watch?v=8EmAPYKl-4Y&t=5692s) | Misaligned and playtesting | + +## Dreaming becomes a cheaper maintenance loop + +Cameron 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. + +That 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. + +## Agent Client Protocol moves Letta into editors + +A 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. + +This 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. + +## MCP and API compatibility widen the integration surface + +The 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. + +That 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. + +## Trajectory treats agent transcripts as reusable learning data + +Trajectory 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. + +The 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. + +## Q&A themes + +The Q&A turns the product updates into a set of architectural questions: + +- **How should memory maintenance be powered?** The episode argues for a cheaper, more routine dreaming loop so agents stay current without expensive upkeep. +- **Where should agent identity live?** The recurring answer is inside the Letta runtime, not inside whichever editor or client happens to connect. +- **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. +- **Why normalize transcripts across harnesses?** Because learning from agent behavior requires comparable data, not just more data. +- **How should companion agents sleep or wake?** The episode explores timing as part of harness design, not as an afterthought. +- **Why keep emphasizing inspectability?** Because persistent memory is only useful if people can review and revise it. + +## Architectural through-line + +The 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. + +That 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. + +## Related public material + +- [YouTube episode](https://www.youtube.com/watch?v=8EmAPYKl-4Y) +- [Letta documentation](https://docs.letta.com/) +- [Agent Client Protocol](https://docs.letta.com/platform/acp) +- [Letta Agent SDK](https://docs.letta.com/agent-sdk) +- [Letta Code](https://github.com/letta-ai/letta-code) +- [Letta Agent SDK repository](https://github.com/letta-ai/letta-agent-sdk) +- [Trajectory](https://docs.letta.com/) +- [OpenHands](https://github.com/All-Hands-AI/OpenHands) diff --git a/knowledge/published/letta-office-hours.md b/knowledge/published/letta-office-hours.md new file mode 100644 index 0000000..5e2b187 --- /dev/null +++ b/knowledge/published/letta-office-hours.md @@ -0,0 +1,143 @@ +--- +title: Letta Office Hours +slug: letta-office-hours +summary: >- + Timestamped explanatory guides to Letta Office Hours episodes, organized as + historical records of the platform’s changing agent architecture. +kind: map +status: evolving +claimMode: mixed +perspectiveOwner: Co +confidence: medium +topics: + - ai + - agents + - letta + - office-hours + - map-of-content +related: + - letta + - letta-code + - persistent-agent-memory + - durable-agent-execution +sources: + - title: Letta on YouTube + url: 'https://www.youtube.com/@letta-ai/videos' + - title: Letta documentation + url: 'https://docs.letta.com/' + - title: Letta on GitHub + url: 'https://github.com/letta-ai' +aiAssisted: true +generatedBy: Co +sourceDigest: 'sha256:1e25b31cd563019703459c8ecd088061127bb99b3e7896664002c4641bd61c3a' +updated: '2026-08-07T02:33:42.799Z' +reviewStatus: approved +reviewBasis: technical-publication-authorization +implementationReviewedBy: Co +implementationReviewedAt: '2026-08-07T02:41:18.752Z' +publicationAuthorization: + kind: technical-publication-authorization + authorizedBy: Cameron + recordedAt: '2026-08-07T01:55:00.000Z' + route: letta-office-hours + scope: technical-publication + exactRenderReviewed: false + receiptPath: knowledge/receipts/technical-publication/letta-office-hours.json + receiptDigest: 'sha256:4f965d6d93fdf3fb74ebaf6a523c2f170a2427a3c98c6146643fdf6d44365bd9' +publishedAt: '2026-08-07T02:41:18.752Z' +reviewedContentDigest: 'sha256:cd0f28b65c6d2579cfec9818bcc29f34d3d1b531444c85c2b3946b80475353df' +reviewReceiptDigest: 'sha256:4f965d6d93fdf3fb74ebaf6a523c2f170a2427a3c98c6146643fdf6d44365bd9' +--- +Letta Office Hours is a public video series about the changing architecture and practice of persistent AI agents. These guides turn each recording into a compact, timestamped explanation of its major announcements, demonstrations, questions, and design connections. + +The pages are historical records, not current product manuals. Letta changes quickly; a feature described in an older episode may have been renamed, redesigned, removed, or absorbed into a different surface. The original recording remains the primary source for what was said at that time. + +## Episodes + +### 2026 + +- **[2026-08-06: Shared Memory, Hypervigilant, Schedules, and the Agent SDK](/knowledge/letta-office-hours-2026-08-06)** — Shared memory, schedule execution, local providers, the channels gateway, Hypervigilant, and the Agent SDK. + +- **[2026-07-30: Free Dreaming, ACP, MCP, and Trajectory](/knowledge/letta-office-hours-2026-07-30)** — Letta adds free dreaming on Cloud, ACP editor support, broader MCP integration, and Trajectory for learning across coding-agent harnesses. + +- **[2026-07-23: Agent SDK, Shared Memory, and Spec-Driven Development](/knowledge/letta-office-hours-2026-07-23)** — July 23, 2026 office hours episode on the Letta Agent SDK, agent-created schedules, shared memory, ACP support, and spec-driven development. + +- **[2026-07-16: Cloud Sandboxes, GitHub Integration, GPT-5.6, and Agent Sharing](/knowledge/letta-office-hours-2026-07-16)** — Letta adds persistent cloud sandboxes, GitHub integration, model support updates, and a broader discussion of shared and cross-organizational agents. + +- **[2026-07-09: GPT-5.6, Grok 4.5, Letta App Server, and Spec-Driven Agents](/knowledge/letta-office-hours-2026-07-09)** — Office hours cover new Slack agent UI, GPT-5.6 and Grok 4.5, the new-user path in Letta Chat, and the app server and Agent SDK architecture. + +- **[2026-07-02: Letta Agent, Mod Challenge Demos, Slack Agents, and GLM-5.2](/knowledge/letta-office-hours-2026-07-02)** — Cameron frames Letta Agent as the broader packaged experience, then walks through mod challenge demos, Slack coworker workflows, model choices, and subagent tooling. + +- **[2026-06-29: Mods, Signal Support, GLM-5.2, and Slack Agents](/knowledge/letta-office-hours-2026-06-29)** — Office hours on mods, Signal channels, model routing, secret handling, and why Slack-style channels can make agents feel more like coworkers. + +- **[2026-06-19: Mods, MemFS, and Teaching Agents New Tricks](/knowledge/letta-office-hours-2026-06-19)** — Office hours on mods, local mode, channels, schedules, memory architecture, and how Letta teaches agents new capabilities over time. + +- **[2026-05-21: New Desktop UI, Local Mode, Agent Services, and Skills vs MCP](/knowledge/letta-office-hours-2026-05-21)** — Office hours on the redesigned Letta Code desktop app, local mode, memory UX, agent services, and the product and protocol tradeoffs behind skills, MCP, and channels. + +- **[2026-05-14: Local Mode and the New Pro Plan](/knowledge/letta-office-hours-2026-05-14)** — Office hours on a memory-forward Letta Code UI, local mode, slash commands, /goal, and the shift from Max plans to Pro, BYOK, and credits. + +- **[2026-05-08: Sandboxes for Letta Chat, Sensemaker, and an agent that plays Pokemon](/knowledge/letta-office-hours-2026-05-08)** — New channel controls, local-only Letta Code, sandboxed agents in Letta Chat, Sensemaker, and design guidance for building durable agents. + +- **[2026-05-01: Discord Channel, Custom Plugins, Letta City Sim, and a Special Guest](/knowledge/letta-office-hours-2026-05-01)** — Office hours covers Discord channels, custom plugins, schedules, policy boundaries, Letta City Sim, model updates, and a long Q&A on memory, context, and agents. + +- **[2026-04-23: Digital Coworkers with Slack](/knowledge/letta-office-hours-2026-04-23)** — Letta office hours on Slack-native agents, remote environments, channel hosting, and why skills beat MCP-style integrations. + +- **[2026-04-16: Channels, Cron, and Opus 4.7](/knowledge/letta-office-hours-2026-04-16)** — Office hours on built-in channels, schedules, remote environments, and how recent model and agent changes shape always-on workflows. + +- **[2026-04-09: April 9th, 2026](/knowledge/letta-office-hours-2026-04-09)** — Office hours covering Letta Code general access, remote control mode, the memory viewer, social agents, ChatGPT memory import, and the Context Constitution. + +- **[2026-04-02: April 2nd, 2026](/knowledge/letta-office-hours-2026-04-02)** — Cameron introduces the new Letta Code app, demos memory repair and sleep-time processing, and answers questions on tools, deployment, and agent memory design. + +- **[2026-03-26: Desktop Early Access, Forking, Secrets, Memory Doctor](/knowledge/letta-office-hours-2026-03-26)** — Office hours covering desktop early access, new slash commands, memory health checks, auto fallback, and the shift toward stateful multi-agent workflows. + +- **[2026-03-19: March 19th, 2026](/knowledge/letta-office-hours-2026-03-19)** — Cameron explains Letta’s client-side shift, MemFS, sleeper agents, deprecations, and the move toward skills, code SDK orchestration, and computer-use-first workflows. + +- **[2026-03-12: March 12, 2026](/knowledge/letta-office-hours-2026-03-12)** — Office hours recap of Auto Mode, Letta Code and Chat changes, Lettabot improvements, Ezra's new capabilities, and community-built fleet and team tooling. + +- **[2026-03-05: Letta Remote, Claude Subconscious Demo, and Lettabot](/knowledge/letta-office-hours-2026-03-05)** — Office hours on Letta Remote, chat-to-remote workflows, Lettabot updates, pricing tradeoffs, and demos of Claude Subconscious and Co-work. + +- **[2026-02-26: MemFS, Letta Chat, and the future of AI agent memory](/knowledge/letta-office-hours-2026-02-26)** — Office hours on MemFS, Letta Remote, Letta Chat, sleep-time compute, Lettabot upgrades, and how Letta is rethinking agent memory. + +- **[2026-02-05: Opus 4.6, Lettabot Updates, Agent File Directory, and More](/knowledge/letta-office-hours-2026-02-05)** — Office hours on Opus 4.6, Letta Code provider setup, Lettabot, agent self-forking, and why Letta favors stateful agents over retrieval-only memory. + +- **[2026-01-29: Introducing LettaBot +Claude Subconscious Demo](/knowledge/letta-office-hours-2026-01-29)** — Office hours on LettaBot, a locally deployed messaging bridge for agents, plus a live Claude Subconscious demo that injects Letta context into Claude Code. + +- **[2026-01-26: Letta Chat, GitHub Action, Letta Code, and more!](/knowledge/letta-office-hours-2026-01-26)** — Cameron demos Letta Chat, a GitHub Action for Letta Code, specialist repo agents, the note tool, and social agents on Blue Sky. + +- **[2026-01-09: Message Scheduling, GitHub Actions, Ralph Mode, and the Note Tool](/knowledge/letta-office-hours-2026-01-09)** — Office hours on scheduling, GitHub Actions, Ralph mode, custom commands, sub-agents, the note tool, and why simple memory structures often beat heavier abstractions. + +### 2025 + +- **[2025-12-18: Letta Code Demo, Agent Skills, Claude Code Proxy & More](/knowledge/letta-office-hours-2025-12-18)** — Office hours on Letta Code, agent skills, persistent memory, sub-agents, and emerging ideas for shared blocks and file-system-like agent environments. + +- **[2025-12-04: December 4th, 2025](/knowledge/letta-office-hours-2025-12-04)** — December 4, 2025 office hours on the v1 SDK launch, message search, Learning SDK examples, skills, lettactl, personal agents, and Ezra updates. + +- **[2025-11-06: November 6th, 2025](/knowledge/letta-office-hours-2025-11-06)** — November 6, 2025 office hours on the v1 SDK migration, shared archives, Letta Code improvements, AI Memory SDK v0.2, scheduling, and Ezra. + +- **[2025-10-30: October 30th, 2025](/knowledge/letta-office-hours-2025-10-30)** — October 30, 2025 office hours on Letta Code, Co, the Obsidian plugin, personal agents, and the platform shift toward terminal-first and note-centric workflows. + +- **[2025-10-16: October 16th, 2025](/knowledge/letta-office-hours-2025-10-16)** — October 16, 2025 office hours on voice support, the runs viewer, Telegram improvements, stateful-agent patterns, and practical tips for building with memory. + +- **[2025-10-02: October 2nd, 2025](/knowledge/letta-office-hours-2025-10-02)** — October 2, 2025 office hours on the v1 alpha, memory tools, mobile agents, Obsidian, Bluesky, and the shift toward a new agent architecture. + +- **[2025-09-25: September 25th, 2025](/knowledge/letta-office-hours-2025-09-25)** — Office hours on the AI SDK v5 update, cloud reliability work, open-source release planning, memory behavior, and model/provider recommendations. + +## Recurring themes + +- **Persistent identity and memory.** The series repeatedly separates an agent from any one chat window, model call, or client application. + +- **Execution surfaces.** Letta Code, Desktop, Chat, channels, sandboxes, schedules, and the Agent SDK appear as different ways to connect durable agents to work. + +- **Harness extension.** Skills, tools, MCP, mods, protocols, and provider compatibility are treated as different layers rather than synonyms. + +- **Inspectable state.** Memory files, commits, runs, approvals, traces, and tests make agent behavior reviewable instead of merely fluent. + +- **Teaching and evaluation.** Later episodes increasingly ask how agents learn from trajectories, specifications, feedback, and explicit release gates. + +## Public sources + +- [Letta on YouTube](https://www.youtube.com/@letta-ai/videos) + +- [Letta documentation](https://docs.letta.com/) + +- [Letta on GitHub](https://github.com/letta-ai) diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2025-09-25.json b/knowledge/receipts/technical-publication/letta-office-hours-2025-09-25.json new file mode 100644 index 0000000..a0c5af1 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2025-09-25.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2025-09-25", + "route": "letta-office-hours-2025-09-25", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2025-10-02.json b/knowledge/receipts/technical-publication/letta-office-hours-2025-10-02.json new file mode 100644 index 0000000..ea0b02a --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2025-10-02.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2025-10-02", + "route": "letta-office-hours-2025-10-02", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2025-10-16.json b/knowledge/receipts/technical-publication/letta-office-hours-2025-10-16.json new file mode 100644 index 0000000..0c2e9f4 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2025-10-16.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2025-10-16", + "route": "letta-office-hours-2025-10-16", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2025-10-30.json b/knowledge/receipts/technical-publication/letta-office-hours-2025-10-30.json new file mode 100644 index 0000000..298b8be --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2025-10-30.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2025-10-30", + "route": "letta-office-hours-2025-10-30", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2025-11-06.json b/knowledge/receipts/technical-publication/letta-office-hours-2025-11-06.json new file mode 100644 index 0000000..374f7fa --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2025-11-06.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2025-11-06", + "route": "letta-office-hours-2025-11-06", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2025-12-04.json b/knowledge/receipts/technical-publication/letta-office-hours-2025-12-04.json new file mode 100644 index 0000000..9dda4c7 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2025-12-04.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2025-12-04", + "route": "letta-office-hours-2025-12-04", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2025-12-18.json b/knowledge/receipts/technical-publication/letta-office-hours-2025-12-18.json new file mode 100644 index 0000000..15d08eb --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2025-12-18.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2025-12-18", + "route": "letta-office-hours-2025-12-18", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-01-09.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-01-09.json new file mode 100644 index 0000000..3035a11 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-01-09.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-01-09", + "route": "letta-office-hours-2026-01-09", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-01-26.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-01-26.json new file mode 100644 index 0000000..1d21f1d --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-01-26.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-01-26", + "route": "letta-office-hours-2026-01-26", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-01-29.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-01-29.json new file mode 100644 index 0000000..bfeb1af --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-01-29.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-01-29", + "route": "letta-office-hours-2026-01-29", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-02-05.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-02-05.json new file mode 100644 index 0000000..af42fe5 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-02-05.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-02-05", + "route": "letta-office-hours-2026-02-05", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-02-26.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-02-26.json new file mode 100644 index 0000000..e9fecaa --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-02-26.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-02-26", + "route": "letta-office-hours-2026-02-26", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-03-05.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-03-05.json new file mode 100644 index 0000000..0735742 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-03-05.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-03-05", + "route": "letta-office-hours-2026-03-05", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-03-12.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-03-12.json new file mode 100644 index 0000000..8a2abd4 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-03-12.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-03-12", + "route": "letta-office-hours-2026-03-12", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-03-19.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-03-19.json new file mode 100644 index 0000000..af4fba7 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-03-19.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-03-19", + "route": "letta-office-hours-2026-03-19", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-03-26.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-03-26.json new file mode 100644 index 0000000..d042899 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-03-26.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-03-26", + "route": "letta-office-hours-2026-03-26", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-04-02.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-04-02.json new file mode 100644 index 0000000..17054bb --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-04-02.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-04-02", + "route": "letta-office-hours-2026-04-02", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-04-09.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-04-09.json new file mode 100644 index 0000000..db14aa5 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-04-09.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-04-09", + "route": "letta-office-hours-2026-04-09", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-04-16.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-04-16.json new file mode 100644 index 0000000..e8ff12a --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-04-16.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-04-16", + "route": "letta-office-hours-2026-04-16", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-04-23.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-04-23.json new file mode 100644 index 0000000..bc21298 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-04-23.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-04-23", + "route": "letta-office-hours-2026-04-23", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-05-01.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-05-01.json new file mode 100644 index 0000000..fdde64b --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-05-01.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-05-01", + "route": "letta-office-hours-2026-05-01", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-05-08.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-05-08.json new file mode 100644 index 0000000..db2a43a --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-05-08.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-05-08", + "route": "letta-office-hours-2026-05-08", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-05-14.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-05-14.json new file mode 100644 index 0000000..f99d7ea --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-05-14.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-05-14", + "route": "letta-office-hours-2026-05-14", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-05-21.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-05-21.json new file mode 100644 index 0000000..425e8ce --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-05-21.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-05-21", + "route": "letta-office-hours-2026-05-21", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-06-19.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-06-19.json new file mode 100644 index 0000000..d6b5efd --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-06-19.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-06-19", + "route": "letta-office-hours-2026-06-19", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-06-29.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-06-29.json new file mode 100644 index 0000000..636334c --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-06-29.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-06-29", + "route": "letta-office-hours-2026-06-29", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-07-02.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-02.json new file mode 100644 index 0000000..c4bd3f0 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-02.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-07-02", + "route": "letta-office-hours-2026-07-02", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-07-09.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-09.json new file mode 100644 index 0000000..8d4a052 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-09.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-07-09", + "route": "letta-office-hours-2026-07-09", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-07-16.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-16.json new file mode 100644 index 0000000..a6aeedb --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-16.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-07-16", + "route": "letta-office-hours-2026-07-16", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-07-23.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-23.json new file mode 100644 index 0000000..d20ec82 --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-23.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-07-23", + "route": "letta-office-hours-2026-07-23", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours-2026-07-30.json b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-30.json new file mode 100644 index 0000000..bd5529c --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours-2026-07-30.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours-2026-07-30", + "route": "letta-office-hours-2026-07-30", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is one episode in that commissioned 31-page backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} diff --git a/knowledge/receipts/technical-publication/letta-office-hours.json b/knowledge/receipts/technical-publication/letta-office-hours.json new file mode 100644 index 0000000..e0575fa --- /dev/null +++ b/knowledge/receipts/technical-publication/letta-office-hours.json @@ -0,0 +1,20 @@ +{ + "schema": 1, + "kind": "technical-publication-authorization", + "entrySlug": "letta-office-hours", + "route": "letta-office-hours", + "authorizedBy": "Cameron", + "recordedAt": "2026-08-07T01:55:00.000Z", + "scope": "technical-publication", + "authorizationBasis": "Telegram message 17731 explicitly requested Public Knowledge pages for previous Letta Office Hours episodes. Message 17733 recorded the public inventory as 31 prior recordings and the full-backfill interpretation; message 17734 confirmed continuing with subagents. This route is the chronological series index needed to navigate that commissioned backfill.", + "exactRenderReviewed": false, + "implementationReviewedBy": "Co", + "constraints": [ + "Use only the public episodes, public captions, public metadata, official documentation, public repositories, and existing public Knowledge entries.", + "Publish explanatory wiki guides with concise leads, selected timestamp links, architectural context, Q&A themes, and one chronological series index; do not publish transcript dumps.", + "Exclude private conversation, private people or relationships, health, work-internal material, finances, housing, location detail, audience identities, and incidental personal tangents.", + "Treat each page as a historical record of what the episode announced, demonstrated, or discussed; do not imply old behavior remains current.", + "Do not represent technical-publication authorization as exact Cameron review.", + "Run deterministic coverage, timestamp, privacy, source-link, graph, responsive, deployment, live-route, and protocol-mirror checks before reporting completion." + ] +} -- 2.51.2