switchyardcallboard

Switchyard · Conductor

Every session gets a receipt.

An agent checks in with its role and rig. Callboard resolves its instructions on the server and returns them with a manifest of exactly which component versions went into them — and records that manifest against the session.

Open the callboard See live sessions

Request example

check_in { role: "judge", agent_name: "sc-judge-1",
           rig: "switchyard-callboard", client: "claude",
           vars: { default_branch: "main" } }

Response

session_idses_7f3a91c2channel canary
documentcore/judgev4
snippetcore/house-rulesv3
snippetcore/escalationv1
snippetcore/summonv4
snippetcore/proposev2
snippetshared/peer-reviewv1
snippetshared/tersev1

An example receipt. Sign in to see your own sessions.

What it owns

Four concerns, one Go binary. Agents never carry their own copy of an instruction again.

  1. 1

    Registry

    Orgs → fleets → roles → agents. Roles carry traits (lifecycle, write authority, review discipline, tone) that shape the instructions they resolve to.

  2. 2

    Instructions

    Documents and namespaced, pinned snippets. A role's effective instructions are resolved server-side and returned with a manifest of exactly which component versions went into it.

  3. 3

    Versions

    Immutable versions; channels (production, canary, pins) decide what a check-in resolves to. Rollback is re-pointing a label.

  4. 4

    Sessions

    The check-in/check-out ledger — who ran on what version, for how long, at what token cost, and how it went.

Resolution

One source, composed on the server.

A role's instructions are assembled at check-in from rows that are stored once. Nothing here keeps a second copy of an instruction.

  • Namespaced and pinned

    References pin namespace, name and version — never a bare name — so two snippets can share a name indefinitely without one shadowing the other.

  • Composed in a declared order

    The base document, then org-wide snippets, then snippets attached to the role's traits. The manifest records exactly that order.

  • A receipt for every session

    check_in durably binds the session to the exact manifest it resolved, so "which instructions was this agent running?" has one answer.

Built to fail loudly

An instruction that is silently wrong is worse than one that fails. Every write and every resolution is checkable.

  • Merge is publish

    Edits happen on a Dolt branch and are reviewed as a diff. A version that can't name the branch it merged from doesn't exist.

  • Versions never change

    A published version is immutable and content-hashed. Republishing v2 with different text is a duplicate-key error, not a silent substitution.

  • Rollback is re-pointing a label

    production and canary are pointers. Rolling back moves the label to an edition that already exists; nothing is copied.

  • Leftover markers are refused

    If a template marker survives rendering, resolution fails and names the variable. It never reaches an agent as instruction text.

The MCP surface

Six tools. check_in takes no channel argument — which edition runs where is an operator decision made in the registry.

health           {}                             # server version and database reachability
check_in         { role, agent_name, rig, client, vars?, caps?, model? }
                 → { session_id, instructions,
                     manifest: [{kind, namespace, name, version}...],
                     channel, model, preferred_model?, models?, expires_hint }
heartbeat        { session_id }                 # liveness; silent past the window = lapsed
get_instructions { session_id }                 # re-fetch the pinned receipt
check_out        { session_id, outcome_summary, tokens?, duration_seconds? }
report           { session_id, message, kind? } # mid-session breadcrumb; kind defaults to note

See what your agents are running.

20 roles · 2 channels · one manifest per session.

Open the callboard Browse agents