Channels

One agent, many hats

The agent has a single identity and memory, but it is able to wear a different "hat" on each entrypoint to the agent. For example, a friends channel can be a guarded way for friends to contact your agent. A peer-query channel can be a one-shot communication endpoint for another agent. A reflection channel can be a quiet space where the agent works on itself on a schedule. Each channel has its own lifetime, tools, prompt, boundary scripts, model, and who can reach it. The three patterns below make this concrete.

A friends channel

You might want to let a friend talk to your personal agent — get help with something, ask a question — without giving them the same surface you use yourself. A separate channel with its own prompt and ACL grant does that.

Persistent lifetime keeps the chat open between messages. Full lifecycle wires in bootstrap and cleanup so context with this friend carries across sessions. The per-channel prompt sets the agent's posture (warm but guarded) and tells it when to push a question back to you.

# blueprint/channels/friends/channel.json
{
  "idle_timeout": 1800000,
  "lifecycle": "full"
}

# blueprint/channels/friends/prompt.md
You're talking to one of my friends, not me. Be helpful and warm.
You can share what I've marked as shareable in /memory/; otherwise
default to private — answer in general terms or politely decline.

If a question comes up you're unsure about, message me and wait for
my reply before answering.

A peer-query endpoint

Another agent might need a quick answer without opening an ongoing relationship. A peer-query channel takes one question, returns one answer, and closes. The peer accumulates no state with you, and the channel can expose a narrower tool surface than the default — answers don't need to schedule tasks or push into other conversations.

idle_timeout: null makes it single-shot, paired with disabled_tools to narrow what the peer-callable surface can reach. A short prompt.md sets the one-shot posture so the agent commits to a complete answer in its single turn.

# blueprint/channels/peer-query/channel.json
{
  "idle_timeout": null,
  "disabled_tools": ["task__*", "conversation__push_to_channel"]
}

# blueprint/channels/peer-query/prompt.md
You're answering one question from a peer agent. Give a complete
answer in your single turn — there are no follow-ups. Cite from
/memory/ where you can; be specific.

A reflection channel that runs on its own

An agent benefits from working on itself off-thread. A reflection channel is the agent talking to itself on a schedule: review the day, distill what mattered, leave a note in /memory/. No human in the loop, no ongoing chat to maintain. The conversation opens, the agent does its work in one turn, and it closes.

Three pieces carry the pattern. idle_timeout: null makes it single-shot. The per-channel prompt.md tells the agent what reflection means on this surface. And a per-channel model override pins it to Haiku, since this work doesn't need the agent's heavier default.

# blueprint/channels/reflection/channel.json
{
  "idle_timeout": null
}

# blueprint/channels/reflection/prompt.md
You're doing your daily reflection. Skim recent work logs and message
threads. Append a paragraph to today's entry in /memory/journal/ —
decisions made, surprises, anything worth remembering next time.

# config/agent.json   (excerpt — per-channel model override)
{
  "modelOverrides": [
    { "channel": "reflection", "model": "claude-haiku-4-5" }
  ]
}

What's in a channel definition

A channel is a directory under blueprint/channels/<name>/. Most of what shapes the channel lives inside that folder; a couple of operator-set knobs sit outside it, in the agent's config.

What to read next

• Conversations — the unit a channel shapes.
• Scheduling & triggers — what fires a channel, beyond a person sending a turn.
• Authoring blueprints — the full field reference for every file in the channel folder.