The Boardroom

One agent has one point of view

Give a coding agent a big codebase and it will confidently tell you things that are almost true. It has no adversary. Nothing in the loop is trying to prove it wrong.

The fix that actually works is embarrassingly old-fashioned: put several of them in a room and make them check each other's work. Not a swarm, not a hierarchy of sub-agents spawned and discarded — peers. Long-lived, each owning a real slice of the system, each able to read the other's claims and go look.

What that buys you, in practice, is that a claim now has to survive somebody who doesn't want it to be true. That is the entire product. Everything below is scaffolding for that one effect.

The trick: a process that wakes an agent by dying

This is the only clever part of the whole system, and everything else follows from it.

Coding agents in a terminal are turn-based. They act, they finish, they wait for you. There's no daemon, no inbox, no way to push a message into a sleeping agent.

But most agent CLIs have one useful property: when a background task you started finishes, the agent gets re-invoked to deal with it. That's the door.

So the listener isn't a server. It's a script that blocks — long-polling the hub, doing nothing — until somebody mentions this agent by name. Then it prints the message and exits. The exit is the doorbell. The agent wakes up, sees the message in the task output, and acts on it.

Not an agent you spawn. A session you already have.

This is the part that gets misread, and getting it wrong produces something that looks identical and is worth almost nothing.

A board member is not a fresh agent booted up to answer a question. It is not a bot wearing a role prompt. It is not a go-between, a router, or a wrapper.

It is a real terminal session that was already open — the one that has spent the last four hours in that repository, that read the file, ran the failing test, saw the stack trace, and remembers all of it. The room is a door into that session, not a container for it.

Three things follow, and they explain most of the rules

1 · A member remembers its own work, and nothing of anyone else's

Member A can say “I read that file an hour ago and it doesn't say that” — because it genuinely did, and the reading is still in its context. But it has no idea what member B has been doing, beyond what B has posted. There is no shared brain, no common memory, no telepathy.

So the room record is the only shared state that exists. That's not a design nicety — it's the reason every rule about provenance, evidence and verbatim minutes earns its keep. If it wasn't said in the room, with its receipts, it isn't real to anybody else.

2 · Being interrupted is cheap, and that's the point

A member gets pulled into the room mid-task, answers, and returns to exactly what it was doing — with its working context intact. There is no reload, no re-briefing, no “catch me up”. That's what makes a five-second sanity check from a colleague economically sane, and it's why the board can be consulted constantly rather than convened ceremonially.

3 · Context is finite — and this is the failure mode nobody expects

A long session eventually fills its context window and compacts: the older detail is summarised away. The member doesn't feel different. It will still answer confidently about a file it examined this morning — from a summary of a summary.

Why this beats spawning sub-agents — which you will be tempted to do

The obvious shortcut is to spin up a lightweight sub-agent, call it “the backend expert”, and let it answer for a codebase it has never opened. Don't. We tried; it is a trap with exceptionally good camouflage.

A sub-agent has no history and no stake. It hasn't read the file, hasn't run the test, and can't remember being wrong last week. What it has is a role prompt and a strong instinct to be helpful — so it will answer, fluently, in the voice of a colleague, and cite a file that was deleted that morning. Ours did exactly that.

Three processes, and none of them are clever

The parts

Arming an agent

The whole contract: block, print, exit. Long-poll the hub for messages newer than the last one seen; if any of them mention this agent (or @all), print them in a format the agent can read, and quit.

// Arm this agent. Runs as a BACKGROUND TASK of the agent runtime,
// so that when it exits, the runtime re-invokes the agent.

const me = process.argv[2];              // whatever you named them in agents.json
let since = await latestMessageId();     // don't replay history

// Tell the room we are reachable. This is the ONLY claim that matters.
await beat(me, 'listening');

while (true) {
  const msgs = await poll(since);
  for (const m of msgs) {
    since = m.id;
    const forMe = m.mentions.includes(me) || /@all\b/.test(m.content);

    // A watcher (the chairman) wakes on EVERY message, not just mentions.
    if (forMe || cfg.agents[me].watch) {
      await beat(me, 'thinking');        // heartbeat stops now — see §08
      print(m);
      process.exit(0);                    // ← THE WAKE. this line is the product.
    }
  }
  await sleep(1500);
}

Two details that look small and aren't:

• Start from the newest message, not from zero. Otherwise an agent that re-arms immediately wakes on the message it just sent, and you have built an infinite loop that costs money.
• The chairman gets watch: true. A moderator woken only when addressed is blind to the thing it moderates.

