CoordinatorLucid Coding for your agents

See how each agent read the problem, what it built, how a blind critic judged it and why, and what is running now.

  1. Situation and goal. Where the run stands, in one line, counted from its log.
  2. Needs you. The one question only you can answer, asked once, with the lead's pick marked Recommended.
  3. Units. Working, Needs you, and Waiting for h1, each linked to the unit it waits on, with its behaviours and evidence.
  4. Under the scan: the flow map. What waits on what across a release run, the critical path, and the issues and PRs each unit links.

Vibe coding is a feeling. Lucid Coding is knowing.

Agentic engineering is how a lot of software gets built now: agents write the code and people direct them. Lucid Coding is the practice of doing that with your eyes open. You know your system, your agents' thinking, and how each piece was built and judged.

Coordinator is built for that. It does not pick your stack or your screens. It brings the process: a bar agreed before the build, a critic who never grades its own work, hard stops in code, and a record of every step you can open in a browser.

Get the work done first. Speed and cost improve with time and experience, and each run's record is where that experience comes from.

Read the Lucid Coding manifesto

One loop, written down at every step

Every run follows the same six steps. Each one leaves an event in the run's log, so the dashboard can show it and a crash cannot lose it.

  1. Ask once

    The lead reads the project and the task, researches, staffs builders and critics from your harness's own agents, and asks every open question in one batch, its recommendation first. Then it runs without you.

  2. Agree the bar

    Each unit of work gets a bar a critic can check: behaviours written as given, when, then, a failing test that must pass, or a reference to match. Bar changes stay on the record.

  3. Build

    One fresh builder per unit, each in its own git worktree, in parallel where units are independent. Mechanical work can go to a cheaper model; critics and work on security, money, migrations and auth stay on the strong one. Each round records which model built it.

  4. Judge blind

    A separate critic, who never sees the builder's reasoning, checks the real result against the bar and marks each behaviour with evidence. A detector reads the diff for skipped tests, removed assertions and rewritten snapshots.

  5. Decide in code

    run.mjs next decides what happens to each unit: build again, change strategy, or stop. Round and time budgets, no-progress and same-cause detection are enforced by the script, and steps taken out of order are refused.

  6. Learn

    The retro turns repeated gaps into lessons quoted into the next run's briefs, tunes the budgets from past runs, and proposes changes to the skill for a person to review.

What you can see, at any moment

Real screenshots from real runs. Coordinator builds itself with Coordinator, so most of them are its own release runs.

What needs you, and what doesn't

A question comes once, with the lead's pick marked Recommended. Answer it here, from a phone, or in an issue comment. A unit waiting on another one says Waiting for A and links to it; only a real question for you turns amber and says Needs you.

A Needs you box on the dashboard of this site's own run: the question asks where the Install the skill button should lead, with This page marked Recommended, an Other field and a Submit button.

How it read the problem

The bar, as behaviours a critic can check one by one. Screenshots, test output and logs attach to the behaviour they prove, and run.mjs adopt copies them into the run before a worktree is deleted.

A unit's bar written as four behaviours, such as: given a 390 pixel phone, when the page loads, then the headline, the two buttons and the first visual fit with no sideways scroll. Two behaviours carry screenshots of this homepage as evidence.

How the critic judged it, and why

Every round keeps the builder's report, the critic's gap, its root cause and a score. Here a critic failed the model-routing unit three times, on three different gaps, and the script stopped it when its round budget ran out.

Three rounds of one unit. Each shows fail, a score of 4, 6 and 7, a cause tag, the builder's report with commit links, the gap and the critic's evidence. It ends with Stopped: budget: rounds.

Maps of the run, drawn from its log

Each map is drawn from the run's events, with no extra input. Every box carries a status mark, its id and title, so nothing depends on colour alone.

Flow map of a release run: eight units stacked left to right with waits-on arrows, the critical path in blue, and on the right the issues, pull requests and follow-on runs they link.
Flow. What waits on what, the critical path, the issues and PRs each unit links, and the runs that carried work on.
The flow map with unit c11 selected: its links are lit, the rest dimmed, and a panel shows a breadcrumb, Open unit, Up to parent and its three children.
Select and walk. Click or press Enter on a box to light its links, then walk the map with the arrow keys, one level at a time.
Mind map: the goal in the centre and eight units around it, passed units in green, stopped ones in grey.
Mind. The goal in the centre, then units, behaviours and evidence.
Activity by hour: one row per unit, one column per hour, darker cells for more activity and red cells for failed tries.
Heat. Where effort and churn went, per unit and hour. Red holds a failed try.
Goal relevance: the goal on the left, four units that serve it on the right, and one unit marked off goal with a dashed border.
Goal relevance. Which units serve the goal, so work off the goal stands out.
Function calls for the unit that added the run report: 121 functions touched in 24 files, a graph of who calls the first eight and what they call, and a table with file and line links.
Function calls. The functions a unit's diff touched, what calls them and what they call, with file and line links, read from the code at the unit's head commit. The project map beside it covers modules, shared helpers, settings keys, routes and screens.

While it runs, and after it ends

While it runs

Live dashboard
run.mjs serve serves it on 127.0.0.1 behind a token, updating in place as the run moves. A page per unit, timelines with search and filters, and Export PDF on every page.
Answer from anywhere
Answer the lead and add notes on the web dashboard, or with /coordinator answer q3 b in an issue or PR comment. Only people with push access can answer.
Alerts
Web push, email or a GitHub mention when a run needs you, a unit stops, a run finishes, a PR merges or checks go red. Quiet hours and digests per person.

