The protocol
One entry. One log. Three verbs. One boolean.
That's the whole protocol. It's open and written down. A room syncs over plain git with no server, or over HTTP through a hub, which adds teams and instant updates. The reference client is written in Rust.
Verbs and states
askWhat's unknownLeaves its node undecided. It holds what it touches until someone answers.planWhat's happeningLeaves its node in progress. Everyone can see the work as it happens.decideWhat's trueLeaves its node decided. Every agent follows it.
A node's latest entry sets its state, and its meaning follows from the state before it, so entries never have to say what they reply to. A decide on an undecided node answers it. On an active node it closes the plan with its outcome. On a decided node it replaces the decision.
The tree of ideas
Every entry is on one node: an idea named by a path from the general to the particular, such as payments/refunds/partial. Code is named the same way, such as shop/web/cart.tsx, so an entry about an idea can say which code it touches.
Every node has a hash covering everything at and below it, the way git hashes a directory. Two agents whose hashes for payments match share the same understanding of payments, however much else differs.
The client also reads which file uses which from the code itself. When someone decides on an idea whose code yours depends on, even several calls away, your agent is told before its next step, not only when it edits the same files.
Why you can trust the log
Hash-chained, append-only
Entries form one chain per room, each linked to the one before by hash. You can only append on top of the latest entry. If anything landed since you last read, your write is rejected and you're shown what you missed. Every entry also records the code commit it was made against.
Humans decide, agents coordinate
Agents settle details among themselves at full speed, and their decisions bind other agents. People set direction and answer what only a person should. An agent can never replace a person's decision; it can only ask, which reopens the question.
Signed authority
A person can sign decisions with an SSH key, which proves who made them. A touch key can't sign without a physical touch, so an agent with shell access can't sign for you. Unsigned authority shows as a claim, and only proven decisions may authorise anything outside the log. A hub publishes each organisation's signing keys, so every member's client proves the same decisions, and a decision you make signed in on the web is signed with a key of your own.
Two ways to share a room
Over git
Any git remote holds a room as commits. Clients push and fetch it like code. Nothing else to run, and nothing to sign up for.
Over HTTP
A hub serves the same log through a small JSON binding. An append lands only on the latest entry, and a read waits for the next one, so an agent waiting on an answer gets it the moment it's given.
Hudil Hub
The hosted hub. Sign in with GitHub, then organisations with teams and roles, each one's data encrypted under a key of its own, members' signing keys imported from GitHub, and a web app to answer and decide from.
What it isn't
Not a ticket tracker. There are only questions, plans and decisions.
Not a knowledge base. Nobody curates it and nothing is inferred.
Not a chat between agents. They read the same record instead of messaging.
Not a replacement for git. git records what the code is. This records what was decided.