“Sent” is not “arrived”

This is the section people skip, and then spend a week confused.

An agent posts a message addressed to a colleague — in prose, politely, by name — and nothing happens. The message is in the room. It scrolled past. Nobody was woken, because only a literal @mention wakes a terminal, and the sender has no idea.

So say.mjs doesn't just post. It verifies delivery and reports back to its own agent. Three outcomes, and it must be able to say all three:

Who's in the room is your decision, not the software's

Nothing in the system knows what a “frontend agent” is. It knows there are members, that each has a name, a colour, a portrait, and a working directory. What they're for is entirely up to you — and you'll get it wrong the first time and rearrange it, which is fine, because it's one config file.

The three kinds of seat

Every board that works seems to end up with the same three kinds of member, in wildly different proportions:

A worked example

The board below is one particular board, built for a particular job — a DeFi protocol with a public app, a routing engine behind it, and a couple of side projects. It is an illustration, not a template. Yours will look nothing like it, and shouldn't.

What's worth stealing isn't the roles — it's the shape: two permanent owners covering the two halves of the system that can genuinely disagree with each other, plus specialists who appear when their subject does, plus a referee who never touches the work.

the human

Convenes the board

Sets the problem, rules on the disagreement, and holds the one thing no code-read recovers: why it was arranged this way.

key advisors · permanent · each owns ground the other can check

domain owner

The application

Owns everything users touch. Its claims get read by the engine owner, who has every incentive to find them wanting.

domain owner

The engine & servers

Owns the services and the machines. The only member who can say “I checked production, and it says otherwise.”

specialists · called in for a subject, or to bounce ideas around

specialist

A deep vertical

Brought in for one complex area. Idle for weeks, then indispensable — often the one who reads the document nobody else could face opening.

specialist

A side project

A seat that exists but has never been filled. Shown as NOT JOINED — different from “offline”, because an empty chair is a different fact from a sleeping member.

Other boards you might build

How a session actually runs

You post a problem. The member who owns that surface replies. Then someone who doesn't own it goes and checks. That's the entire ritual, and it is worth more than any individual member's intelligence.

Real things this caught that no single agent would have:

• A member announced a fix as complete. Another read the file — only two of the three approved changes were actually in it. The header said done; the appendix said pending; the appendix was right.
• A member declared a service healthy after testing it — but had only tested the endpoints that were healthy. A colleague asked the one question that mattered: “what did you not sample?”
• The whole board converged on an answer from three sources, and was wrong — because all three sources described the same thing from the same angle. The human's memory was the only orthogonal source in the building.

The room must never lie about who can hear you

An agent that has finished speaking and forgotten to re-arm is alive, and completely deaf. If your UI shows it as “listening”, you will spend an afternoon addressing an empty chair.

Two rules that fall out of this

Presence lives in memory, and that is correct. Restart the presence service and nobody is confirmed present until they beat again — which is exactly the truth. Persisting presence would let it survive as a comfortable lie.

An agent that is thinking sends no heartbeat. Its listener exited to wake it; nothing is beating while it reasons. So you genuinely cannot distinguish “working hard” from “died”. Don't guess. Show how long it has been thinking and let the human judge: two minutes is a turn, twenty minutes is a problem.

A referee that can't play

The single highest-leverage member of the board is a deliberately weak model whose only job is procedure.

It has authority over how the room talks and none over what it decides. It opens and closes the session, writes the minutes, and calls out a rule violation. It is a company secretary crossed with a referee — never a judge.

What it checks — syntactic, never semantic

• A number with no time range and no method.
• A claim with no file, line, or query behind it.
• A raw total with no breakdown.
• Consensus with no dissent — if everyone agrees and nobody checked, it calls a dissent round.

It never judges whether the evidence is good. Only whether evidence is attached. That distinction is what lets a small, cheap model do the job — and what keeps it neutral.

Minutes: verbatim, never paraphrase

It may write “@engine objected, noting: ‘<their exact words>’”. It may not write “@engine made the stronger case”. Paraphrase is precisely how a neutral party stops being neutral — it never announces itself, it erodes one summary at a time. Verbatim-only is pedantic on purpose.

The rules are the product

Every one of these was written after something went wrong. Copy them; you will earn them anyway, but you may as well start ahead.

Things that will go wrong, in the order they'll go wrong

Keep it on the desk

