openlanes
Work in progress: 3.1.0 on RubyGems, 4.0 on main, Homebrew next

A few words in. Agents in lanes. Reviewed PRs out.

openlanes is a software factory for your terminal. You write a short brief in spec.md; a crew of specialist agents researches, specifies, plans, builds, reviews and verifies it, until it's a set of reviewed, CI-passing pull requests. You merge. It runs on your laptop, and other machines can join the same board.

See how it works

brew install A Homebrew package is on its way.

The openlanes control room with five plans on the board. Each swim lane is a plan moving from New through Planning, Building and Review, with luke-backend and a planner working, token counts per plan and a detail drawer for luke-backend on the right.
The control room, five plans in flight. Run openlanes start and it opens on 127.0.0.1:11000.

No database. The folder name is the state.

  • Every feature is a folder under .plans/, named NNN.MM━━emoji━━❯slug.
  • When an agent finishes, openlanes renames the folder with git mv, so git log is the audit trail.
  • A folder may only claim a state its files prove. openlanes resync dirs fixes any that lie.
  • Done, deferred and discarded plans move into archive/, deferred/ and abandoned/.

$ ls .plans/

    How the factory is wired

    A Ruby engine runs in rounds. Each round it reads every plan folder, hands each plan to the agent that owns its state, and stops when a full round changes nothing. Hover or tab through the map.

    Engine

    Lines show who talks to whom.

    From a brief to ready-to-merge

    Each state belongs to one agent. It does its job, then the folder is renamed to the next state. Nothing merges automatically.

    1. Newleah-researcher
    2. Researchedyoda-writer
    3. Ready for planningluthen-rael-planner
    4. Plannedluke-backend
    5. Buildingluke + rey-frontend
    6. Ready for reviewharness opens PR
    7. In reviewhansolo-reviewer
    8. Verifyingchewie-verifier
    9. Approved & mergedYou merge

    Blocked

    A question only a person can answer goes into blocked.md. lando-broker folds your answer back in.

    Changes requested

    hansolo or chewie sends the plan back to the builders with what failed.

    Bomb

    A block left too long while other plans wait on it halts the run until someone answers.

    Stuck rebase

    bb8-resolver resolves a rebase onto main that stopped, and never moves a plan.

    Choose where each plan starts

    Not every change needs a researcher. starts: takes one of three values: set a default in .openlanes.yml and override it in any plan's spec.md frontmatter.

    researchThe whole spine: a new feature from a few words.
    1. researcher
    2. writer
    3. planner
    4. backend + frontend
    5. reviewer
    6. verifier
    planningSkip research: your spec already stands.
    1. planner
    2. backend + frontend
    3. reviewer
    4. verifier
    buildingOne agent, one short mechanical task.
    1. mechanic
    2. reviewer
    3. verifier

    Settings resolve in this order: a typed flag, then spec.md frontmatter, then .openlanes.yml, then the built-in default. openlanes create --starts building split big migration skips straight to the mechanic.

    Watch it work, step in when asked

    openlanes start boots the engine and the control room together. Clone the project on a second machine, point it at the same Redis, and both work the same board.

    The control room with plan 000 between Planning and Building, luke-backend and rey-frontend working on it side by side, and the luke-backend panel open showing its model, tokens, context use and a box to message it.
    One plan, two builders in parallel, and the luke-backend drawer open.
    • Swim lanesEach row is a plan, coloured by where it starts, with its tokens and the agent working it right now.
    • Message an agentSwitch its model or write to it; it reads your note at its next step.
    • Chat with the copilotAsk it anything about the board while plans build. Type /stop 004, /restart 004 or /concurrency 6 in the same box to steer the run.
    • Needs YouAnswer blocks on the page instead of editing blocked.md.
    • All machinesRemote nodes show up read-only, each on its own plans.
    • Stop All LocalThe off switch for every local agent and the page.

    Start on one laptop. Grow a cluster.

    openlanes runs entirely on your machine. Start it on a second one with the same repository and the same REDIS_URL, and the two become nodes of one cluster with one board. Redis is the only wire between them.

    • Your laptopopenlanes startPlans 001, 004
    • DesktopREDIS_URL=… openlanes startPlans 002, 005
    • Build boxREDIS_URL=… openlanes startPlan 003
    RedisLocks, so no two nodes take one plan. Streams, so every node sees every move.
    • Local firstOne machine is a complete factory. Nothing to host, no account to make.
    • Join, don't configureSame repo, same Redis. The new node shows up under All machines.
    • Each node owns its plansA node builds the plans it claimed; the others show them read-only.

    Agents write code. They don't ship it.

    The autonomy boundary is enforced by the harness, not by asking nicely in a prompt.

    • No commits, no pushes

      Agents never run git commit, git push or gh pr merge. Web access is off unless an agent declares it.

    • Checked after every agent

      The harness confirms HEAD didn't move and no remote ref was pushed, then publishes the branch itself.

    • Verified, not just reviewed

      chewie-verifier starts the app and walks the plan's How to test before anything is labelled ready.

    • Survives a lost Redis

      Agents pause, Redis is retried with jittered backoff, and work resumes from whichever state copy is newer.

    The crew

    Each agent runs on the model its job needs. Read any definition with openlanes describe <name>, and change its model per phase in spec.md.

    • leah-researcher

      Researches a new idea across many sources.

      haiku / medium
    • yoda-writer

      Turns research into a full spec.

      sonnet / medium
    • luthen-rael-planner

      Splits the spec into work units built in parallel.

      opus / high
    • luke-backend

      Builds data, domain and API, with tests.

      opus / high
    • rey-frontend

      Builds the interface on top of that API.

      sonnet / medium
    • r2d2-mechanic

      Builds plans that start at building, on its own.

      haiku / medium
    • hansolo-reviewer

      Checks the pull request against what the spec asked for.

      sonnet / high
    • chewie-verifier

      Runs the app through the plan's How to test.

      sonnet / medium
    • lando-broker

      Folds your answers back into the plan.

      haiku / low
    • bb8-resolver

      Resolves a rebase onto main that stopped.

      sonnet / high
    • c3po-operator

      The control room's copilot: chat with it about the board.

      haiku / low

    Opus: planning and back endSonnet: writing, UI, reviewHaiku: research and paperwork

    Still being built, in the open

    openlanes builds itself: most of its recent pull requests went through its own lanes. Expect sharp edges and fast releases.

    1. Shipped

      3.1.0 on RubyGems

      Plan folders, the three starts, the crew, blocks, and the control room.

    2. On main

      4.0

      chewie-verifier, multi-machine boards, the progress journal and Redis outage recovery.

    3. Next

      Homebrew package

      One brew install, no Ruby setup to think about.

    Try it today

    Install the gem now. When the Homebrew package lands, it'll be the easy way in. Watch the repo to hear about it first.

    1. Installs the gem and its three names for one executable: openlanes, lanes and ol, plus agent-lock, which lets several agents share one checkout without overwriting each other. Needs Ruby 3 or newer.

    2. Makes your shell notice the new ol on your PATH.

    3. Installs what's missing with Homebrew, then checks the claude CLI, gh auth and Redis. Add -n to see the list first.

    4. Run it inside your repository. Writes .openlanes.yml and creates .plans/.

    5. Starts the engine and the control room together, with up to 8 agents working at once. The board opens on 127.0.0.1:11000.

    Then, day to day

    ol create
    Starts the next numbered plan from a few words and opens its spec.md.
    ol run -n
    Shows which agent would take which plan, changing nothing.
    ol start
    Engine plus control room, until Stop All Local or Ctrl-C.
    ol status
    Every open plan, its state and its pull requests.
    ol unblock
    Folds answers from blocked.md back into the plan.

    brew install Coming soon.

    Illustrated portrait of Konstantin Gredeskoul in a trucker cap and sunglasses

    Made by Konstantin Gredeskoul

    Engineering leader and open-source author with 25+ years in distributed systems, scaling and developer tooling. I took Wanelo from 3,000 to 300,000 requests a minute, and my Ruby gems have been downloaded over 200 million times. These days I build applied-AI systems through ReinventONE, and openlanes is how I ship them.