← All work

Orion

Go

Orion runs the whole development lifecycle with agents, for greenfield and brownfield work alike. It interviews you about an idea, plans it into a spec and a tree of tracker tickets, then builds and tests several tickets at once, each in its own sandbox, and lands the tested work on develop in batches. Sixteen named agents do the work; Orion decides what runs next, and a person decides what ships.

GoClaude Codespec-kitJiraGitHub ActionsSlack
At a glance
  • Greenfield from an idea, or brownfield by adopting it inside an existing repo.
  • Sixteen role-based agents (architect, developers, QA, triage) on up to four tickets at once.
  • Breaker, gate and shield hooks enforce guardrails; release promotion stays human.
  • Every agent in its own worktree, inside an OS sandbox with a network allowlist.
  • A local web dashboard to clear gates, answer agents and start work without the terminal.
  • One static Go binary, no third-party modules; 42 releases, latest v0.12.0.

Problem

A coding agent can write a ticket's worth of code. It cannot run a project. Someone still has to turn an idea into a plan, break it into tickets, decide what to work on next, keep parallel work from colliding, test the result, integrate it and decide whether it ships. Hand that coordination to the same agent and its judgement becomes the only control, with no hard limit on what it touches, how long it runs or what it pushes.

Approach

Separate the order of work from the work. Orion owns the sequence, the gates between stages and the record; agents do the work inside a stage, and a toolkit such as nj-agents or spec-kit supplies the method. Each stage is its own claude -p run that starts from committed artifacts rather than the previous stage's transcript, so the commits are the audit trail. Routing is by ticket type, component and label, with no model making that choice, and the guardrails are hooks that match rules rather than an agent's opinion.

Solution

Two phases. Inception: orion new interviews you and creates the tracker project, then orion plan writes the intent, constitution, spec and plan, scaffolds the repository and previews the whole Epic, Story and Task tree for one approval. Construction: orion watch sweeps the queue once a minute, admits or holds each ticket, and runs admitted ones through implementing, QA and push in parallel worktrees, then assembles ready branches into a batch, runs CI once and lands it on develop, isolating the culprit when CI goes red. A failed ticket retries at most twice before it comes to you. orion web gives the same controls in a local dashboard, and every action in it maps to a fixed orion command.

System architecture, from the Orion docs: plan, deliver, and the process model inside every stage.

Impact

Orion turns agentic coding from a chat session into a delivery pipeline: an idea goes in and tested work landed on develop comes out, with a committed artifact at every step. Agents cannot push to main or develop, edit their own controls, weaken the test that defines a fix, or cut a release; promoting develop to main stays a person's decision.