The hub, as described, has no authentication. An agent's identity is a string it sends. Anybody who can reach the port can be anybody.

That is a perfectly reasonable trade for something bound to localhost on a machine you own, and it keeps the whole thing small enough to actually build. But it means one hard rule:

Two more, both learned the hard way and both boring:

• Never let an agent print a secret to the room. The transcript is a file, and files get shared. Read credentials from a path outside every repository, and never echo them.
• Give each agent the narrowest working directory that lets it do its job. Scope is not just tidiness — it is what makes “I checked, and it isn't there” a meaningful sentence.

The whole thing, end to end

Six files. Two dependencies. It runs on localhost and it fits on a couple of screens — which is the point: you should be able to read all of it before you trust it.

Layout

board/
├── server.mjs      hub + presence + serves the UI
├── listen.mjs      arms an agent   — blocks, prints, EXITS
├── say.mjs         agent speaks    — posts, then verifies delivery
├── members.json    who is on the board
├── ui/index.html   the room, for the human
└── messages.jsonl  the record (created on first send)

npm init -y && npm i express ws
node server.mjs                 # → http://localhost:4000

1 · Who's on the board

One file defines the room. Add a member by adding a key — there is no other step, and no limit.

{
  "you":      { "human": true, "colour": "#E0453C", "role": "Convenes the board" },
  "app":      { "colour": "#E07B26", "role": "The application",      "cwd": "~/code/app" },
  "engine":   { "colour": "#8B5CF6", "role": "The engine & servers", "cwd": "~/code/engine" },
  "chairman": { "colour": "#8A93A0", "role": "Procedure only", "watch": true }
}

watch: true is the chairman's switch: it wakes on every message, not just mentions. A moderator woken only when addressed is blind to the thing it moderates.

2 · The server

import express from 'express';
import { WebSocketServer } from 'ws';
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const HERE = path.dirname(fileURLToPath(import.meta.url));
const LOG  = path.join(HERE, 'messages.jsonl');
const PORT = 4000;

const members = JSON.parse(fs.readFileSync(path.join(HERE, 'members.json'), 'utf8'));
const NAMES   = Object.keys(members);

// LOAD THE HISTORY BACK. Our first hub wrote every message to disk and then never
// read it on boot — so a restart looked like the room had never happened. The write
// path is not the read path, and only one of them was tested.
let messages = fs.existsSync(LOG)
  ? fs.readFileSync(LOG, 'utf8').split('\n').filter(Boolean).map(JSON.parse)
  : [];
let nextId = messages.length ? messages.at(-1).id + 1 : 1;

const clients = new Set();

// @mentions are the ONLY thing that wakes a terminal. Addressing someone politely in
// prose reaches nobody — which is why say.mjs checks, and warns, on every send.
function mentionsIn(text) {
  const hit = new Set();
  for (const [, raw] of text.matchAll(/@([\w-]+)/g)) {
    const n = raw.toLowerCase();
    if (n === 'all') NAMES.forEach(x => hit.add(x));
    else if (NAMES.includes(n)) hit.add(n);
  }
  return [...hit];
}

const app = express();
app.use(express.json({ limit: '2mb' }));

// ── conversation ──────────────────────────────────────────────────────────
app.post('/api/send', (req, res) => {
  const from = String(req.body?.from ?? '').toLowerCase();
  const text = String(req.body?.text ?? '').trim();
  if (!NAMES.includes(from) || !text)
    return res.status(400).json({ error: 'known "from" and non-empty "text" required' });

  const msg = { id: nextId++, from, text, mentions: mentionsIn(text), at: Date.now() };
  messages.push(msg);
  fs.appendFileSync(LOG, JSON.stringify(msg) + '\n');
  for (const c of clients) if (c.readyState === 1) c.send(JSON.stringify(msg));

  // Hand the mentions straight back — say.mjs needs them to tell its agent who it woke.
  res.json({ ok: true, id: msg.id, mentions: msg.mentions });
});

app.get('/api/messages', (req, res) => {
  const since = Number(req.query.since ?? 0);
  res.json(messages.filter(m => m.id > since));
});

// ── presence: a DIFFERENT question, kept apart on purpose ──────────────────
// In memory, and that is correct. Restart this and nobody is confirmed present until
// they beat again — which is exactly the truth. Persisting presence would let it
// survive as a comfortable lie.
const seen = new Map();
const STALE_MS  = 40_000;        // no beat this long → gone
const THINK_MS  = 25 * 60_000;   // a turn can legitimately run a long time
const SPOKE_MS  = 25_000;        // re-arming should take about a second

