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

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

**Title:** Letta Office Hours: Letta Remote, Claude Subconscious Demo, and Lettabot
**Published:** Fri, 07 Aug 2026 02:41:26 GMT
**Updated:** Fri, 07 Aug 2026 02:33:35 GMT
**Description:** Office hours on Letta Remote, chat-to-remote workflows, Lettabot updates, pricing tradeoffs, and demos of Claude Subconscious and Co-work.
**Publication:** `at://did:plc:gfrmhdmjvxn2sjedzboeudef/site.standard.publication/3mr4py6clps2f`
**Path:** /letta-office-hours-2026-03-05
**Tags:** knowledge, journal, ai, agents, letta, office-hours, public-source, letta-remote, letta-chat, lettabot, model-routing, pricing, claude-subconscious, co-work

**Content:**
```json
{
  "text": "[Watch this episode on YouTube](<https://www.youtube.com/watch?v=-SwpYxjGRdg>)\n\nAt 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.\n\nThis guide is part of the [Letta Office Hours archive](https://cameron.stream/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification.\n\nAround 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.\n\n## Selected chapters\n- [00:00:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=0s) Opening remarks and the episode focus\n- [00:00:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=30s) Letta Remote overview\n- [00:01:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=90s) Letta Chat for remote and server mode\n- [00:02:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=120s) Lettabot updates: cancel, model selection, redaction\n- [00:03:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=210s) Per-agent tool scoping and Docker deployment\n- [00:04:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=270s) ChatGPT onboarding and model access\n- [00:10:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=600s) Max-plan usage limits and pricing tradeoffs\n- [00:12:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=750s) Why memory and cheaper models matter\n- [00:15:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=930s) Model behavior, intent, and architecture\n- [01:28:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=5280s) Claude Subconscious demo and ecosystem value\n- [01:33:00](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=5580s) Letta Co-work as a prettier local interface\n- [01:41:30](https://www.youtube.com/watch?v=-SwpYxjGRdg&t=6090s) Product positioning for Chat, Code, and Bot\n\n## Letta Remote as a control plane\nLetta 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.\n\nThe 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.\n\n## Letta Chat becomes the front door\nLetta 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.\n\nThat 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.\n\n## Lettabot as a configurable agent system\nA 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.\n\nThe 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.\n\n## Pricing, models, and the memory tradeoff\nThe 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.\n\nThat 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.\n\n## Claude Subconscious and Co-work\nTwo 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.\n\nCo-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.\n\n## Q&A themes\nThe 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.\n\n## Architectural through-line\nThe 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.\n\n## Related public material\n- https://www.youtube.com/watch?v=-SwpYxjGRdg\n- https://docs.letta.com/\n- https://github.com/letta-ai/letta\n- https://github.com/letta-ai/letta-code\n- https://github.com/letta-ai/letta-agent-sdk\n- https://github.com/letta-ai/hypervigilant\n\n## Sources\n\n- [Official YouTube episode](<https://www.youtube.com/watch?v=-SwpYxjGRdg>)\n- [Letta documentation](<https://docs.letta.com/>)",
  "$type": "site.standard.content.markdown",
  "version": "1.0"
}
```

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