tally Get started →
TALLY PROTOCOL · GROMIT 0.2.0

Your tools stay yours. The shared parts stay in step.

Everyone runs a sidecar. It checks what their tools did against the team's contracts, signs it and shares it through the relay. Every sidecar folds the same log the same way, so the shared parts of everyone's tools agree and the rest never leaves your machine.

  1. 1 Publish POST /do A tool tells its owner’s sidecar what happened.
  2. 2 Judge contracts/*.yaml The sidecar checks it against the team’s contracts and signs it. A rejected event never leaves the machine.
  3. 3 Share GET /events The relay adds it to the signed log and sends it to every sidecar.
  4. 4 Fold GET /state Each sidecar folds it with the same contracts, so the shared parts of every tool update the same way.
shared: same on every machine private: one person's tools only contracts, in every sidecar
ONE EVENT, FOUR STEPS

What happens when someone on the team does something

Claiming a ticket, approving an MR, recording a decision: every change takes the same four steps, on everyone's machine at once. Scroll through them one at a time.

01 · PUBLISH · POST /do

Your tools tell your sidecar.

Everything on the bus starts on someone's machine. Your tool's adapter, the gromit CLI and Claude Code all ask the same thing of the same sidecar, over a unix socket only your user can open.

  • The sidecar holds your device key and signs. Adapters and agents never see it.
  • Only what a tool shares goes in. The circles in the picture are private items: they never enter the pipe.
  • Offline? The sidecar queues it and sends it when the relay is back.
The sidecar API →
02 · JUDGE · contracts/*.yaml

The sidecar checks it against the team's contracts.

Contracts are YAML files the team agrees on. Before anything leaves your machine, your sidecar judges it exactly as every other sidecar will, and answers with an outcome.

  • applied, pending and suggestion are signed and sent on.
  • rejected:<reason> is never stored or sent. Sending it again gets the same answer.
  • Agents act within a mandate their person granted. Protected acts, like approving an MR, stay human.
The contracts → Every outcome →
    03 · SHARE · GET /events

    The relay keeps the signed log and passes it on.

    The relay is the one shared piece. It stores every signed event in order and sends it to every sidecar in the grouping. It never sees your tools.

    • It checks the signer is a member and the event is next in their feed. It doesn't judge contracts: the sidecars already did.
    • It stamps received_at, the one clock every time rule uses.
    • A sidecar that was offline catches up from where it left off. Nothing is lost while you're away.
    How the relay works →
    04 · FOLD · GET /state

    Every sidecar folds the same log the same way.

    Events reach different machines in different orders. The fold doesn't care: the same events through the same contracts give the same state, and your adapter brings the shared parts back into your tool.

    • Two claims at once? The lower hash wins and the other becomes fork, on every machine.
    • Contract tests fold every case in 12 shuffled orders to prove the state doesn't move.
    • GET /state is the truth. Adapters compare with it on every pass.
    The fold →
    ruth · created A ines · claimed A · 1220a3… kofi · claimed A · 1220f1…
    THREE WAYS ONTO THE BUS

    Nobody changes tools. Each one gets a way in.

    Adapters

    For your own tool, the one only you use. A small program on your machine reads the tool, publishes the difference through your sidecar and brings back what teammates did. Any language.

    Write an adapter →
    Bridges

    For shared systems. The GitLab bridge turns each MR into a change set; the Asana bridge turns board tasks into work items, both ways. They run with the relay, so nobody needs an adapter for these.

    How bridges work →
    Agents

    Claude Code acts through your sidecar's MCP tools as you/claude, only within the mandate you granted. Routine work applies at once; commitments wait for you; protected acts stay yours.

    For agents →
    THE RULES LIVE IN GIT

    The team changes the rules by signing for them.

    Contracts and membership are files in a governance repo. Pushing a change activates nothing. Members approve the commit with a tag signed by their device key, and once the quorum is met, every sidecar and the relay switch to it within about 15 seconds.

    Changing a contract →
    a0bec9a · Add sam ines approved kofi approved ruth · not yet active
    each member who needs to approve
    gromit approve a0bec9a8a7aeff7b007eed27ad30c896e4b6cc69
    # pushed approve/a0bec9a8a7…/ines

    Join in three commands.

    Install Gromit, install from the steward's invite, and wait for their approval. About 15 seconds after they approve, you're connected and Claude Code can see the team's work.

    your Mac
    brew install TomPope94/gromit/gromit
    gromit local install --invite "tally:eyJ…" --person sam --write
    gromit local status      # "connected" once the steward approves you