dryforge

An all-in-one plugin harness for Claude Code and Codex.

Install and Update

Claude Code

/plugin marketplace add fn-opt/dryforge
/plugin install dryforge

Codex

codex plugin marketplace add fn-opt/dryforge
codex plugin add dryforge@dryforge

Auto update

Codex checks for new releases at the start of each new session and applies them automatically.

Claude Code updates automatically only when auto-update is enabled for dryforge in /plugins -> installed -> dryforge -> auto-update. Otherwise, update manually:

# Claude Code
/plugin marketplace update dryforge
/plugin update dryforge@dryforge

# Codex
codex plugin marketplace upgrade dryforge

Bounded Autonomy Architecture

dryforge redesigns the whole agent workflow around one principle: bounded autonomy. The model gets enough authority to think, plan, parallelize, and execute, but not enough authority to decide what the user meant.

Most agent tooling fails in one of two ways. A bare model is too loose: it can lock onto the wrong interpretation of the user's words and satisfy that instead of the user's real intent. A prescriptive harness is too tight: it can make the model optimize for the wrapper, checklist, or guardrail instead of the work.

dryforge takes the third path: floor, not ceiling. It fixes the minimum structure the model must respect — validated intent, authority hierarchy, execution graph, evidence floor, durable project memory — and leaves the reasoning space open inside that structure. As models get stronger, dryforge does not need to micromanage more; it needs the floor to stay calibrated.

That floor is enforced at the points where agents usually drift. ready makes the decision surface explicit before the spec exists, so a load-bearing unknown cannot slip through as a reasonable default. go follows the approved dependency graph instead of re-planning the work. Verification requires captured evidence, not self-report. Reviews and gates stay silent insurance, not the objective the model is trained to satisfy.

The floor is calibrated, not inflated. A thin input raises the elicitation bar instead of lowering output quality. Domain choices are extracted from the user; technical choices are presented with trade-offs; harmless tuning values are left to implementation. Execution is right-sized the same way: low-risk work can stay direct, risky or parallel work gets isolation, but every path keeps the same evidence floor.

The authority split is explicit. The user owns intent. The spec owns behavior. The plan owns scheduling. Evidence owns verification. The project harness owns durable knowledge.

conventional loop: prompt -> implementation -> correction -> lost context

dryforge loop:     elicited intent -> executable contract -> evidence-backed execution -> durable project state

The result is not a smaller model in a bigger cage. It is a capable model operating with the right floor: enough structure to prevent reward-hacking and laziness, enough freedom to use its reasoning.

Failure Model

Coding agents are already strong enough to build. The failure is not raw capability. The failure is the shape of the work.

A bare agent starts from an underspecified prompt. It fills missing decisions with plausible defaults, implements those defaults as if they were yours, validates from its own point of view, and leaves the rationale in a transcript that dies with the session.

The next session has code, but code only shows outcomes. It does not show why a trade-off was chosen, which edge case was intentionally rejected, or whether an auth check is the complete policy.

dryforge addresses that failure before code exists, during execution, and after the run. It extracts the real intent, freezes it into an executable contract, runs against that contract with bounded autonomy, verifies with captured evidence, and writes the durable project knowledge where future agents start.

The result is higher quality and better token economics. Wrong-direction builds are caught earlier. Correction loops shrink. Project context is not re-explained every run.

One Agent Workflow

dryforge replaces the stack people usually assemble around coding agents: planning modes, deep-interview prompts, ad-hoc project harnesses, AGENTS conventions, memory files, review checklists, and parallel runners.

The important part is that these capabilities are not separate pieces stitched together. They share one philosophy and one workflow. dryforge gives the agent the operating conditions required to use its reasoning well.

Command Loop

/ready <INPUT>  ->  /go  ->  working software + the project harness

Already have running code?
/migration brings the project into the dryforge harness first.

Short aliases are available as /ready, /go, and /migration.

Intent Realization

ready is the front door and the part that makes dryforge fundamentally different from ordinary planning tools.

Most planning tools organize what the user already knew how to say. Deep-interview prompts ask better questions, but still tend to work from a question list, a brainstorming pattern, or the visible content of the input.

ready goes after what the goal implies but never states.

Every input enters as material, not ground truth. A one-line idea, a requirements document, a model-generated plan, a design note, or scattered notes are useful, challengeable, and not authoritative until the user's intent has been validated.

The core mechanism is decision surface accounting: an internal pass that enumerates the load-bearing decisions the design must answer. Entities, actors, state, relationships, lifecycles, edge cases, technical shape, and hidden policy preferences are treated as decisions to close, not blanks to fill with plausible defaults.

Silent defaulting is not a terminal state.

That is the difference between understanding and guessing. If the user's stated goals and constraints already ground a decision, ready realizes it without asking again. If they are silent, ready does not pick a reasonable default and move on. Domain decisions go back to the user. Technical decisions come with concrete options, trade-offs, and a recommendation.

ready's advantage is not question volume. It enumerates more internally, then asks only what survives derivation. The user sees fewer low-value questions and more questions that would otherwise become expensive wrong assumptions.

A thin input raises the bar. It does not justify a thin output. When the prompt gives fewer signals, ready has less to derive and more responsibility to surface the missing decisions before code exists.

The output is not a prettier plan. It is an executable contract that represents what the user meant.

Executable Contract Layer

ready writes three plain files under .dryforge.