Proof

Evidence and screenshots
Test output, screenshots, PDFs and links attach to the behaviour they prove, stored in the run with a checksum that doctor verifies. In web and Expo apps, pair with reins so builders and visual critics trigger typed actions, read app state, check lifecycle, component and API timings (reins_perf), inspect DOM and CSS layout (reins_dom) and snap panels by id instead of clicking by pixels. A reins_report in Markdown, attached to the unit, shows the critic what was slow, duplicated or clipped, front end and back end, and a before/after compare proves a speed-up with numbers.
Quality and compliance signals
The bar-gaming detector on every diff, a security pass in every code review, a specialist critic for risk areas, and run.mjs quality: duplication, long functions, nesting, naming, security and PDPL/GDPR privacy signals, each with the file and line to review. Signals for a person, not a certification.
A report for testers and operators
Each run gets a report page: what changed, with its PRs; for testers, steps and expected results; for whoever deploys, migrations, environment variables, scripts and jobs read from git; and the quality signals.

Memory

Follow-on runs
A unit stopped in one run and finished in the next keeps its history: --continues run:unit links them, and the stats count the chain as one unit.
Retro and lessons
A retro page per run lists its notes, the lessons it added, budgets and proposals. Repeated gaps become lessons quoted into the next briefs, past runs set the budgets, and a lesson seen three times is proposed as a change to the skill.
Which model did what
Each round records the model that built it and the one that judged it, and the stats give a pass rate per builder model.

Setup

Init and doctor
/coordinator:init learns the project once and asks where state goes, the theme, budgets, the merge rule and the hosted app. /coordinator:doctor checks the setup, one line per item with a fix.
Claude Code and Codex CLI
A plugin for Claude Code. In OpenAI Codex CLI, the skill folders plus a short AGENTS.md block; with no question tool there, questions go to the dashboard.
Self-host, or hosted
The web service is one container and Postgres with your own GitHub App. The hosted app is opening soon. Builders and critics always run on your machine.
Helper models
Offload tool summaries, fixed-list picks and screenshot pre-screens to a local model (Ollama, LM Studio) or a router (OpenRouter, OpenAI) with helper.mjs setup. Unsure answers escalate to the strong model; a helper never judges.
The report page's change list: five units with their status (stopped, pass, building) and the pull requests that merged them.
A run's report: what changed, unit by unit, with the PRs that carried it.
Code quality and compliance signals for the whole project: 0.3 percent duplication, one long file, 18 long functions, 23 deeply nested blocks, and security signals to review with their locations.
Quality and compliance signals for this repository, measured by run.mjs quality, each one for a person to check.
The coordinator's own page: pass rate 86 percent, rounds to pass 1, stopped 14 percent, 69 minutes per unit, a suggested max-rounds of 3, and a trend table over six runs.
The coordinator's own page: how it is doing across every run in the project, and what budget to set next.
Work across runs: units carried from one run to the next with tries and outcomes, then proposals from retro notes and follow-ups.
Work carried across runs, and the proposals each retro left for the next one.

Also in 1.1

  • Evidence viewer. Open any screenshot or log from the timeline in a scrollable viewer, step through them, open in a new tab.
  • Gaps view. Every open gap across runs on the coordinator's page, searchable, so nothing is forgotten.
  • Runs that end eagerly. Only real defects fail a round; small fixes get a quick check; you are asked once when one unit is left.
  • Local demo of the hosted app. npm run demo runs the web dashboard on your machine with your own runs.

Picking up a run

After a crash, a closed session or a week away, the run is still there. Every step is an append-only event log in .coordinator/runs/<run>/, with the questions you answered, the bar, every round and its evidence.

Work in flight is checked against its branch or output; a unit with nothing to show goes back to build. Start a new run for new work, and use --continues when it finishes a unit an earlier run left open, so that unit's history comes along.

  1. /coordinator:doctorchecks the setup first: Node, gh, settings, stale locks and dashboards
  2. /coordinator:statuswhere each run stands; the lead carries on with run.mjs next and does not ask your answers again
  3. run.mjs pull <run>on another machine: restores the run from the coordinator-state branch the lead pushed at its last pit stop; a public repo keeps it in a private stateRepo instead

Start a run today

Install the skill in Claude Code

/plugin marketplace add mindmakr/coordinator
/plugin install coordinator@coordinator

Then, in a project: /coordinator:init, then /coordinator:run Fix issue #142. Needs Node 18+ and git, nothing else. Add .coordinator/ to your .gitignore.

In OpenAI Codex CLI: copy the skill folders into .agents/skills/ and add the AGENTS.md block. Install guide

Self-host the service

Follow runs on the web, answer from a phone, and get alerts. One container and Postgres, with your own GitHub App.

Self-host guide

Hosted app: opening soon

The same service, run by us, free during the beta. What it reads and keeps: permissions and privacy.

Follow the hosted beta

Companion: reins for web & Expo

Give your agents hands and eyes inside your app: typed actions, state, DOM/CSS diagnostics and panel screenshots, and one timeline from the click through the server and database back to the screen. Session reports in Markdown become a critic's evidence; testers can export theirs for an agent to analyse. Stripped from production builds.

Explore reins