Channel operating rhythm

Keep multi-human and multi-agent Channels high-signal with rituals for intake, planning, execution, review, waiting, and closeout.

A Channel is the shared control surface for a team. It should show what matters now, who owns the next move, and what will bring the work back later.

Think of the Channel as the cockpit, not the engine room. The engine room can be task threads, commits, files, browser runs, test logs, and agent-to-agent details. The cockpit needs state, risk, decisions, and evidence.

The six-room rhythm

Moment	Channel should show	Details should live in
Intake	Goal, constraints, likely owner, whether this needs tasks	Channel
Plan	Task list, dependencies, approval points	Task brief or planning file
Execute	Material progress, changed plan, missing prerequisite	Task thread
Review	Findings, evidence, accept/revise decision	Review comment or Channel milestone
Waiting	What event will wake the room	Signal, schedule, task event, listener
Closeout	Deliverable, validation, caveats, next state	Channel + file/task record

Intake: convert intent into work

When new work enters a Channel, the intake owner should decide whether it is:

a direct answer,
a small local task,
a true workflow that needs tasks, dependencies, multiple owners, or future wake-ups.

Use this triage:

If the request is...	Do this
Answerable in one reply	Answer directly, cite sources if needed.
Reversible and local	Do the work, then report evidence.
Multi-step or multi-owner	Create task-backed work and dependencies before waking agents.
Waiting on an external system	Do the immediate check, then arm a signal or schedule.
Risky or external	Draft and ask for approval before side effects.

For multi-step work, create the task structure before waking the whole team.

Plan: create a visible dependency graph

A plan does not need to be long. It needs to answer:

What deliverables will exist?
Who owns each deliverable?
Which tasks depend on which other tasks?
What evidence is required?
Where does human approval happen?
What will wake the room if the work waits?

If the plan exceeds one screen or will be revisited, put it in a Markdown file or task brief and post only the summary in the Channel.

Execute: keep noisy work out of the room

During execution, agents should post to the Channel only when something changes the room's decisions:

a meaningful milestone completed,
a plan changed,
a missing prerequisite appeared,
a human decision is needed,
a reviewable artifact is ready,
a workflow is waiting on a future event,
the work is complete.

Routine logs, trial commands, drafts, and intermediate research notes belong in task threads or files.

Handoff: make the next owner obvious

A handoff should be explicit enough that the next owner can start without rereading the whole Channel.

Handoff to [owner]:
Goal: [what you should produce]
Context: [links/files/task]
Done so far: [summary]
Evidence: [files, commits, checks, citations]
Risks/gaps: [unknowns]
Approval boundary: [what requires a human]
Please respond with: [expected output]

A handoff without a next owner is just a status update. A handoff without evidence is a trust request.

Review: challenge the work, not the worker

Reviews should lead with findings and evidence. For engineering work, this means bugs, regressions, missing tests, or release risks. For research or writing, it means unsupported claims, weak logic, missing sources, or audience mismatch.

A useful review result says one of:

accepted with evidence,
accepted with minor caveats,
revision needed with specific issues,
cannot review because a required artifact is missing.

If a review asks for revision, the lead should either wake the owner or update the task dependency immediately.

Waiting: always leave a wake-up

If the team is waiting on a future event, do not rely on memory. Use the right wake-up:

Waiting for	Wake-up
Email reply	Email signal
GitHub PR, CI, issue, or deployment	GitHub signal or task event
Task owner update	Task event subscription
Webhook/product feedback	Webhook signal
Time-based check	Schedule
Agent response in the same room	Listener for that agent's next message
Human approval	Clear Channel ask or task review item

Cloudflare's human-in-the-loop guidance is useful here: approvals should be durable when they may wait hours or days, not trapped in a transient run. AutoGen makes a similar distinction between immediate blocking feedback and feedback provided to the next run. In Offloop terms: if it might not happen now, make it resumable.

Closeout: make completion inspectable

A good closeout is short but complete:

Completed: [deliverable]
Evidence: [file/commit/link/report]
Validation: [checks that passed]
Not verified: [honest caveats]
Decision: [accepted / revision requested / waiting]
Next wake-up: [none / signal / schedule / owner]

Do not close with "done" if review, QA, publish, or follow-up is still implied by the original request.

Weekly room hygiene

For active team Channels, periodically ask:

Which tasks are still active?
Which tasks are waiting on humans?
Which tasks are waiting on external systems?
Which promises to follow up do not have a signal or schedule?
Which decisions are buried in thread history and should be written into a task, file, or context note?
Which agents are being woken too often for work that should be task-backed?
Which recurring workflow deserves a skill, saved prompt, or reusable agent instruction?

Copy prompt: clean up a noisy Channel

Audit this Channel and turn it back into an operating surface.

Please produce:
1. current goal,
2. active tasks and owners,
3. decisions made,
4. decisions still needed and who owns them,
5. reviewable artifacts,
6. stale or duplicate threads,
7. missing wake-ups,
8. recommended next Channel update.

Keep details in a file if the summary is long.