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 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)
- 00:01:04 Channels: Telegram and Slack built into Letta Code
- 00:03:00 How channels replace Lettabot
- 00:05:31 Channels via CLI deployment
- 00:07:31 Schedules and cron jobs
- 00:08:36 Remote environments explained
- 00:11:04 Opus 4.7 model news
- 00:12:30 Recall agent and self-forking conversations
- 00:13:30 Telegram pairing and permissions
- 00:24:14 Subagents available everywhere
- 00:49:31 LoRA and fine-tuning vs in-context learning
- 01:33:34 Local models vs cloud hosting
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.