I was looking for a way to build projects and ideas in the background while I was off doing something else. I felt like coding agents by themselves could do a certain granularity of work, but I wanted to try and push it further. So I built Orrery.

What it does:

- Take an idea or spec and produce an implementable plan (steps, dependencies, outputs)

- Refine, simulate, and review the plan in a trackable way

- Execute the plan with a deterministic step graph (same plan gives same execution order), with tracked step logs/reviews/artifacts

I've used this to do a repo conversion and generate entire projects (take a look at "watchfix" in my github repos as an example). This is still experimental.

Note: "agent skills" are basically repeatable prompts that coding agents can use in specific situations.

Key features:

- Repeatable “agent skills” for idea decomposition, refinement, execution, and review

- Plans are YAML, can be generated externally (e.g., from a spec doc in a Claude project), then simulated/reviewed

- Execution runs in an isolated git branch, and the non-interactive flow is pipeline-friendly

When not to use it (and just use a coding agent):

- Quick one-off changes

- Exploratory development where the plan changes every few minutes

- Simple refactors that don’t benefit from explicit planning

Further comparison vs Claude Code/similar tools: https://github.com/CaseyHaralson/orrery/blob/main/docs/COMPA...

How it works:

- It installs a few agent skills that help guide plan generation, step execution, and review

- A script breaks the plan into steps and then loops through the plan giving background agents the context

Quick start:

- Install + init:

  npm install -g @caseyharalson/orrery
  orrery init

- Generate a plan: ask your agent to use the discovery skill for [goal]

- Execute:

  orrery exec # (optionally inside a devcontainer)

Repo: https://github.com/CaseyHaralson/orrery

Feedback I'd love:

- Would this be useful in your workflow?

- What would make this stand out vs other orchestrators?

- Which part is most valuable: idea decomposition, plan format, review loop, or execution runner?

---

Example Plan Yaml:

  metadata:
    source_idea: "Simple test plan for parallel and
  dependency testing"
    outcomes:
      - Test parallel step execution
      - Test dependency resolution

  steps:
    - id: "1"
      description: "Create config file"
      deps: []
      parallel: true
      context: "Initial config file with basic settings"
      requirements:
        - Create config.json with app name and version
      criteria:
        - File exists and contains valid JSON
      files:
        - test-output/config.json