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

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

**Title:** Letta Office Hours: Local Mode and the New Pro Plan
**Published:** Fri, 07 Aug 2026 02:41:31 GMT
**Updated:** Fri, 07 Aug 2026 02:33:30 GMT
**Description:** 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.
**Publication:** `at://did:plc:gfrmhdmjvxn2sjedzboeudef/site.standard.publication/3mr4py6clps2f`
**Path:** /letta-office-hours-2026-05-14
**Tags:** knowledge, journal, ai, agents, letta, office-hours, public-source, letta-code, memory-ui, local-mode, slash-commands, model-routing, pricing, agent-services

**Content:**
```json
{
  "text": "[Watch this episode on YouTube](<https://www.youtube.com/watch?v=F50DN3GlzB0>)\n\nThis 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.\n\nThis guide is part of the [Letta Office Hours archive](https://cameron.stream/knowledge/letta-office-hours) and describes the episode as a historical record rather than a current product specification.\n\nThe 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.\n\n## Selected chapters\n- [00:00 Welcome](https://www.youtube.com/watch?v=F50DN3GlzB0&t=0s)\n- [00:54 Memory-forward UI in Letta Code](https://www.youtube.com/watch?v=F50DN3GlzB0&t=54s)\n- [01:16 Expanded memory view and markdown editor](https://www.youtube.com/watch?v=F50DN3GlzB0&t=76s)\n- [03:27 Memory graph and commit history](https://www.youtube.com/watch?v=F50DN3GlzB0&t=207s)\n- [05:08 Local mode without Cloud or Docker](https://www.youtube.com/watch?v=F50DN3GlzB0&t=308s)\n- [07:03 Invoking skills directly with slash commands](https://www.youtube.com/watch?v=F50DN3GlzB0&t=423s)\n- [07:22 /goal for long-running objectives](https://www.youtube.com/watch?v=F50DN3GlzB0&t=442s)\n- [08:25 Max and Max Lite plan changes](https://www.youtube.com/watch?v=F50DN3GlzB0&t=505s)\n- [11:08 Recommended model paths: Pro, BYOK, credits, Codex](https://www.youtube.com/watch?v=F50DN3GlzB0&t=668s)\n- [38:24 Letta Auto, model routing, and sensitive data](https://www.youtube.com/watch?v=F50DN3GlzB0&t=2304s)\n- [57:34 Agent services: Ezra, Overlord, and Sensemaker](https://www.youtube.com/watch?v=F50DN3GlzB0&t=3454s)\n- [01:16:30 Closing notes](https://www.youtube.com/watch?v=F50DN3GlzB0&t=4590s)\n\n## Memory as an interface\nThe 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.\n\nA 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.\n\n## Local mode and lightweight setup\nLocal 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.\n\nThis 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.\n\n## Commands for long-running work\nThe 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.\n\nThe /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.\n\n## Plan changes and model strategy\nThe 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.\n\nThe 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.\n\n## Model routing and Letta Auto\nThe 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.\n\nThat 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.\n\n## Agent services as a design pattern\nLater 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.\n\nThe 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.\n\n## Q&A themes\n- Choosing between Pro, BYOK, credits, and direct provider subscriptions\n- Why frontier model usage was being removed from quota-style plans\n- How local mode changes onboarding and infrastructure requirements\n- Whether Letta Auto should be treated as a router or a manual model list\n- How to think about agent services like Ezra and Overlord\n- Why memory updates should be aligned with the agent’s own runtime state\n\n## Architectural through-line\nThe 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.\n\nIn 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.\n\n## Related public material\n- https://www.youtube.com/watch?v=F50DN3GlzB0\n- https://github.com/letta-ai/letta-code\n- https://letta.com/\n- https://docs.letta.com/\n\n## Sources\n\n- [Official YouTube episode](<https://www.youtube.com/watch?v=F50DN3GlzB0>)\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`*