Ferrox Core

What is Ferrox Factory?

Every developer running coding agents has felt the same sickening moment: the agent declares victory, you open the diff, and it is confident garbage. The model wrote fast, marked its own homework, and moved on. Ferrox Factory exists to kill that moment. It is an agentic build line where trust does not come from the model at all. It comes from the line itself: structure, discipline, and machine gates that no agent can talk its way past. Work goes in as a spec. It comes out as verified, committed, working software. There is no third state.

The line runs the way a real factory runs. A project becomes a roadmap, the roadmap becomes planned phases, and each phase executes as waves of parallel sub-agents, each building in its own isolated worktree under enforced rules: tests before code, atomic commits per task, deviations recorded instead of improvised. Verification then works backward from the goal, checking that the phase delivered what it promised, not that a checklist got ticked. Plans, state, and handoffs live on disk, so the discipline survives context loss, session breaks, and model swaps.

The whole line is hardened station by station: a context-engineered lifecycle (new-project → plan → execute → verify → ship) fused with anti-loop forcing functions, a fail-closed merge gate, adaptive discipline depth, 3-lineage cross-auditing on risky work, a universal gate-first executor running the Anvil method natively, and a runtime-agnostic model backbone. Fleets of parallel sub-agents build real work without the infinite audit → fix → re-plan loop that stalls naive agent systems.

It runs as markdown skills + a Node CLI (ferrox-tools.cjs) inside your existing agent: Claude Code, Codex, Cursor, Kimi CLI, and 15+ other runtimes. No new runtime, no lock-in.

The proof is the shipping record. This factory built Wayland Desktop, Wayland Core, and the Anvil engine, whose gated climb now runs natively as the line's default execution path. Then it built its own v1.8 through its own phases, gates enforcing, 714 checks green.

The one guarantee, above all others: the build line always terminates and always moves forward. Every working session ends in either a landed, coverage-advancing increment or an explicit, bounded stop (rescope, descope, or escalate to a human). Whatever else happens, the build never enters an unbounded loop.

Why it exists

Every good spec-driven system gives you plan → build → verify. That is table stakes, and on a clean, well-scoped task, table stakes are enough. Ferrox Factory is built for everything else: the machinery that matters when work goes wrong or gets big, the failure modes that cost you days, not minutes:

• It cannot spin. Halting caps turn "re-plan forever" into a bounded, terminating loop.
• It will not merge un-evidenced work. A fail-closed gate refuses any land without real receipts.
• It cannot let the backlog rot, or skip discipline on genuinely risky code.
• It proves work against machine-checked gates. The default executor is gate-first: candidates must pass real, deterministic checks before anything is accepted, and models escalate only when gates fail.
• It routes cost intelligently: low-cost frontier-class models for most work, expensive ones only where risk earns them, on any runtime.

That's the offer: a structural safety net for exactly the paths where autonomous agents usually fall apart, enforced by the line instead of promised by the model.

The core ideas

1. Adaptive discipline depth: spend rigor where risk earns it

Every planned increment is risk-graded, and the process depth scales to the grade. Not a mode you toggle; a decision the system makes and can audit: