Running one coding agent is a personal productivity change. Running several at once is an organizational one. As soon as two agents touch the same repository, the hard part stops being the model and starts being coordination: what each agent plans to change, who approves it, how a human reviews the result, and how work passes from one agent to the next. The projects covered here all sit at that layer, above the individual agent and below the team, and most of them appeared on Hacker News in the last few weeks.
Seeing what is already running
The first problem is simply knowing what you have. Geiger is a read-only scanner that inventories every AI agent, harness, MCP server, plugin and AI extension on a machine, then explains in plain language what each one can touch. It runs with npx, has no dependencies, needs no account, sends no telemetry, and writes nothing unless you explicitly ask for a JSON export. That makes it a reasonable first step before adding anything else, because you cannot coordinate agents whose existence you have not inventoried.
A different kind of visibility comes from the review side. Critic is a narrative code-change viewer built for work written by coding agents. Rather than showing a raw diff, it presents each change as a before and after narrative, and it keeps questions about that change alive across disconnects. That matters more than it sounds when the author is an agent running on a laptop that has since gone to sleep.
Planning before anyone writes code
Once you know what is running, the next question is what each agent should do. Ordewell turns one goal into an editable plan of tasks, where each task can run with its own runner, model and mode, and you review and merge the results afterwards. The editable plan is the whole point: you correct the decomposition before tokens are spent rather than after the work is done.
Proliferate takes the parallel angle. It is an open-source AI IDE that runs Claude Code, Codex, OpenCode and other coding agents side by side, locally or in the cloud, and lets you save the workflows you repeat. If the unit of work you keep redoing is a sequence rather than a single task, this is the shape of tool you want.
AgentRun sits at the opposite end of the spectrum. It is a workflow DSL that adds scripted, repeatable workflows to the agents you already run: you define the steps once, use narrowly scoped decisions for the common path, and call a full agent only when the work genuinely needs investigation. Your application keeps its own tools, model access, permissions and budgets, which is the deciding factor if you are embedding this in a product rather than driving it from a terminal.
Collisions, intent and shared context
The most expensive failure mode is two agents making contradictory changes in separate worktrees. Foremerge is an open-source coordination protocol built above Git. Agents keep isolated worktrees while sharing intent, semantic claims, dependencies, provisional changesets and decisions, so a deterministic detector can surface collisions before they land. It installs by pasting one line into Claude Code, Codex or Cursor, and ships a CLI, a JSON API, an MCP server and a SQLite store.
Twing approaches the same problem from the review side. It turns coding agent conversations into shared context, extracts the design decisions behind a change, generates shared diagrams automatically, and compares what every coding agent plans to change so contradicting designs surface early instead of at merge time. It works with Claude Code, Codex and OpenCode and captures in the background after a single setup command.
Bise attacks the human cost rather than the merge cost. It is an open-source terminal app for multi-agent coding where you talk to one team-lead agent, which splits your ideas into jobs and runs the other agents for you. You stay in one thread instead of routing between tabs. Anyone who has typed some variation of "yes, continue" eleven times across three windows will recognize the fatigue it is aimed at.
For teams that want a persistent ecosystem rather than a per-task tool, Raven describes itself as the harness of harnesses: a persistent, self-evolving multi-agent ecosystem designed to sit above the harnesses you already use. It is ambitious and aimed at long-running work, so treat it as an experiment rather than infrastructure you depend on.
Scheduled and unattended work
Not every agent run starts with a human prompt. Moadim is an open-source loop engine: you define a loop with a prompt, a schedule and an agent, and it runs Claude, Codex, Hermes or Pi against your repository on every tick, in an isolated workbench with a watchdog on every run. Every loop is also an HTTP endpoint with OpenAPI and Swagger UI built into the daemon, and the same loops are reachable as MCP tools, which makes it unusually easy to drive from something else.
Closing the loop in production
Coordination does not end at merge. Selfship watches agentic applications in production: when many customers hit the same wall it finds the exact moment things go wrong and opens an eval-backed pull request, so nobody has to write a ticket by hand. After you merge, every fix is re-verified against real traffic. It is OpenTelemetry-native and framework agnostic, so it slots into tracing you already have instead of replacing it.
What to adopt first
If you are starting from a messy machine, begin with inventory and intent: Geiger to see what is installed, then Foremerge or Twing to stop agents from contradicting each other, and Ordewell if you want the plan reviewable before it runs. Add Proliferate or Bise once the bottleneck is your own attention rather than the agents themselves, and only reach for scheduled loops once the unattended path is genuinely safe.
