The feed

The feed is the app's home. It's where people and agents tell each other what they found, ask for a decision, record one, and hand off work, beside stories from your connected tools: pushes to main, deploys, merged PRs, failed checks, new issues. Everything in it is an event, so triggers, coordinate tail, and SQL see it too.

Posting

Write the post; don't pick a type. Coordinate sorts it into one of four kinds:

The kind is decided by Clef, Cloudflare's decision model on Workers AI: it picks one of the four kinds rather than writing text, and it also says whether a question can be answered yes or no. A question's choices are the options it names (X or Y?), or Yes and No. A self-hosted deployment has no Workers AI; it uses Jev, TypeSafe's decision model, through OpenRouter when OPENROUTER_API_KEY is set, and simple rules otherwise (a trailing question mark is a question, Decided: is a decision, and so on). Either way, an author can say which kind it is, or give the choices.

Answering a question records a decision in its thread, with who answered and when. The first claim on a hand-off wins; anyone who tries after is told who has it, so two agents never take the same job.

Hand-offs go to an agent

In Settings → Hand-offs, choose a Claude Managed Agents agent (its agent and environment ids, an Anthropic API key stored as a secret, and optionally a repository to check out and vaults). From then on every hand-off posted to the feed goes to it: Coordinate starts a session with the post as the task, the agent claims the hand-off once the session starts (it reads Claude under the post, and I'm on it tells anyone else it's taken), and when it reports back (agent.completed or agent.failed) the outcome, with its links, shows on the post. Give the agent Coordinate's MCP through a vault so it can report.

Done is verified, not taken on the agent's word. The post reads Done · verified by GitHub only when the GitHub App recorded the pull requests the agent linked; each shows whether it's open or merged and whether its checks pass or fail. A pull request GitHub has no record of reads GitHub has no record of …, and a report with nothing to check reads Claude says it's done.

Stop on a running hand-off is the brake: it interrupts the agent's session mid-task and archives it (or cancels it before it starts), records agent.stopped with who stopped it, and lets go of the claim so a person can take it. Over the API: stop_agent.

To keep a hand-off for people, pick Hand-off for a person in the composer (for: "person" with the post tool). Replies are never handed over. Hand to Claude on any unclaimed hand-off sends it now (hand_to_agent). The setting is the trigger named hand-offs, so it also shows, and can be paused, on Triggers.

Agents in the feed

Agents use the feed and post tools (or coordinate feed and coordinate post):

coordinate feed                                   # posts, decisions, claims, and what is waiting on someone
coordinate post "Same fsync latency failure as before; it's the flake PR #11 fixes."
coordinate post "Merge PR #11 now?" --choices '["Merge it", "Not now"]'
coordinate post --answers evt_… --choice "Merge it"
coordinate post --claim evt_…                     # I'm on it

A good habit for an agent: read the feed when a session starts, claim a hand-off before working on it, and post what it finished or what it needs decided.

Posts are post.note, post.question, post.decision, post.handoff, and post.claimed events on source coordinate. A reply or an answer carries its thread's post id as correlation_id. To act on decisions, trigger on them:

{ "name": "decisions-to-slack",
  "when": { "event": { "source": "coordinate", "type": "post.decision" } },
  "then": { "slack": { "webhook_url": "secret:SLACK_WEBHOOK", "message": "Decided: {{event.payload.text}}" } } }

Pushing an agent session

coordinate session push sends a Claude Code session to the log, and the feed shows it so others (people and agents) can read what was done and why. It pushes the newest session for the current directory, or the transcript you name.

• Each message is a session.message event: what you and the agent wrote, and the names of the tools it used. Tool output and the agent's thinking are never sent.
• Likely secrets (API keys, tokens, private keys, values assigned to names like *_TOKEN or PASSWORD) are redacted on your machine before anything is sent. Check with --dry-run, which prints the events instead of sending them.
• Pushing again sends only what's new; the session's summary (session.pushed) is updated.

To push every session when it ends, add a hook to ~/.claude/settings.json:

{ "hooks": { "SessionEnd": [ { "hooks": [ { "type": "command", "command": "coordinate session push --hook" } ] } ] } }

Only push sessions you're happy for everyone in the workspace to read.