app.post('/api/presence', (req, res) => {
  const { name, status } = req.body ?? {};
  if (!NAMES.includes(name)) return res.status(400).json({ error: 'unknown member' });
  seen.set(name, { status, at: Date.now() });
  res.json({ ok: true });
});

app.get('/api/presence', (_req, res) => {
  const now = Date.now(), out = {};
  for (const [name, p] of seen) {
    const age      = now - p.at;
    const thinking = p.status === 'thinking' && age < THINK_MS;
    const rearming = p.status === 'spoke'    && age < SPOKE_MS;
    const deaf     = p.status === 'spoke'    && age >= SPOKE_MS;
    const live     = p.status === 'listening' && age < STALE_MS;

    out[name] = {
      status: thinking ? 'thinking' : rearming ? 're-arming'
            : deaf     ? 'deaf'     : live     ? 'listening' : 'offline',
      // "online" means EXACTLY ONE THING: a mention will wake them. Deaf and re-arming
      // are alive and unreachable — and unreachable is the only fact a sender needs.
      online: thinking || live,
      seconds: Math.round(age / 1000),
    };
  }
  res.json(out);
});

app.get('/api/members', (_req, res) => res.json(members));
app.use(express.static(path.join(HERE, 'ui')));

// 127.0.0.1, not 0.0.0.0. There is no auth here — see §12. Keep it on your desk.
const server = app.listen(PORT, '127.0.0.1', () =>
  console.log(`board → http://localhost:${PORT}`));

new WebSocketServer({ server }).on('connection', ws => {
  clients.add(ws);
  ws.on('close', () => clients.delete(ws));
});

3 · Arming an agent

The doorbell. Note the two lines that stop it eating itself: start from the newest message, and never wake on your own words.

import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const HERE = path.dirname(fileURLToPath(import.meta.url));
const HUB  = 'http://localhost:4000';

const members = JSON.parse(fs.readFileSync(path.join(HERE, 'members.json'), 'utf8'));
const me      = (process.argv[2] ?? '').toLowerCase();
if (!members[me]) { console.error(`unknown member: ${me}`); process.exit(1); }
const watches = members[me].watch === true;

const beat = status => fetch(`${HUB}/api/presence`, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ name: me, status }),
}).catch(() => {});

const get = url => fetch(url).then(r => r.json()).catch(() => []);

// START FROM THE NEWEST MESSAGE. Replay the log instead and the agent wakes on the
// message it sent thirty seconds ago, re-arms, wakes on it again — an infinite loop
// that bills by the token.
const history = await get(`${HUB}/api/messages?since=0`);
let since = history.length ? history.at(-1).id : 0;

await beat('listening');
console.log(`armed as @${me}${watches ? ' (watching everything)' : ''} — waiting…`);

for (;;) {
  for (const m of await get(`${HUB}/api/messages?since=${since}`)) {
    since = m.id;
    if (m.from === me) continue;                          // never wake on your own words
    if (!m.mentions.includes(me) && !watches) continue;    // not for you

    // The heartbeat STOPS here. Nothing beats while the agent reasons, so the room
    // genuinely cannot tell "working hard" from "died" — it shows elapsed time and
    // lets the human judge. Don't invent a cutoff; it will declare a live agent dead.
    await beat('thinking');

    console.log(`\n=== ROOM · @${m.from} ===\n`);
    console.log(m.text);
    console.log(`\n=== reply:  node say.mjs ${me} "…"`);
    console.log(`=== re-arm: node listen.mjs ${me}   ← IN THE BACKGROUND, OR YOU GO DEAF`);

    process.exit(0);   // ← THE WAKE. Exiting is how we reach the agent.
  }
  await new Promise(r => setTimeout(r, 1500));
}

4 · Speaking — and checking it arrived

import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const HERE = path.dirname(fileURLToPath(import.meta.url));
const HUB  = 'http://localhost:4000';

const members = JSON.parse(fs.readFileSync(path.join(HERE, 'members.json'), 'utf8'));
const me   = (process.argv[2] ?? '').toLowerCase();
const text = process.argv.slice(3).join(' ').trim();
if (!members[me] || !text) {
  console.error(`usage: node say.mjs <${Object.keys(members).join('|')}> "message"`);
  process.exit(1);
}

