Codex Forge

Forge the proposal. Let the council judge it.

Forge is the creative sibling of Codex Council. The council reviews what already exists; Forge invents what could. Five creator roles shape one bounded implementation proposal — then hand it to the council for judgment. Forge creates; it does not validate truth, safety, UI behavior, or correctness.

Your idea enters on the left. Five creators shape it in parallel, the Forge converges their work into one proposal (re-briefing up to three rounds if needed), and the result is handed to the council to judge.

Forge vs. Council

One invents. The other interrogates.

Forge creates

Use it when you have an idea and want a concrete, buildable shape for it — a proposal that balances boldness, feasibility, safety, and cost.

Output is one bounded proposal, not a verdict. It does not check whether the idea is correct or safe to ship.

Council judges

Use it when you have a proposal and want to know if it survives architecture, reliability, security, product, red‑team, and performance pressure.

The natural flow is Forge → Council: invent the shape, then pressure‑test it before you build. Forge even writes the next prompt for you.

The five creators

Different imaginations, one proposal.

Buckminster Fuller

Systems Imagination Architect. The bold system shape — primitives, boundaries, the creative architecture.

Hedy Lamarr

Product Invention Strategist. Turns the idea into user value, workflow fit, interaction shape, and adoption hooks.

Katherine Johnson

Feasibility & Integration Engineer. Grounds it in implementable steps, dependencies, interfaces, and constraints.

Margaret Hamilton

Safety & Reliability Builder. Surfaces failure modes, privacy, rollback, and reliability constraints.

John von Neumann

Performance & Complexity Optimizer. Pushes for performance, low cost, low latency, and ruthless simplification.

The synthesizer

A separate creative pass merges the five into one unified proposal — keeping disagreement visible instead of averaging it away.

A bounded loop

It converges, or it tells you it didn't.

Creation can spin forever, so Forge is deliberately capped. It won't manufacture fake agreement to look finished.

01

One round, by default

The five creators each produce a proposal, and the synthesizer merges them. Most ideas need only this.

02

Convergence check

Proposals are scored. Converged means every creator's alignment is high, scores agree, and there are no blockers or open dissent.

03

Re-brief

If it hasn't converged, Forge runs another round — automatically when round 1 is strongly discordant, or after your OK on a near-miss. It re-briefs only the divergence. Hard cap: three rounds.

04

Converged or not

You get a unified proposal, or an honest nonconverged result with the dissent that stopped it.

How convergence is decided Proposals are scored on novelty, feasibility, user fit, risk control, and implementation clarity. It converges only when the lowest alignment is at least 7/10, the scores don't scatter, and nothing is blocked — otherwise you get nonconverged with the dissent preserved. When round 1 is strongly discordant (low alignment or a wide spread), the next round starts automatically; a near-miss waits for your go-ahead.

What it returns

A proposal you can hand straight to the council.

Unified proposal — the merged design, leading with what to build.
Convergence result — converged, partial, or nonconverged.
Persistent dissent — the creative disagreement that survived, kept visible.
Implementation shape — the buildable path: steps, interfaces, dependencies.
Safety & performance notes — failure modes, rollback, cost and latency flags.
Verification — what still needs to be proven before you trust it.
Next prompt — a ready‑to‑send Council prompt to judge what you just forged.

Use it

Ask Forge to shape the idea.

In chat — give it an idea to design, not a decision to judge:

Prompt

Use Codex Forge to design a bounded implementation proposal for <your idea>.
Balance bold shape, feasibility, safety, and cost — and tell me where the
creators disagree. Then give me the prompt to send Council for judgment.

Or scaffold a traceable Forge session from the CLI (it reuses the council's preflight estimate, token budgets, and stats):

# Estimate, then scaffold a Forge session (--type forge).
python3 scripts/codex_council.py estimate --topic "Forge a release workflow" --mode standard --type forge --token-budget compact
python3 scripts/codex_council.py init --topic "Forge a release workflow" --root . --mode standard --type forge --token-budget compact --confirm-estimate

# When creator scores exist, assess convergence.
python3 scripts/codex_council.py forge-convergence --input forge-scores.json

Forge, then verify A forged proposal is a starting point, not a green light. If the risk is non‑trivial, run Codex Council (or normal implementation verification) on it before you build.