Miniforge

miniforge is an autonomous software development system designed to behave like a factory, not a chatbot

LLM Mart 7 views 401k listing impressions

Write a spec. Get a pull request.

Miniforge is an autonomous software factory. You describe what you want — in plain English or structured EDN — and miniforge plans the work, writes the code, runs the tests, reviews itself, and opens a PR. No prompt engineering. No copy-paste. Full SDLC.

Before and After

BEFORE                              AFTER
──────                              ─────
1. Write a ticket                   1. Write a spec
2. Create a branch                  2. mf run spec.edn
3. Read the codebase                3. Review the PR
4. Write code                       4. Merge
5. Run tests
6. Fix failures
7. Lint
8. Fix lint
9. Commit
10. Push
11. Open PR
12. Write PR description
13. Wait for CI
14. Wait for review
15. Address feedback
16. Re-push
17. Wait for re-review
18. Merge

How It Works

Miniforge runs four nested control loops — a team of agents does the work, a tight inner loop enforces quality at every step, a monitor resolves reviewer feedback after delivery, and meta-agents govern the whole operation.

Team loop — specialized agents collaborate through phases, like a dev team handing off work:

Spec ──► Explore ──► Plan ──► Implement ──► Verify ──► Review ──► Release ──► Observe
           │            │           │            │           │          │          │
           │            │           │            │           │          │          └─ monitors PR:
           │            │           │            │           │          │             polls comments,
           │            │           │            │           │          │             fixes feedback,
           │            │           │            │           │          │             merges when ready
           │            │           │            │           │          │
           │            │           │            │           │          └─ creates branch,
           │            │           │            │           │             commits, opens PR
           │            │           │            │           │
           │            │           │            │           └─ self-reviews diff
           │            │           │            │              against spec + constraints
           │            │           │            │
           │            │           │            └─ gates: syntax, lint,
           │            │           │               no-secrets, tests-pass
           │            │           │
           │            │           └─ generates code via LLM agent
           │            │
           │            └─ decomposes spec into a task DAG
           │               with dependencies and parallel execution
           │
           └─ scans codebase, loads relevant files,
              queries knowledge base

Inner loop — inside each phase, the agent generates an artifact, validates it against policy gates, and repairs failures automatically:

generate ──► validate ──► [pass] ──► next phase
                │
                └─ [fail] ──► repair ──► re-validate
                                 │
                                 └─ [budget exhausted] ──► escalate

Observe loop — after Release creates a PR, the monitor loop runs autonomously for up to 72 hours:

poll PR ──► classify comments ──► route
               │                     │
               ├─ change request ──► fix, push, reply
               ├─ question ──────► answer, reply
               ├─ approval ──────► attempt merge
               └─ noise ─────────► skip

Meta loop — governance meta-agents supervise the entire operation at a semantic level. Any meta-agent can halt the factory floor:

From the project's README.

Comments (0)

Sign in to join the conversation.

No comments yet.