openlanes

Will work with ClaudeCodexGeminiPiGrok

Work in progress: 3.1.0 is on RubyGems, and 4.0 is a massive refactor, restructure and speed-up. 3.1.0 may not be ready for your testing yet, but if you like the cutting edge, go for it. Version 4.0 will come with app examples you can generate and build on the fly.

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.

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 backend and a planner working, token counts per plan and a detail drawer for 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.

    openlanes

    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. Newresearcher
    2. Researchedwriter
    3. Ready for planningplanner
    4. Plannedbackend
    5. Buildingbackend + frontend
    6. Ready for reviewharness opens PR
    7. In reviewreviewer
    8. Verifyingverifier
    9. Approved & mergedYou merge

    Blocked

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

    Changes requested

    The reviewer or the verifier 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

    The resolver fixes 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.

    Feature (plans) implementations follow the dependency graph

    While it plans, the planner writes depends_on: into each plan's spec.md. openlanes sorts the plans topologically. Plans joined by an unfinished dependency form a group that builds one plan at a time, prerequisites first, ties by number. Separate groups build side by side, and a plan on a cycle is never started. Drag the plans, hover one to trace its chain, or press Run.

    • can start
    • waiting
    • building
    • merged

    An arrow points from a plan to the one that waits for it. depends_on: lists direct prerequisites only; openlanes works out the rest and never stores the reverse edge. A dependency on a plan that has merged joins nothing, so groups split as plans ship.

    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.

    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

      The verifier runs the repo's e2e suite, if it exists, and the spec'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, but it's customizable per project, as well as which coding agent to invoke. You can also change the agent's model per spec.

    • researcher

      Researches reuse of existing local code, reuse of open source tools, and the best way forwards.

      haiku / medium
    • writer

      Processes the entire spec.md file to be clear, concise and ready for planning.

      sonnet / medium
    • planner

      Splits the spec into work units built in parallel.

      opus / high
    • backend

      Builds data, domain and API, with tests.

      opus / high
    • frontend

      Builds the interface on top of that API.

      sonnet / medium
    • mechanic

      Builds plans that start at building, on its own.

      haiku / medium
    • reviewer

      Checks the pull request against what the spec asked for.

      sonnet / high
    • verifier

      Runs the repo's e2e suite, if it exists, as well as the "How to test" section of the spec.

      sonnet / medium
    • broker

      Folds your answers back into the plan.

      haiku / low
    • resolver

      Resolves a rebase onto main that stopped.

      sonnet / high
    • 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

      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.