Ayman Dakir

Agent infrastructure

Made,deliberately.

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:

Selected work

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.

Speclock

Lock the spec, gate the merge. Intent becomes a machine-checkable contract, and CI refuses anything that drifts from it.

Control Tower

A local-first control plane for fleets of coding agents: watch and steer dozens of parallel runs from one screen. Read-only, no telemetry.

Cairn

An always-on memory backbone for a multi-agent operator. Semantic recall over a distributed vector index, with snapshot restore behind it.

It started because I kept losing track of my own agents.

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.

The models got good. The coordination did not.

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.

How I work

Run. Isolate. Build. Open.

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.

01Run

I put fleets of agents on real work every day, which is the only way the failures show up honestly.

02Isolate

Most of them trace back to the same few gaps: no shared state, no contract, nothing that remembers.

03Build

So I build the missing piece small and local-first, then use it on the very next run.

04Open

Whatever survives daily use gets documented and pushed public. The rest quietly gets deleted.

The one I keep coming back to

Agentbus.

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 protocol
01Folder

One shared folder is the whole substrate. No broker, no daemon, nothing to keep alive.

02Messages

Agents post to a bus instead of to each other, so nobody has to know who is listening.

03Board

Work gets claimed off a task board, so two agents never quietly take the same job.

04Trace

Every message stays on disk, which is what makes a run readable long after it finished.

Move your fleet up the levels.

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.

  • L1Chat. Prompting by hand, one window at a time. Useful, but nothing compounds.
  • L3Workflows. One job done the same way every run, with a person reviewing the diff.
  • L5Fleets. Many agents on many jobs at once, coordinating through a protocol instead of through you.

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.

From the lab

Second brain

Drop in any source and it gets read, linked and filed into one connected graph of plain Markdown you still own.

ClaudeObsidianMCP

Jarvis

A voice assistant that runs entirely on the machine it can operate, with the renderer kept as a separate subscriber.

Local-firstPython

The lobby

A lobby display where twenty-five AI collaborators share a pixel office, and you can watch the work move between them.

ClaudeNext.js

MCP servers

Small servers that hand an agent one clean set of tools: twelve for GitHub, another for the X API.

MCPRailway
Get in touch

Bring me something hard.

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.

© 2026