Agentbus
A message bus and task board for teams of agents, running on nothing but a shared folder. An open protocol, with no broker to stand up.
Ayman Dakir
Agent infrastructure
I build infrastructurefor fleets of AI agents
Protocols, control planes and memory backbones for multi-agent systems.
A short point of view on what actually breaks once you run agents in numbers — and on the part nobody has solved yet. First, some work:
A message bus and task board for teams of agents, running on nothing but a shared folder. An open protocol, with no broker to stand up.
Lock the spec, gate the merge. Intent becomes a machine-checkable contract, and CI refuses anything that drifts from it.
A local-first control plane for fleets of coding agents: watch and steer dozens of parallel runs from one screen. Read-only, no telemetry.
An always-on memory backbone for a multi-agent operator. Semantic recall over a distributed vector index, with snapshot restore behind it.
Where this comes from
I run coding agents on real work every day, and not one at a time. Somewhere past the fifth parallel run it stopped being a productivity story and started being an operations problem: who is working on what, who already tried this, and which one of them quietly broke the build.
The failures were almost never about the model. They were the old, boring ones — two workers claiming the same job, no shared state, no record of what happened, nothing that remembered yesterday.
Those are solved problems in every other kind of distributed system. They just had not been carried over yet. So that is the work: the unglamorous plumbing underneath, built small enough that it runs on a laptop.
What changed
One agent on one well-scoped task is close to a solved problem. It reads the codebase, writes the patch, runs the tests, and it is right often enough to be worth the tokens.
Put twenty of them on the same repository and none of that helps. What you have is a distributed system with no protocol, staffed by workers that are confident, fast, and completely unaware of each other.
Brilliant at
Doing the work. Reading context, writing the patch, and getting a credible first version in front of you in minutes.
Hopeless at
Knowing what the others are doing, admitting when a job is already taken, or remembering any of it tomorrow.
So the interesting problem moved. It is not prompting any more — it is state, ordering and memory, which is a much older set of questions with much better answers.
Nothing here was designed on a whiteboard. Each piece exists because a fleet broke the same way three times in a row and I got tired of babysitting it.
I put fleets of agents on real work every day, which is the only way the failures show up honestly.
Most of them trace back to the same few gaps: no shared state, no contract, nothing that remembers.
So I build the missing piece small and local-first, then use it on the very next run.
Whatever survives daily use gets documented and pushed public. The rest quietly gets deleted.
A message bus and a task board for teams of agents, running on nothing but a shared folder. No broker, no daemon, no service to keep alive — which means it works the same on a laptop as it does in CI.
Read the protocolOne shared folder is the whole substrate. No broker, no daemon, nothing to keep alive.
Agents post to a bus instead of to each other, so nobody has to know who is listening.
Work gets claimed off a task board, so two agents never quietly take the same job.
Every message stays on disk, which is what makes a run readable long after it finished.
Where most teams actually are
Almost everything I have learned here came from running this daily rather than from reading about it, and most of it turns out to be teachable. The tools are the easy part to copy. The operating model is not.
It starts with being honest about where you are. Adoption has levels, a bit like self-driving cars: at one end someone is pasting prompts into a chat window, at the other a fleet runs whole jobs and coordinates without a human in the middle.
Most teams who ask for L5 want L3 and would be delighted by it. Skipping the middle is how you end up with an expensive mess and no idea which agent made it.
Anyone can run one agent. Almost nobody can run fifty.
One agent on one task is close to a solved problem. The moment twenty of them touch the same repository, the questions stop being about prompting and start being about ordering, consensus and state — which is a much older field.
Drop in any source and it gets read, linked and filed into one connected graph of plain Markdown you still own.
A voice assistant that runs entirely on the machine it can operate, with the renderer kept as a separate subscriber.
A lobby display where twenty-five AI collaborators share a pixel office, and you can watch the work move between them.
Small servers that hand an agent one clean set of tools: twelve for GitHub, another for the X API.
Most of this ends up public sooner or later, so the fastest way to see how I work is to read the code rather than take my word for it. Issues and pull requests are open.