// baro.rs

baro

Backgroundagentruntimeorchestrator

Type a goal in your repo. Walk away. Come back to a pull request.

$ npm install -g baro-ai
One prompt → a 33-story plan → 808 passing tests → a PR, in 71 minutes→
// what you get

You write one sentence. baro does the rest.

No babysitting. No copy-paste. No "now do the next file." baro plans the work, builds it in parallel across isolated branches, reviews itself, and opens the PR — from a single prompt.

baro TUI at the end of a real run — 33 of 33 stories complete, 2.2× parallel speedup, 32 files modified, PR opened
An actual run — one prompt → 33-story DAG → 808 passing tests → PR opened. The summary panel shows wall time, parallel speedup (2.2×), token usage, and the PR URL.
  1. 01

    You describe the goal

    One sentence, plain English, in your repo.

  2. 02

    An Architect pins the design

    File paths, schemas, API shapes, library choices — so dozens of agents don't each invent their own.

  3. 03

    A Planner splits it into a DAG

    Stories with dependencies, so independent work runs at the same time.

  4. 04

    A fleet of agents builds it in parallel

    Not one chat agent typing for an hour — dozens, each in its own isolated git branch.

  5. 05

    It reviews and repairs itself

    A Critic checks every turn and corrects on failure; a Surgeon replans stories that get stuck.

  6. 06

    You get a pull request

    Build-verified, on a feature branch, with a stories table and run stats.

// features

Everything between your sentence and the PR.

  • ◆

    Parallel by default

    Your goal becomes a DAG — topological sort, level grouping, cycle detection. Independent stories run simultaneously, dependents wait their turn.

  • ◆

    Four LLM backends, one flag

    `--llm claude` shells out to Claude Code on Anthropic Max. `--llm codex` shells out to OpenAI Codex CLI on ChatGPT Pro/Plus. `--llm openai` calls any OpenAI-compatible API through Mozaik. `--llm opencode` delegates to the OpenCode CLI (any provider). `--llm hybrid` mixes them — Claude on Architect/Planner/Surgeon, Codex on Story/Critic — the cheapest way to run anything serious.

  • ◆

    Review agent

    After every level, a review agent checks work against acceptance criteria. Spawns fix stories automatically when something is off.

  • ◆

    Live TUI

    Story status, agent logs, DAG view, stats. Nothing happens behind your back — every event lands in the dashboard in real time.

  • ◆

    Resume incomplete runs

    Plans persist as prd.json. If a run is interrupted or you started with --dry-run, pass --resume to continue with the same DAG.

  • ◆

    PR with full summary

    On a feature branch, never on main. PR body includes the story table, build stats, time saved vs sequential, and review notes.

// quick start

Install. Point. Ship.

$ npm install -g baro-ai
  • Basic — give it a goal, walk away (Claude Code under the hood)
    $ baro "Add JWT authentication with role-based access control"
  • Codex CLI on your ChatGPT Pro/Plus subscription instead
    $ baro --llm codex "Refactor the database layer"
  • Hybrid — Claude upstream, Codex downstream (cheapest serious mix)
    $ baro --llm hybrid "Add WebSocket support across api and frontend"
  • OpenCode CLI — any provider, any model
    $ baro --llm opencode -m anthropic/claude-sonnet-4 "Refactor the database layer"
  • Mozaik-native OpenAI (per-call API billing)
    $ OPENAI_API_KEY=sk-... baro --llm openai "Refactor the database layer"
  • Any OpenAI-compatible endpoint (OpenRouter, vLLM, Ollama, MiMo…)
    $ OPENAI_API_KEY=key OPENAI_BASE_URL=https://openrouter.ai/api/v1 baro --llm openai --story-model anthropic/claude-3.5-sonnet "..."
  • Mix it yourself — any phase, any backend
    $ baro --architect-llm claude --story-llm codex --critic-llm codex "..."
  • Limit parallelism on big plans
    $ baro --parallel 3 "Refactor the database layer"
  • Dry-run first, run later
    $ baro --dry-run "Add WebSocket support"
baro --resume
Full options on GitHub →
// agentic environment

Not a pipeline. A bus.

baro is built on the Mozaik agentic environment. The Conductor has no run() method. Every participant subscribes to event types and emits others — spawning a story, evaluating a turn, replanning the DAG are all reactions, not steps in a loop.

What you'd usually write
// the usual orchestrator
async function run(prd) {
  for (const level of prd.levels) {
    const results = await Promise.all(
      level.stories.map(s => runStory(s))
    )
    if (anyFailed(results)) {
      const fixes = await reviewer(results)
      await Promise.all(fixes.map(runStory))
    }
  }
  await commitAndPush()
  await openPR()
}
What baro does
// baro on the Mozaik bus
class Conductor extends Participant {
  onContextItem(item: ContextItem) {
    if (item.type === "RunStartRequest")
      this.emit(LevelComputeRequest())


    if (item.type === "StoryResult")
      this.checkLevel(item)


    if (item.type === "LevelCompleted")
      this.emit(this.nextLevelOrFinish())


    // no run(), no while, no Promise.all
  }
}
// the cast — 12 participants, one bus
  • ArchitectDesigns the DAG up front — runs once before any story spawns (0.25)
  • ConductorOrchestration state machine — drives the run by reacting
  • StoryFactorySpawns Story Agents on each StorySpawnRequest
  • StoryAgentRuns one story via Claude CLI, with retries and timeout
  • LibrarianCross-agent memory — indexes outputs of exploration tools
  • SentryFlags overlapping file writes across concurrent stories
  • CriticPer-turn acceptance-criteria evaluator (opt-in)
  • SurgeonEmits DAG replans when a story fails terminally (opt-in)
  • FinalizerCommits the run, pushes the branch, opens the PR
  • OperatorBridges external commands (TUI, web UI) into bus events
  • AuditorJSONL log of every event on the bus
  • CartographerTranslates bus events into UI frames for the Rust TUI
// deep dive

We wrote up the full engineering story — Getting the maximum out of my Claude Code subscription→

// built with
baro·/ˈbɑː.roʊ/·noun (slang)

Untranslatable. Approximated by cool, sharp, the real thing — but if any of those were enough, the word would not exist. Its negation carries the weight: when something is not baro, it isn't merely uncool, it is actively, irredeemably wrong.

developersarebarosoftwareisbaroagentsarebarocodingisbarothe futureisbarodevelopersarebarosoftwareisbaroagentsarebarocodingisbarothe futureisbaro
// try baro

npm i -g baro-ai

Type a goal. Get a PR.

$ npm i -g baro-ai