A channel is a room the agent listens in, and four knobs make each room what it is.
What a channel is
A channel is a labeled room on the agent. The agent's brain, identity, and memory are shared across all of its channels. What the agent does in any one room is shaped by that room's configuration.
Rooms run in parallel. The agent in its email room and the agent in your chat are independent live sessions, not a queue. The agent can triage incoming mail while you're talking to it, reflect overnight while a deferred fire lands. And within any one room, each person who reaches the agent there gets their own private conversation. Same room, same rules, separate histories.
There's nothing built in to subscribe to. Every channel is something the operator declares. default is conventionally the user-facing conversation room, and everything else (e.g. events, reflection, ask, review) is named by whoever wrote the agent. The four knobs are what make each room what it is.
Conversations and the learning loop
fig. 1: conversation lifecycle
Inside a channel, the unit of work is a conversation, a bounded live session with a finite context window. Conversations have lifecycles: they start, accumulate context as the agent works, and end (either when the channel's idle timer expires, or right after the reply if the channel is ephemeral).
Two hooks bridge across. Bootstrap fires at the start and reads /memory/ to pull forward what matters. Cleanup fires at the end and writes back what the conversation learned: distilled notes, summaries, anything worth keeping. This is how the agent learns over time without an unbounded window: each conversation is a focused chunk. Durable notes accumulate in memory and recall at the next bootstrap when relevant. Token-efficient by construction.
Access. Who is allowed to address the channel. The operator grants per-peer permissions: granted users get conversational read/write, peer agents get query-only doors, some channels stay internal, so only schedule fires and the like reach them.
Capabilities. Which tools the agent can reach in this channel. A peer-query room might block everything outbound. An email triage room might block writes to peers and schedules. A conversation room usually grants the full toolkit.
Working memory. Whether the channel's short-term context survives between fires. Persistent: the conversation picks up where it left off, and the agent's working context stays warm across turns. Ephemeral: every visit starts fresh, with the agent rebuilding context from /memory/ at bootstrap. Persistent fits conversations, ephemeral fits scheduled jobs, event handlers, and peer queries, where state from the last fire would contaminate the next.
Instructions. The channel's own behavior prompt, plus optional bootstrap (read at start) and cleanup (read at end) hooks. The agent reads them on every visit.
Different settings of the four knobs produce recognizable shapes:
A conversation room. Granted-user access + full capabilities + persistent working memory + conversational instructions. The default shape, and the agent picks up where you left off.
A scheduled reflection room. Internal-only access + narrowed capabilities + ephemeral working memory + reflection-shape instructions. Each evening's pass is independent, and nothing from yesterday bleeds into tonight.
A peer-query door. Designated-peer access + outbound-blocked capabilities + ephemeral working memory + answer-shape instructions. Callers ask, the agent answers, the session ends. The same agent can hold sensitive data its caller doesn't.
An event-handler room. Push/file-watch access + narrowed capabilities + ephemeral working memory + triage-shape instructions. The agent decides per-event whether to act silently or surface to the user's channel.
The point isn't that these are the only shapes. It's that one mechanism with four dials produces all of them. New shapes are new combinations, not new mechanisms.
Where channels stop
A channel is not a security wall. The agent's brain is the same brain everywhere. If it's compromised in one room, it's the same agent in the others. What channels give you is defense in depth inside the one trust boundary that's actually mechanical (the container). They let you match the agent's behavior in each context to the trust posture of that context, without splitting the agent itself.