One Framework, Seven AI Agents: Why We Stopped Picking Favorites

Here's a conversation I've had at least a dozen times:

"Does Plan Forge work with Claude?" "What about Cursor?" "We use Gemini CLI — can we still use your guardrails?"

The answer used to be "sort of — copy the instruction files and adapt them." That was slow, fragile, and nobody did it consistently.

So we built native adapters for every major AI coding agent. One setup command. Seven agent formats. Same guardrails everywhere.

The Problem: Teams Don't Agree on Tools

Your team doesn't all use the same AI coding tool. One dev swears by Copilot in VS Code. Another prefers Cursor's inline editing. The senior architect uses Claude Code for deep reasoning. The DevOps engineer likes Gemini CLI because it's fast. The intern just discovered Windsurf.

If your guardrails only work in one tool, most of your team isn't covered. And the team members who aren't covered are the ones who produce the code that fails review.

One Command, Seven Agents

.\setup.ps1 -Preset dotnet -Agent all

That single command generates native files for every supported agent. Not generic text files that you paste into a chat — actual native configuration that each tool reads automatically at session start.

What Each Agent Gets

Every format includes all 18 guardrail files, all pipeline prompts, and all 19 reviewer agents — transformed into the native format each tool expects.

How the Adapters Work

Each adapter follows the same pattern: take Plan Forge's canonical files (.github/instructions/, .github/prompts/, .github/agents/) and transform them into whatever format the AI tool reads natively.

Copilot (the default)

Copilot reads .github/instructions/*.instructions.md files automatically based on their applyTo frontmatter. Edit a database file and the database guardrails load. Edit a test file and the testing guardrails load. No manual attachment needed. This is the gold standard — and what every other adapter tries to replicate.

Claude Code

Claude reads CLAUDE.md at session start. The adapter generates a rich document with all guardrails embedded inline, organized by domain (security, database, testing, etc.), plus a "How to Use These Guardrails" header that tells Claude which section applies to which file type. Every prompt becomes a /planforge-* slash command via .claude/skills/. MCP tools work via .claude/mcp.json.

Cursor

Cursor reads .cursor/rules at session start and .cursor/commands/ for custom commands. The adapter generates a rules file with all guardrails embedded plus command files for every pipeline step and reviewer agent. Type planforge.step3-execute-slice and Cursor runs it natively.

Gemini CLI

Gemini reads GEMINI.md and supports @import syntax to pull in external files. The adapter generates a context document with @.github/instructions/security.instructions.md imports, plus .toml command files in .gemini/commands/planforge/ for every pipeline step. MCP auto-configures via .gemini/settings.json.

Windsurf

Windsurf's Cascade agent reads .windsurf/rules/ and .windsurf/workflows/. Same embedding pattern — all guardrails in a single rules file, all prompts and agents as workflow files.

Codex CLI

Codex reads .agents/skills/ directories with SKILL.md files. Every prompt and agent becomes an invocable skill.

Generic (any tool)

For tools not explicitly supported — ChatGPT, Perplexity, Ollama, Mistral, whatever comes next — the generic adapter generates .ai/AI_INSTRUCTIONS.md with everything embedded as plain markdown. Copy-paste it into any chat window. It works everywhere, forever.

Why This Matters for Teams

The guardrails aren't suggestions. They're structural. When every developer's AI agent loads the same architecture principles, the same security rules, and the same testing standards — regardless of whether they're using Copilot or Cursor or Claude — the code converges on the same quality bar.

No more "this PR doesn't match our patterns because I used a different tool." No more "I didn't know about the security guidelines." The guidelines load automatically in every tool. The agent can't avoid them.

• New hire on Cursor? — -Agent cursor and they have every guardrail from day one
• Senior dev on Claude? — -Agent claude and the same 19 reviewer agents are available
• Experimenting with Gemini? — -Agent gemini and MCP auto-configures
• Using everything? — -Agent all and every format generates in one pass

What's the Same, What's Different

Capability	All 7 Agents	Copilot Only
18 guardrail files	✅ embedded in native format	✅ auto-loading by file type
19 reviewer agents	✅ as native commands/skills	✅ as agent picker entries
Pipeline prompts	✅ as native slash commands	✅ as prompt templates
MCP tools (18)	✅ Claude + Gemini + Copilot	✅ via .vscode/mcp.json
Auto-load by file type	❌ embedded instead	✅ via applyTo frontmatter
Lifecycle hooks	❌ VS Code only	✅ SessionStart, PreToolUse, etc.

Copilot in VS Code remains the richest experience — it's the only one with true file-type-scoped auto-loading and lifecycle hooks. The other adapters embed all guardrails at once (which is slightly less efficient in terms of context but functionally equivalent). Every agent gets the same rules; they just ingest them differently.

The Killer Feature: Unified Memory Across Agents

Here's the part most people miss — and it might be the biggest deal of all.

When you wire in OpenBrain as a shared MCP server, agents in completely different tools share the same memory. Think about what that means:

1. Your Claude Code session hardens the plan and captures architectural decisions to OpenBrain
2. Your Cursor session executes the slices — and searches OpenBrain first, finding every decision Claude made
3. Your Copilot session runs the independent review — and queries OpenBrain for the full decision history from both previous sessions

Three different tools. Three different AI models. One shared institutional memory.

This isn't just "same guardrails everywhere." This is cross-agent collaboration through persistent semantic memory. The Claude session doesn't know Cursor exists. The Cursor session doesn't know Claude was involved. But they're both working from the same decision history because OpenBrain sits underneath all of them.

It doesn't matter which agent writes the code. What matters is that every agent knows what every other agent decided — and why.

This is what makes the multi-agent story more than a convenience feature. It's not just "pick your favorite tool." It's "your whole team's AI agents build on each other's knowledge, across tools, across sessions, across time." The decisions compound. The mistakes are learned from. And nobody starts from zero — ever.

Try It

# Install for your stack + your team's agents
.\setup.ps1 -Preset typescript -Agent copilot,claude,cursor

# Or just install everything
.\setup.ps1 -Preset python -Agent all

# On macOS/Linux
./setup.sh --preset java --agent all

Copilot files are always installed (they're the canonical source). Additional agent formats layer on top. Use one, some, or all. The guardrails are the same everywhere.

Plan Forge is free and open source. MIT licensed. Pick your stack, pick your agents, and your whole team gets the same quality gates — regardless of which tool they prefer.