migration

Install & Update

Install:

/plugin marketplace add prekuter/dryforge
/plugin install dryforge@dryforge

Update:

/plugin marketplace update dryforge
/plugin update dryforge@dryforge

Auto-update: off by default. Turn it on in /plugin → Marketplaces → dryforge → Enable auto-update.

Install:

codex plugin marketplace add prekuter/dryforge
codex plugin add dryforge@dryforge

Update:

codex plugin marketplace upgrade dryforge

Auto-update: on. New releases load at the start of each session.

Install:

grok plugin marketplace add prekuter/dryforge
grok plugin install dryforge

Update:

grok plugin update dryforge

Auto-update: on. New releases load at the start of each session.

Install:

copilot plugin marketplace add prekuter/dryforge
copilot plugin install dryforge@dryforge

Update:

copilot plugin update dryforge

Auto-update: off by default. Add "autoUpdate": true to the dryforge entry under extraKnownMarketplaces in ~/.copilot/settings.json.

Install:

agy plugin install https://github.com/prekuter/dryforge/tree/main/antigravity

Update:

agy plugin install https://github.com/prekuter/dryforge/tree/main/antigravity

Auto-update: not available. Run the install command again to update.

Everyone has been using agents wrong.

Agents already know how to work. What they don't have is your intent.

The industry filled that gap with process. Workflows, methodologies, rules, swarms of agents — all fixed before anyone asks what you are building. The method comes first, and your intent is cut to fit it.

Your intent should decide the method. Instead, the method decides your intent.

"We write tests first. Now — what are you building?"

It runs backwards. Once the intent is clear, the method follows from it. Fixing the method first is not rigor. It only means no one listened first.

And every one of those rules was written before anyone saw your work, for whichever model was current when it was written. When the next model arrives, the rules no longer fit, and the whole setup is torn down and rebuilt. Again.

• Workflows script how the agent works, so every new model breaks them — and the model takes the blame.
• Test-first as law puts the same ceremony on a config file and a payment rule.
• Subagent swarms guess an unstated intent in parallel and bill the tokens as progress.
• Loops run for hours toward a goal nobody pinned down.
• Questions are a step in the procedure. They ask what the code already answers, while the decisions that are yours get made in silence. The most dangerous question is the one never asked.
• Human checkpoints land on every step of the process instead of on the decisions only you can make.
• Spec documents are generated for the ritual, then drift from the code and stop being read.

The problem nobody solved is the first one: understanding what you actually mean.

Fundamentally Different Approach

Agents have become capable enough to be given real autonomy. The question is no longer whether to let them decide. It is what they may decide.

There have been two answers, and both are wrong.

• Hold the agent too tight, and you get process: every step scripted, every case enumerated in advance. It props up a weak model and caps a strong one. The better the model gets, the more the procedure holds it back.
• Let the agent go, and you get a bare agent: free where it should be free, and free where it should not be. It decides what you meant, and fills every gap with a plausible guess.

Dryforge's answer is the third: bounded autonomy, anchored in your intent. The agent has full freedom inside a boundary it may not move on its own — and that boundary is your intent.

Agents rarely fail for lack of intelligence. Most of their failures are failures of authority, dressed up as failures of reasoning. An agent infers a product rule no one stated. It treats the code that exists as proof of what was intended. It reinterprets a requirement into something easier to build. It takes its own summary as proof that the work is done. Each step sounds reasonable on its own. Together, they carry the result away from what you wanted.

So Dryforge separates authority. On top of bounded autonomy, Dryforge built its own authority model:

• Every decision in the work has an owner. What is yours comes back to you, whatever form it takes. What is the agent's, the agent decides with everything it has.
• What can be found out is not asked. What is yours is never guessed.
• When sources disagree, nothing is chosen quietly. The conflict comes to you.
• No process decides what is yours, and nothing that is yours is decided without you. A guess is worse than a pause.

The rest of the design follows from it.

• A floor, not a ceiling. Dryforge fixes only what must hold, and leaves the reasoning open. A better model raises the ceiling by itself.
• Trust the reasoning, not the self-verdict. The agent's judgment is trusted. Its judgment of its own work is not. Whether something is done is decided by evidence, not by the agent's word.
• Effort in proportion. Effort scales with the risk of the work. A small change stays small; a risky one gets the rigor it needs. Thoroughness for show is a failure, not a virtue.
• Protect the goal, not a proxy. Every rule, checklist, and gate a harness adds can become the thing the agent optimizes instead of the work. Dryforge adds none of them for their own sake. It arranges the work so that the shortest path is the one that serves your intent.

It changes where you stand. You are not asked to supervise every step, approve every stage, or answer what the code could have told the agent. You are called in where the decision is yours, and only there. You stay the author of wh