the 
 ███████╗ ██████╗ ██╗   ██╗███╗   ██╗██████╗ ██████╗ ██╗   ██╗
 ██╔════╝██╔═══██╗██║   ██║████╗  ██║██╔══██╗██╔══██╗╚██╗ ██╔╝
 █████╗  ██║   ██║██║   ██║██╔██╗ ██║██║  ██║██████╔╝ ╚████╔╝
 ██╔══╝  ██║   ██║██║   ██║██║╚██╗██║██║  ██║██╔══██╗  ╚██╔╝
 ██║     ╚██████╔╝╚██████╔╝██║ ╚████║██████╔╝██║  ██║   ██║
 ╚═╝      ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═════╝ ╚═╝  ╚═╝   ╚═╝

~/project $ /plugin install odsp-microsoft/foundry

v1.6.2 · Copilot CLI Plugin
▼ scroll

// Skills

═══════════════════════════════════════

🔥 Crucible

Multi-Model Planning

Three AI models plan independently, then cross-review until convergence. No single model's blind spots survive.

Phases: Intake → Assess → Config → Fleet Draft → Converge → Output → Handoff

⚒️ Forge

Autonomous Execution

Reads the plan, writes code file-by-file, verifies every iteration, passes the build gate, commits and pushes.

Phases: Intake → Prepare → Branch → Execute → Ready → Deep Review → Ship
📋 Task
You describe the work
→
🔥 Crucible
3 models plan
→
📄 plan.md
Converged output
→
⚒️ Forge
Code + verify
→
🚀 Shipped
Committed & pushed

// Agents

═══════════════════════════════════════

Foundry coordinates 7 specialized agents, each with a single responsibility. No agent does two things. They are dispatched by Crucible and Forge as needed — drafters produce artifacts, verifiers validate them, and the scribe logs everything.
plan-drafter
Crucible · Drafting
Why: Each model needs its own drafter to produce a plan independently — this is what makes multi-model convergence possible.
design-drafter
Crucible · Drafting
Why: Large tasks need a design doc that specifies contracts and interfaces. This agent generates it during convergence so Forge can verify against it.
plan-verifier
Forge · Verification
Why: After every code iteration, Forge needs a binary PASS/FAIL check that the implementation still matches the plan. No subjective judgment — just compliance.
design-verifier
Forge · Verification
Why: Code can pass the plan check but violate design contracts. This agent catches interface mismatches and pattern violations.
architecture-verifier
Forge · Verification
Why: Even correct code can break architecture rules. This agent verifies the implementation respects the existing architecture constraints and conventions.
code-agent
Forge · Execution
Why: One agent per file, surgical changes only. Isolation prevents one file's changes from corrupting another. Each gets the plan + just its target file.
scribe
Forge · Logging
Why: Forge runs autonomously and can span many iterations. The scribe records what happened each iteration so you (and Forge on resume) have full history.
Want to understand the internals? Read the wiki →

// How They Work

═══════════════════════════════════════

🔥 Crucible
The Planning Engine
Agents it dispatches
plan-drafter ×3 — one per model, produces plan.md
design-drafter ×3 — large tasks only, produces design-doc.md
How it orchestrates
1 Intake — collects task description, architecture doc, and execution config from you
2 Context Gathering — Crucible itself scans the codebase (git ls-files, key files, project structure) and assembles a context packet
3 Fleet Dispatch — sends context packet to 3 plan-drafters in parallel (Opus, Codex, Gemini). Each plans independently — no model sees the others
4 Cross-Review Loop — all 3 plans are shared. Each model revises its plan after seeing the others. Repeats until ≥2/3 models converge structurally
5 Output — writes converged plan.md (+ design-doc.md for large tasks) to the Foundry working directory
Key insight
The plan-drafter never touches the codebase. Crucible does all the exploration and feeds the drafter a pre-assembled context packet. The drafter's only job is: given this context, produce the best possible plan.
⚒️ Forge
The Execution Engine
Agents it dispatches
code-agent ×N — one per file, surgical changes only
plan-verifier ×1 per iteration — PASS/FAIL compliance
design-verifier ×1 per iteration — contract checks (large only)
arch-verifier ×1 per iteration — architecture compliance
scribe ×1 per iteration — logs history for resume
How it orchestrates
1 Intake — reads plan.md from Crucible's output. Runs headless using the execution config
2 Branch — creates task branch from base. For multi-split: creates split branches off the task branch
3 Execute — for each file in the plan, dispatches a dedicated code-agent. One agent = one file = isolation
4 Verify — after each iteration, runs plan-verifier + design-verifier + architecture-verifier in parallel. All must PASS
5 Deep Review — 3-model adversarial review. Scribe logs everything. On PASS → commit, push, done
Key insight
Forge is designed to be headless — after you say "go", it runs to completion without interruption. If interrupted, the scribe's logs enable full resume from the last iteration.
Full internal documentation → Foundry Wiki

// Fleet Review

═══════════════════════════════════════

Three Models. One Verdict.
Claude Opus
9.1
Deep architectural analysis
GPT Codex
9.0
Logic & correctness focus
Gemini Pro
8.0
Edge case detection
▼ Cross-reference → Deduplicate → Apply fixes → Commit ▼

// Install

═══════════════════════════════════════

Requires GitHub Copilot CLI

/plugin install odsp-microsoft/foundry Copilot CLI only — multi-model orchestration required

Foundry's deep review phase uses deep-review for adversarial code review

/plugin install agency-microsoft/deep-review Recommended — Forge falls back gracefully if not installed

// Important Notes

═══════════════════════════════════════

⚠ Caution

AI can make mistakes. Foundry is a powerful tool, but it is still just a tool. It is your responsibility to cross-check all outputs — code, plans, and design docs. No matter how smart the orchestration gets, it still needs human oversight. Always verify your work before merging.

💡 Recommendation

Foundry dispatches multiple AI models in parallel — planning with 3 models, executing with dedicated code agents, and running adversarial reviews. This can consume significant resources depending on task complexity. We recommend using Foundry in a separate dev box or dedicated environment to avoid impacting your primary workflow.

🔑 Permissions

Foundry creates branches, writes files, runs builds, commits, and pushes — all autonomously. For it to work without constant permission prompts interrupting the flow, enable full permissions with /yolo in Copilot CLI before invoking Crucible or Forge. Without it, Foundry will pause at every file write and git operation, breaking the autonomous execution loop.