# Agents

Forge configures a **superset of 24 AI coding agents** — plus a `generic`
adapter for anything else. Its core is agent-agnostic: a single unified command
set is translated by **per-agent adapters** into each agent's native command
format and directories. Every command is written as a `/forge.<name>` slash
command in whatever form that agent expects.

::: info Agent-agnostic core, per-agent adapters
Forge holds one canonical model of its commands. Adapters do the translation, so
adding or improving support for an agent never changes the core — and every
agent ends up speaking the same spec-driven language.
:::

::: warning You choose the agent and provider — and their terms apply
Forge configures these agents but runs **none** of them: it performs no AI
inference and sends nothing to any provider. When you drive an agent, the code and
context that reach its model do so under **that agent's and model provider's own
terms and compliance posture** (including their EU AI Act GPAI obligations). The
choice of agent, model, and provider — and responsibility for their terms — is
yours. See the [EU AI Act Position](/compliance/eu-ai-act).
:::

## Recommended: Claude Code

**Claude Code is the recommended agent** and has the fullest support:

- **Subagents** via the Task tool
- **Output styles**
- **MCP** (Model Context Protocol) servers
- **Hooks**

These capabilities let the harness integrate most deeply — the circuit-breaker,
budget ledger, and attributed timeline can auto-populate from live agent
activity. See [live agent hooks](/harness/live-agent-hooks).

## Supported agents

Beyond Claude Code, Forge drives twenty-three more agents. Each receives the same
`/forge.<name>` command set through its own adapter. The **Sub-agents** column
marks the agents that can run the SDD workflow in `--sdd-mode multi` — one thin
coordinating thread dispatching each phase to a dedicated sub-agent. The rest
fall back to single-thread execution.

| Agent | Sub-agents |
| --- | --- |
| OpenCode | Yes |
| Kilo Code | Yes |
| Gemini CLI | — |
| Codex | — |
| Cursor | — |
| VS Code Copilot | — |
| Google Antigravity | — |
| Windsurf | — |
| Kimi Code | — |
| Qwen Code | — |
| Kiro IDE | Yes |
| OpenClaw | — |
| Pi | Yes |
| Trae IDE | — |
| Hermes | — |
| Roo Code | — |
| IBM Bob | — |
| Amazon Q Developer CLI | — |
| Amp | — |
| Qoder CLI | — |
| CodeBuddy CLI | — |
| Auggie CLI | — |
| SHAI | — |

Claude Code supports sub-agents too — see [above](#recommended-claude-code).
See [SDD modes](/guide/components#sdd-modes) for what `multi` changes.

::: info VS Code Copilot's "—" isn't a gap
VS Code Copilot's adapter intentionally does not use the live sub-agent injection path every other agent in this table does — `forge plugin build`/`install` instead bundles the same subagent templates into a self-contained VS Code Agent Plugin. See [VS Code Agent Plugin](/features/vscode-plugin).
:::

## The `generic` adapter

For anything not covered by a dedicated adapter, Forge provides a **`generic`
adapter** — a bring-your-own command directory. Point it at a command directory
and Forge writes the same `/forge.<name>` command set there, so even agents
without first-class support can drive the Forge workflow.

::: info One command set, every target
The `generic` adapter emits the identical `/forge.<name>` set — it only lacks
the deeper native hooks (sub-agents, output styles, live harness telemetry) that
first-class adapters wire up. Coverage differs; the command surface does not.
:::

## How adapters work

```mermaid
flowchart TD
  Core[Agent-agnostic core] --> A1[Claude Code adapter]
  Core --> A2[Cursor adapter]
  Core --> A3[OpenCode adapter]
  Core --> A4[... 13 more adapters]
  Core --> Gen[generic adapter]
  A1 --> D1[.claude/commands/, .claude/agents/]
  A2 --> D2[Cursor native dirs]
  A3 --> D3[OpenCode native dirs]
  Gen --> DG[your command dir]
```

Each adapter translates the unified configuration into its agent's native
command format and directories, and writes each command as a `/forge.<name>`
slash command. Agent-specific files are written **outside** `.forge/` — for
example Claude Code's commands and subagents live under `.claude/commands/` and
`.claude/agents/`. See [Project Structure](/guide/project-structure).

## Detecting and enabling agents

Forge **detects** which agents are installed on your machine — it never asks you
to name them. `forge install` configures every detected agent by default. You
can narrow that:

```sh
forge install --agents claude-code,cursor,opencode
```

Or restrict enabled agents in configuration:

```yaml
agents:
  scope: workspace
  enabled:
    - claude-code
    - cursor
```

See [Configuration](/guide/configuration#agents) for the full `agents` section.

## Next steps

- [Installation](/installation) — run `forge install` to configure your agents.
- [Commands](/guide/commands) — the command set every agent receives.
- [Components](/guide/components) — SDD modes and what `multi` needs.
- [Project Structure](/guide/project-structure) — where agent files are written.
- [Live agent hooks](/harness/live-agent-hooks) — connect the harness to your
  agent.