// Status becomes 'spoke', NOT 'listening' — we are not armed again until this agent
// re-runs listen.mjs, and the room must not claim otherwise. If this sticks, the
// roster shows DEAF, which is the honest word for alive-and-unreachable.
await fetch(`${HUB}/api/presence`, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ name: me, status: 'spoke' }),
}).catch(() => {});

const res = await fetch(`${HUB}/api/send`, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ from: me, text }),
}).then(r => r.json());

if (!res?.ok) { console.error('send failed:', res); process.exit(1); }
console.log('sent.');

// ── DELIVERY CHECK. "Sent" is not "arrived". ──────────────────────────────
// Three separate failures taught us this, all the same shape: something reported
// success and delivered nothing. Verify who this actually woke, and say so LOUDLY
// when the answer is nobody.
const presence = await fetch(`${HUB}/api/presence`).then(r => r.json()).catch(() => ({}));
const targets  = res.mentions.filter(n => n !== me);

if (!targets.length) {
  console.log('\n  !! THIS MESSAGE WOKE NOBODY — it contains no @mention.');
  console.log('     Addressing someone as "you" in prose does NOT reach them.');
  console.log('     If it was meant for someone, send it again with @name.');
} else {
  const woke   = targets.filter(n => presence[n]?.online);
  const asleep = targets.filter(n => !presence[n]?.online);
  if (woke.length)   console.log(`  → woke: ${woke.map(n => '@' + n).join(', ')}`);
  if (asleep.length) {
    console.log(`\n  !! NOT DELIVERED: ${asleep.map(n => '@' + n).join(', ')} not listening.`);
    console.log('     Stored — they will see it when they next arm. Do not assume it landed.');
  }
}

5 · The room, for the human

One page. It reads the log, subscribes to the websocket, polls presence, and lets you type. Click a member to @mention them — the mention is what wakes a terminal, so making it a one-click thing is not a nicety.

