Codex Forge

Turn an idea into a review-ready proposal.

Five defined role prompts explore the system, product, feasibility, reliability, and performance angles. A separate synthesis pass produces one bounded proposal and keeps material dissent visible. Forge proposes; it does not verify correctness, safety, or runtime behavior.

Five role prompts produce distinct proposals. Forge synthesizes them, may re-brief the unresolved differences, and stops after at most three rounds. The result can be converged, partial, or nonconverged before it is handed to Council.

Forge vs. Council

Forge proposes. Council reviews.

Forge creates

Use it when an idea still needs scope, interfaces, constraints, risks, and a practical implementation shape.

The output is a bounded proposal, not a verdict or release decision.

Council judges

Use it when a proposal needs structured review across architecture, reliability, security, product, red-team, and performance concerns.

Council reports a decision and open risks. Required implementation checks still determine whether the work is correct.

The five role prompts

Defined perspectives, followed by separate synthesis.

Buckminster Fuller

Systems Imagination Architect. Defines primitives, boundaries, and the overall system shape.

Hedy Lamarr

Product Invention Strategist. Connects the idea to user value, workflow fit, and interaction design.

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. Examines latency, cost, complexity, and opportunities to simplify.

The synthesizer

A separate pass merges the five outputs into one proposal while preserving material disagreement.

A bounded loop

The loop stops with a proposal or a nonconverged result.

Forge runs one round by default and never exceeds three. It can finish without convergence; unresolved dissent remains part of the output.

01

One round, by default

Each role prompt produces a proposal, then the separate synthesizer creates the first bounded result.

02

Convergence check

Structured scores, blockers, and persistent dissent determine whether the proposals align or need another pass.

03

Re-brief

Strong discord can trigger a second round; a near-miss waits for approval. Re-briefing targets the unresolved differences. Hard cap: three rounds.

04

Converged or not

The result is converged, partial, or nonconverged, with remaining dissent preserved.

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 score spread stays within the limit, nothing is blocked, and no persistent dissent remains — 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 bounded proposal, not a green light.

Unified proposal — the synthesized design and its intended scope.
Convergence result — converged, partial, or nonconverged.
Persistent dissent — the creative disagreement that survived, kept visible.
Implementation shape — proposed steps, interfaces, and dependencies.
Safety & performance notes — failure modes, rollback, cost and latency flags.
Verification needs — what still requires evidence before implementation or release.
Next prompt — a Council prompt for structured review of the proposal.

Use it

Ask Forge to shape the idea.

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

Prompt example

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

Proposal first, evidence later Forge does not test the proposal. Use Codex Council for review, then run the checks required by the implementation before calling it complete.