Loren Lisk

One Agent Asks, Several Agents Agree

AI Consensus Prototype Dec 2025

What it is

ai-consensus-poc is a prototype built in December 2025. A Go brain service takes a prompt, uses Claude to break it into subtasks, and fans those subtasks out to a pool of child Claude agents. The children are a single Kubernetes Deployment, so adding more is a matter of scaling its replicas. Each child sends its answer back to the brain, which reviews the results and either synthesizes a final answer or sends out refined questions for another round. It keeps iterating until the children reach consensus, capped at 10 iterations.

How consensus works

The brain does not wait for every child. It waits for a quorum: a majority of the children it handed subtasks to that round must respond before it moves on. It then runs a 4-step analysis over the responses:

  1. Identify claims - pull the key claims out of each child's response
  2. Compare agreement - check how far those claims line up across children
  3. Evaluate consensus strength - grade it as strong consensus, weak consensus or no consensus
  4. Decide the next step - synthesize the final answer, or write refined questions that target the disagreements and start another iteration

Architecture

                  prompt
                    |
                    v
       +-------------------------+
       |          BRAIN          |<-----------------------+
       |  1. plan subtasks       |                        |
       |  2. wait for quorum     |                        |
       |  3. review: 4-step      |                        |
       |     consensus analysis  |                        |
       +------------+------------+                        |
                    |  subtasks                           |
      +-------------+-------------+-------------+         |
      |             |             |             |         |
      v             v             v             v         |
 +---------+   +---------+   +---------+   +---------+    |
 | child-1 |   | child-2 |   | child-3 |...| child-N |    |
 +----+----+   +----+----+   +----+----+   +----+----+    |
      |             |             |             |         |
      +-------------+------+------+-------------+         |
                           |                              |
                           +---- results -----------------+

        no consensus yet? refined questions go back out
        (at most 10 iterations), otherwise final answer

Stack

  • Go services - a brain orchestrator and a child agent service, calling Claude through the Anthropic Go SDK
  • Event bus - an internal bus that broadcasts messages, node and edge updates, task start and end, and iteration events
  • WebSocket hub - streams those events live to the dashboard
  • React dashboard - an IRC-style communication log next to a neural-network graph view of the brain and its children
  • Per-child model selection - click a child node in the graph to pick which Claude model it runs
  • Kubernetes - manifests for the brain, the child Deployment and the dashboard
  • SOPS - secrets kept encrypted in the repo

Screenshots

One run of the sample prompt "What are three interesting facts about the moon?" against three children.

Idle dashboard: an empty task prompt, the neural-network graph with the brain and three idle child nodes, and a communication log showing only the WebSocket connection.
Idle: the brain and three children registered, waiting for a task.
Dashboard while processing: the brain has split the moon question into three subtasks, one per child, and all three child nodes glow green in the graph.
Processing: the brain plans subtasks and hands one to each child.
Second iteration: the brain logs that the children covered different aspects with too little overlap, starts iteration 2 and sends each child a refined question.
Iteration 2: the answers did not overlap enough to count as consensus, so the brain sends out refined questions.
Later in the run: the children back to idle and a long child answer on the formation of the moon in the log, while the task panel shows a polling timeout.
Late in the run: children idle again, long answers in the log, and the task panel's own poll timed out first. It is a prototype.

Source

The code, manifests and setup notes are on GitHub: github.com/liskl/ai-consensus-poc.

"If I had more time, I would have made this shorter."

Top Of Page