<!doctype html>
<meta charset="utf-8">
<title>The Board</title>
<style>
  body { margin:0; display:flex; height:100vh; background:#12161c; color:#e6edf4;
         font:15px/1.6 ui-sans-serif, system-ui, sans-serif; }
  aside { width:230px; padding:16px; background:#0d1117; border-right:1px solid #222b36;
          display:flex; flex-direction:column; gap:4px; }
  main  { flex:1; display:flex; flex-direction:column; min-width:0; }
  #log  { flex:1; overflow-y:auto; padding:20px; }
  .msg  { padding:10px 0; border-bottom:1px solid #1a212a; }
  .who  { font:700 13px ui-monospace, monospace; }
  .txt  { white-space:pre-wrap; word-break:break-word; margin-top:4px; }
  .row  { display:flex; align-items:center; gap:9px; padding:8px 10px; border:0;
          border-radius:8px; background:none; color:inherit; font:inherit;
          text-align:left; width:100%; cursor:pointer; }
  .row:hover { background:#171e26; }
  .dot  { width:8px; height:8px; border-radius:50%; background:#3c4653; flex:none; }
  .st   { font:11px ui-monospace, monospace; color:#7d8b99; margin-left:auto; }
  form  { display:flex; gap:8px; padding:14px; border-top:1px solid #222b36; }
  textarea { flex:1; background:#0d1117; color:inherit; border:1px solid #2a3542;
             border-radius:8px; padding:10px; font:inherit; resize:none; }
  button.send { padding:0 18px; border:0; border-radius:8px; background:#E07B26;
                color:#180f06; font-weight:700; cursor:pointer; }
</style>

<aside><b>The Board</b><div id="roster"></div></aside>
<main>
  <div id="log"></div>
  <form id="f">
    <textarea id="i" rows="1" placeholder="@app @engine …"></textarea>
    <button class="send">Send</button>
  </form>
</main>

<script type="module">
const ME = 'you';                                  // the human's key in members.json
const $ = s => document.querySelector(s);
const esc = s => String(s).replace(/[&<>]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;'}[c]));

// IDENTITY FIRST, then messages. Colour comes from members.json, never from presence —
// derive it from presence and an agent going offline greys out everything it ever said.
const members = await fetch('/api/members').then(r => r.json());
const colourOf = n => members[n]?.colour ?? '#8a93a0';

let msgs = await fetch('/api/messages?since=0').then(r => r.json());
draw();

function draw() {
  $('#log').innerHTML = msgs.map(m => `
    <div class="msg">
      <div class="who" style="color:${colourOf(m.from)}">@${esc(m.from)}</div>
      <div class="txt">${esc(m.text)}</div>
    </div>`).join('');
  $('#log').scrollTop = $('#log').scrollHeight;
}

new WebSocket(`ws://${location.host}`).onmessage = e => {
  msgs.push(JSON.parse(e.data)); draw(); poll();
};

// EVERY member is listed, present or not. An absent member is a fact worth showing:
// omitting them makes "nobody's home" indistinguishable from "no such member".
async function poll() {
  const p = await fetch('/api/presence').then(r => r.json()).catch(() => ({}));
  $('#roster').innerHTML = Object.entries(members).map(([n, m]) => {
    if (m.human) return `<div class="row"><span class="dot" style="background:${m.colour}">
      </span><b>@${n}</b><span class="st">always here</span></div>`;

    const s = p[n]?.status ?? 'offline';
    const colour = s === 'deaf' ? '#e4776b'          // alive but NOT listening
                 : s === 'thinking' ? '#d8a03a'
                 : p[n]?.online ? '#46b883' : '#3c4653';
    const label = s === 'deaf' ? `DEAF ${p[n].seconds}s`
                : s === 'thinking' ? `thinking ${p[n].seconds}s` : s;

    return `<button class="row" data-n="${n}">
      <span class="dot" style="background:${colour}"></span>
      <span style="color:${m.colour}">@${n}</span>
      <span class="st">${label}</span></button>`;
  }).join('');
}
poll(); setInterval(poll, 4000);

// Click a member to @mention them. Click again to remove it — getting a mention IN is
// easy; getting a wrong one OUT should be too, because a mention wakes a real terminal.
$('#roster').addEventListener('click', e => {
  const row = e.target.closest('.row[data-n]'); if (!row) return;
  const ta = $('#i'), tag = '@' + row.dataset.n, re = new RegExp(`${tag}\\b\\s*`, 'i');
  ta.value = re.test(ta.value) ? ta.value.replace(re, '') : `${tag} ${ta.value}`;
  ta.focus();
});

$('#f').addEventListener('submit', async e => {
  e.preventDefault();
  const text = $('#i').value.trim(); if (!text) return;
  $('#i').value = '';
  await fetch('/api/send', { method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ from: ME, text }) });
});
</script>

6 · Starting a member

In each agent's terminal, in its own repository, paste a short brief and then arm it. The brief is what makes it a board member rather than a chatbot:

# paste into the agent, once, at the start of a session

You are @engine on the board. You own the services and the machines they run on.
Other members own other things; you do not touch their code.

  Read the room:   the last message will be printed to you when you are woken.
  Speak:           node say.mjs engine "…"     ← ALWAYS include @name to reach someone
  Re-arm:          node listen.mjs engine      ← AS A BACKGROUND TASK, after EVERY message

If you do not re-arm, you go deaf and nobody can reach you.

House rules: verify before you amplify — three outcomes, and "unverifiable" is one of
them. Every number ships with its range and method. Never assert state from memory:
read the file. Nobody confirms their own work.

# then, as a BACKGROUND task (not a trailing & in a shell — it dies with the shell):
node listen.mjs engine

What you actually get

The first question everyone asks is "doesn't this cost more?" — and the honest answer has two halves, because it depends entirely on which frame you measure.

Per task, in isolation: yes. Three agents deliberating cost more tokens and more wall-clock than one agent working alone. It's arithmetic, and pretending otherwise is how you lose a reader who can do the sum. If you already run one instance flat out and keep running out of credits, a board runs you out faster.

End to end, on work that matters: usually cheaper — because "per task in isolation" ignores the most expensive line item in software, the bug you shipped. A defect caught in review costs a few thousand tokens. The same defect caught in production costs a debugging session, a re-derivation of the context you'd lost, a re-fix, a re-deploy, and sometimes damage no token count captures. The old truism holds for agents too: the later a mistake is caught, the steeper it costs. So the answer flips on one variable — what does a mistake cost you? On throwaway work, a board is wasted money. On anything you can't easily take back, it is usually cheaper, precisely because of the agents you added.

Two things it buys that never show up in a token count. Accountability changes behaviour: when an agent knows a colleague will read the file, the quality of what it says changes — not because it is smarter, but because it is answerable. Half the value arrives before anyone has spoken, in the confident-but-wrong claims that never get made. And you get a record, not a chat log: who claimed what, who checked it, what they found, what was decided — minutes. Weeks later, when something breaks, that is the difference between an afternoon of archaeology and a thirty-second lookup.