baro

baro turns one prompt into a pull request. You're in your repo, you type something like "add JWT auth with role-based access" or "write unit tests for every service under src/", and you walk away. When you come back there's a branch, a diff, and an open PR with a summary of what changed.

The thing that makes it different from the single-session coding tools (Claude Code, Cursor's agent, and so on) is that baro doesn't run one agent. It plans the goal into a dependency graph of small stories, then runs the independent ones in parallel — each story is its own agent in its own subprocess. There's no big orchestrator function in the middle calling the shots; every part of the run is a participant on a shared event bus (built on an open-source framework called Mozaik), and they coordinate by reacting to each other's events. That sounds academic, but the payoff is practical: adding a new behavior is just a new participant rather than a rewrite, and nothing bottlenecks when you push past a handful of concurrent agents.

A run has a small cast, and each one does exactly one job:

Architect makes the cross-cutting decisions up front — file paths, schema names, API shapes — and pins them, so thirty parallel agents don't each invent their own conventions.

Planner breaks the goal into the story DAG.

Story agents do the actual coding, in parallel, each on its own slice.

Critic grades every agent's work against the story's acceptance criteria each turn, and feeds corrections back in when something's off.

Librarian indexes what one agent discovers so its siblings don't re-explore the same files.

Sentry flags when two concurrent agents reach for the same file.

Surgeon re-plans on the fly when a story fails — splits it, adds a prerequisite, rewires the graph.

Finalizer runs your build, then opens the PR with a story table and stats.

You don't have to think about any of that — you type a goal and watch it happen in a live terminal UI (story status, agent logs, the DAG, token counts). But it's all there if a run goes sideways and you want to understand why.

One more thing that matters if you're cost-conscious: baro isn't locked to one model vendor. The `--llm` flag picks the backend for the whole run — Claude (through the Claude Code CLI, billed against a Claude subscription), OpenAI Codex (through the Codex CLI, billed against a ChatGPT subscription), or OpenAI's API directly. There's also a `--llm hybrid` preset that sends the cheap-but-careful upstream phases (Architect, Planner) to one model and the high-volume parallel coding work to another — on a real refactor that cut the subscription footprint to about a third of running everything on one premium model. Every phase has its own override flag if you'd rather mix it yourself.

A concrete run, so this isn't hand-waving: I pointed it at a NestJS service with one prompt — "write a full Jest unit suite for every service, controller, guard, listener, scheduler, mapper, decorator, filter, helper, and validator under src/." It planned 33 stories, ran them in parallel across three dependency levels, hit Anthropic's usage cap halfway through at 3am, paused, resumed in the morning, and finished: 808 tests, 83.5% branch coverage, 32 files, one PR. The quality gate filed zero phantom bug issues.

It shines on work that decomposes — test suites, multi-file features, mechanical refactors, anything where "many small parallel changes" beats "one careful sequential edit." For a one-line typo fix, use `--quick` (it skips the planning machinery and runs a single agent) or honestly just edit the file yourself. Every run writes a full audit log to `~/.baro/runs`, so when something breaks there's a trail.

Install is one line — `npm install -g baro-ai` — and you need at least one of the Claude CLI, the Codex CLI, or an OpenAI key signed in. It runs on macOS, Linux, and Windows, and it'll open the PR for you if you have the `gh` CLI. Source is on GitHub (jigjoy-ai/baro), docs at docs.baro.rs.

FAQ

Q: What is baro? A: baro is an autonomous parallel coding agent CLI that turns a single prompt into a pull request. Rather than running one agent in one session, baro plans the goal into a dependency graph of small stories and runs the independent ones in parallel — each story is its own agent in its own subprocess.

Q: How is baro different from Claude Code, Cursor, or Devin? A: Claude Code and Cursor's agent run a single sequential agent. Devin orchestrates one agent over multiple sessions. baro is the parallel-agent execution model — dozens of agents run concurrently against a story DAG, coordinated through a shared event bus rather than a central orchestrator. Result: faster wall-clock time on decomposable work (test suites, multi-file features, mechanical refactors).

Q: Which LLM does baro use? A: baro is not locked to one model vendor. The --llm flag picks the backend — Claude (via the Claude Code CLI), OpenAI Codex (via the Codex CLI), or OpenAI's API directly. There's also a --llm hybrid preset that uses different models for different phases to cut cost.

Q: Is baro open source? A: Yes — source is at github.com/jigjoy-ai/baro and docs at docs.baro.rs. Install via npm install -g baro-ai.

Q: When should I use baro vs single-agent tools? A: baro shines on work that decomposes — test suites, multi-file features, mechanical refactors. For a one-line typo fix, use --quick or just edit the file yourself. baro is purpose-built for "many small parallel changes" rather than "one careful sequential edit."

tl;dr

baro is the autonomous parallel-coding-agent CLI that turns one goal into a pull request. Plans the work into a story DAG, runs independent stories in parallel, coordinates via shared event bus. Works on Claude Code, OpenAI Codex CLI, or OpenAI API. Open-source (github.com/jigjoy-ai/baro). Built by Jigjoy AI in Serbia.