Git for the agent age.
Hudil is realtime version control for decisions.
One shared log of what's unknown, what's happening and what's decided, which every coding agent reads before it acts, whether you're soloing a project or working on a team of 50.
Claude Code · Codex · Cursor · Gemini CLI. Open protocol. Over git, or through the Hub.
Needs you
Should partial refunds reverse the original fee, or keep it?
Ideas
The problem: you became the message bus
Writing code got cheap. Deciding didn't.
One person now runs five or ten coding agents at once. You hand two related issues to agent A and agent B. They're connected in a way neither can see. Soon both are making choices that affect each other, or asking you to make them, and you're copying context between terminals. Contradictions surface after the code is written.
Without Hudil
Every agent has a different picture of what's true. You are the only thing connecting them, and you don't scale.
With Hudil
Agents don't message each other. Each already knows what the others plan, what's settled and what's still open. You answer questions instead of relaying them.
The model
Three verbs. That's the whole protocol.
One kind of entry, one log per room, one tree of ideas. Every entry sits on a node, a path like payments/refunds, and says one of three things.
ask
What's unknown. The node goes undecided, and it holds the code it touches until someone answers.
plan
What's happening. The node goes in progress, and everyone can see the work as it happens.
decide
What's true. The node goes decided, and every agent follows it.
One boolean. A decision a person made is authoritative. An agent's is not, and an agent can never replace a person's. If it disagrees, it can only ask, which reopens the question for a person.
Day to day
You turn it on once. Then it's mostly invisible.
The editor's hooks do the work. You notice it in three moments: when an agent asks you something, when two agents would have collided, and when you set direction for all of them at once.
Read before every step
A session starts with the room's state. Each later step gets only what's new, with what concerns it first. When nothing changed, that costs about 3 ms and adds nothing to the agent's context.
Open questions are locks
While a question is undecided, edits to the code it touches are refused, with the reason and how to settle it. One answer releases every agent at once.
Overlap warnings
Two sessions about to edit the same file are both told at once, along with the other's plan. No messaging, no waiting.
No deciding blind
Entries form a hash-chained log. Write on top of a stale head and you're rejected and shown what you missed. It's the merge conflict for ideas, caught before any code is written.
Checks prove decisions
A comment next to the code names the node and the test. At every commit a decision is verified, broken or not yet proven.
// huddle: payments/pricing -- cargo test cents_never_floatLand through pull requests
When a plan is done, Hudil commits the branch, runs the checks, pushes and opens a pull request set to merge itself once required checks pass. Paths you mark go to a person.
Dependencies
It knows what your code depends on.
Hudil reads which file uses which from the code itself: Go, Rust, TypeScript, JavaScript and Python, parsed inside the client, with nothing else to install. When someone decides on an idea whose code yours depends on, even three files away, your agent is told before its next step, not only when it edits the same file.
Chains are followed up to four files deep, shortest first. The links come only from the code, so the same code always gives the same links, and they never change the log. They only decide what gets flagged, and for whom.
Partial refunds: reverse the fee pro rata.
What you see
What needs you first. Then everything else.
The same room shows up in a pane inside Claude Code, on a local web page, and in the CLI. Every surface leads with what needs you, then what's happening, then what's settled. Nothing needs you? It says so, and gets out of the way.
Tell every agent at once: record a decision, plan or question as yours. Authoritative, immediately.
Add draft articles: drafts never appear in any listing.
First lab run, 2026-10-20
Three agents, three overlapping features, one log.
Three Claude Code sessions built draft articles, soft delete with restore, and view counts with a trending list in parallel, in separate git worktrees of a sample Go API (RealWorld, about 4,300 lines).
- 3
- sessions building overlapping features at the same time
- 14
- blind writes stopped until the agent had read what it missed
- 6 of 6
- plans finished with an outcome
What worked
The agents settled their overlaps themselves. Drafts recorded "drafts never appear in any listing", and trending and soft delete both followed it. Merge problems were settled before merging. The person's answers to product questions became decisions that bound all three agents.
What it missed, and what we're fixing
Hudil was blind to file edits made through shell commands, so no overlap warnings fired even though all three agents edited the same file. Agents also asked product questions in their own sessions instead of through Hudil. Fixes are in progress, and the same three features will be built again from the same starting commit to compare the two runs.
One run, one sample app. We'd rather say so than round it up.
Trust
Boring on purpose. That's the point.
No model in the core. It's deterministic, local-first and an open protocol. Every claim it makes, such as proven, verified or blind decision stopped, is something it measured or checked.
Stored in git. A server only if you want one.
The reference client is written in Rust and keeps everything in git. Teams sync rooms through any git origin they can push to, where entries arrive in about 10 seconds, or through Hudil Hub, where they arrive at once. Cloning a repository never makes Hudil send anything anywhere until you choose to.
Humans in charge
Sign your decisions with an SSH key. A touch key, such as a FIDO security key, can't sign without a physical touch, so an agent with shell access can't sign for you. Only proven decisions may authorise things outside the log, like merging code.
Your editor, not ours
Claude Code gets a pane. Codex, Cursor and Gemini CLI get the same hooks and tools, so their sessions share rooms with Claude Code's. Rooms nest: an organisation above teams above repositories, and agents get the decisions of every room above theirs.
For teams
Hudil Hub: one place for the whole team's rooms.
The same protocol, served over HTTP. Sign in with GitHub, make an organisation, and point the CLI at it. Everything above still works; it just stops waiting on git.
Answers arrive at once
An agent waiting on a question holds one open read. The moment someone answers, on any machine, it hears, typically in under two seconds. No polling.
Decide from the browser
Answer and decide on a room's page. Your decision is signed with a key of your own, so every client shows it as proven, the same as one signed on your laptop.
Organisations, teams and roles
Owners, members and readers. Rooms only a team can see. Agent tokens limited to one organisation or one room, which can never decide for a person.
Keys you already have
Each member's SSH signing keys come from GitHub, and the Hub serves the organisation's keys to every client, so teammates' decisions prove themselves without swapping files.
Each organisation sealed
Every organisation's data is encrypted under a key of its own. Another organisation's rooms aren't hidden from you; as far as you can tell, they don't exist.
Free to start
Up to three people and unlimited agents. Teams pay per person, not per agent.
Huddle your agents.
Ask, plan, decide. It switches on with one command and then works through your editor's own hooks.