Four gold axes meeting at one point on a black background. Pairs of small agent shapes sit along each axis, and a chain of linked blocks runs back into the distance.
Four problems, one point where they meet, and a linked history where a quiet edit shows up.

AI agents produce plausible work fast. Plausible is not the same as proven. The moment you let several agents work together without a person watching every step, you need a way to trust what comes out the other end.

We call that the autonomous swarm problem. We split it into four smaller problems. Each one is a pair of forces that have to be kept in balance, and each one gets a rule we can write down and check.

The four problems

1. Maker and checker

Our rule is that no agent grades its own work. Where the pattern is in place, one agent makes something and a separate agent checks it, answering accept, revise or reject. The step only counts as done when the checker accepts it.

This is the long-standing four-eyes control from finance, applied to software agents. The person who raises a payment is not the person who approves it.

2. Who decides and who does

Agents do the work. People set the direction and approve the decisions that matter. Where an agent stops and a person takes over is a standing written rule, so it is not decided case by case by whoever is in the room.

The rule is simple: an agent can handle routine steps on its own, and a named person approves anything that spends money, cannot be undone, or goes out to a client.

3. Ours and theirs

Before we build anything, we look for what already exists. Public standards and proven open source tools come first, and our process is designed so we build only the part that is genuinely missing.

The same boundary protects clients. Our rule is that each client's data and documents are kept separate and are not shared with any other client, and we check the recipient before anything leaves. What carries from one project to the next is our own method and the lessons we learn, not a client's material.

4. Learning and applying

There are two ways to reason. You can learn a rule from what actually happened, or you can apply a rule you already trust to a new case. A swarm needs both. It learns from real results, writes the lesson down as a rule, and applies that rule the next time.

The lesson has to come from a real result, not from what an agent said it did.

Keeping history honest

All four rules depend on an honest record of what happened. If history can be edited quietly after the fact, every check above can be undone without anyone noticing.

So our research decision log is append-only and linked. Each new entry carries a fingerprint of the entry before it, the same chain-of-hashes idea the Bitcoin whitepaper uses for its timestamp server. If someone quietly changes or removes an entry that has later entries after it, the check fails and names the first entry that no longer fits. To hide the change, they would have to rebuild every entry after it. Cutting off the newest entries is not caught by the chain on its own.

That makes quiet edits easy to spot. It is not tamper-proof: Bitcoin adds proof-of-work and a network to stop a full rebuild, and our log does not. For checking our own work, spotting the edit is what matters.

Five stages, one pattern

This is the shape we are building every project toward: a maker and a checker at each of five stages, each matched to a public standard where one exists.

  • Discover: find where time and money really leak, checked with the person who has the need.
  • Design: turn that into a plan with acceptance criteria that can each be checked, confirmed by a separate checker before building starts.
  • Develop: build it, with a separate tester rerunning the tests before it counts as done.
  • Deploy: release it, check it live, and finish only when the client says it is fixed.
  • Dream: look back on what we learned and use it to improve our own methods.

What we have not solved

We have not removed people from the loop, and we do not think anyone should yet. A person still owns the direction and gives the final yes on anything that matters.

We also have not yet measured how much time or money this approach saves. That is our next step, and we will publish the numbers when we have them.

What the structure is built to give us is narrower and more useful than a promise of full autonomy: agents that do the volume of the work, a separate check on each step to catch their mistakes, and a record of who decided what and why. Today our research decisions are logged that way, and we are extending it to client projects.

What it means for a business

What we are building toward is fewer surprises: claims in a deliverable you can trace back to their source, a named owner for every important decision, and a record that shows where something went wrong instead of leaving you with a mystery.

If you are planning an AI build and want to talk through where the checks should sit, book a strategy call or start with our AI use case scorecard.