> ## Documentation Index
> Fetch the complete documentation index at: https://panopticon-cli.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Harness Landscape

> A survey of coding-agent harnesses Overdeck could drive, and how each one handles skills, MCP, and AGENTS.md

# Harness Landscape

A survey of the AI coding-agent harnesses Overdeck could drive, the skill /
extensibility mechanism each one exposes, and what that means for future
features.

<Note>
  **This is a planning survey, not a support matrix.** Overdeck supports five
  harnesses today — `claude-code`, `ohmypi`, `codex`, native `acp`, and native
  `kimi-code` (see [Harnesses](/configuration/harnesses) for the operational
  guide). Kimi Code CLI is wired two ways: as the first agent through the `acp`
  protocol harness, and natively through `kimi-code`, which drives Kimi's own
  terminal UI directly with no ACP host in between. Other tools on this page
  remain surveyed for evaluation until their provider adapters land. Facts are
  current as of May 2026 unless a profile says otherwise and should be
  re-verified before any decision. Items flagged **⚠ verify** could not be
  cleanly confirmed.
</Note>

## Why this document exists

The field is now large enough, and converging fast enough on shared standards,
that "which harness next?" is a real product question. It is also entangled with
a specific feature request — [template conversations](/reference/template-conversations),
the ability to load a curated *group* of skills into one conversation. Some
harnesses have a native primitive for exactly that; others would need Overdeck
to synthesize it. This survey records the facts needed to weigh both.

## Harness vs. model

A **harness** is the binary that runs in tmux and drives a workspace — it owns
the agent loop, tool calls, context management, and the on-disk extensibility
surface. A **model** is the LLM the harness calls. They are chosen
independently. "Adding a harness" means teaching Overdeck a new
`AgentRuntime` adapter (`src/lib/runtimes/`): how to spawn it, deliver prompts,
detect readiness/heartbeat/completion, and parse cost. "Adding a model" is a
routing-table change. This document is about **harnesses**.

## The three extensibility layers

Every modern harness exposes some subset of three *complementary* layers. They
are not competitors — a mature setup uses all three.

| Layer | Answers | Form | When loaded |
| - | - | - | - |
| **AGENTS.md** | "How does this repo work?" | One Markdown file in the repo | Session start, always-on |
| **Agent Skills** (`SKILL.md`) | "How do I do task X?" | Versioned folder, may bundle scripts/assets | Name+description always; body on-demand |
| **MCP** (Model Context Protocol) | "How do I reach external system Y?" | Running JSON-RPC server | Connect-time, persistent |

* **AGENTS.md** — an open, tool-agnostic standard (a "README for agents"):
  setup commands, conventions, build/test instructions. Emerged 2025 from a
  cross-vendor effort (OpenAI Codex, Amp, Cursor, Factory, Google Jules), now
  stewarded by the **Agentic AI Foundation** under the Linux Foundation. Read by
  25+ tools.
* **Agent Skills / `SKILL.md`** — originated in Claude Code; Anthropic released
  the spec as an **open standard** (most sources: 2025-12-18). A skill is a
  directory with a required `SKILL.md` (YAML frontmatter: `name` +
  `description` required) plus optional `scripts/`, `references/`, `assets/`,
  `templates/`. Three-stage progressive disclosure: discovery (load
  name+description) → activation (load body on task match) → execution (run
  bundled code). By early 2026, \~32 tools read `SKILL.md` — skills are portable
  across harnesses with no modification.
* **MCP** — the live-tool-connection protocol. Near-universal, with one notable
  holdout (ohmypi/omp).

<Info>
  **Why this matters for Overdeck:** `SKILL.md` portability means Overdeck's
  own `skills/` tree is *already* harness-agnostic. The same skill directories
  `pan sync` writes to `~/.claude/skills/` are loadable, unmodified, by Codex,
  Gemini CLI, Cursor, OpenCode, Goose, Amp, Crush, and ohmypi. Adding a harness does
  **not** mean re-authoring skills — it means teaching that harness where to read
  them.
</Info>

## What Overdeck supports today

| Harness | Status | Runtime adapter |
| - | - | - |
| `claude-code` | **Supported** (default) | none needed — drop-in `claude` |
| `ohmypi` | **Supported** (alternative) | `src/lib/runtimes/ohmypi.ts` + vendored `packages/ohmypi-extension/` |
| `codex` | **Supported** (alternative) | `src/lib/runtimes/codex.ts` |
| `acp` | **Supported** (Kimi first) | `src/lib/runtimes/acp.ts` + vendored `packages/effect-acp/` |
| `kimi-code` | **Supported** (native, Kimi-only) | `src/lib/runtimes/kimi-code.ts` |
| `opencode` | **Supported** (Go and Zen) | `src/lib/acp/opencode.ts` + shared ACP runtime |

The native `acp` harness is a reusable protocol integration, but version one
uses the `acp` harness name for Kimi Code CLI. OpenCode Go and Zen use the
`opencode` harness name with the shared ACP transport. `kimi-code` is a
separate, capability-layer harness: it drives Kimi's own terminal UI and wire
protocol directly, reaching Kimi-specific behavior the ACP lowest-common-
denominator surface can't. The remaining profiles are surveyed for planning
unless their status explicitly says supported.

## ACP-capable agents

Overdeck now speaks [Agent Client Protocol](https://agentclientprotocol.com/)
natively, so adding another ACP-speaking CLI no longer requires inventing a
new transport, event stream, permission channel, or session lifecycle. It does
still require a provider adapter that names the executable, arguments, and
authentication method; Overdeck fails loudly rather than treating protocol
compatibility as automatic support.

| ACP agent | Overdeck status | Next integration work |
| - | - | - |
| **Kimi Code CLI** | **Wired now** through `kimi acp` | None for version one; run interactive `/login` once before use. |
| **OpenCode** | **Wired now** through `opencode acp` | Go and Zen; sign in with `opencode auth login`. |
| **Cursor CLI** | ACP-reachable next | Register its executable, launch arguments, and authentication mapping. |
| **Grok CLI** | ACP-reachable next | Register its executable, launch arguments, and authentication mapping. |
| **Google Gemini CLI** | ACP-reachable next | Register its executable, launch arguments, and authentication mapping. |

Kimi K3 supports Low, High, and Max effort through both native CLI and ACP.
Overdeck initializes managed K3 sessions at High unless another effort was
selected. Native launches use the per-process `KIMI_MODEL_THINKING_EFFORT`
override; ACP sets the session's `thinking` option after selecting the model.
Overdeck does not edit the shared Kimi configuration. Saved Medium maps to High,
and Extra High maps to Max. K2.7 Code and HighSpeed always think and do not
offer adjustable effort. Overdeck stores canonical levels for K3 (`kimi-code/k3`
included) and translates at launch, so a saved Medium launches as High and
Extra High as Max on both routes.

For a running ACP session, the host accepts the authenticated `set-effort`
operation with an `effort` string. It acknowledges the normalized effort only
after Kimi accepts the session configuration change. Invalid values and models
without adjustable effort are rejected.

For Claude Code, the saved `kimi-k2.7-code` selection launches as
`kimi-for-coding` when using a Kimi coding-subscription key. The main model
and tier/subagent model variables use the same endpoint mapping. Moonshot
platform keys retain `kimi-k2.7-code`.

The native/ACP aliases `kimi-code/k3` and `kimi-code/k3-256k` have context
windows of 1,048,576 and 262,144 tokens, respectively. Both K2.7 variants have
262,144 tokens. K3's full 1M window requires the corresponding membership
entitlement. See the [official Kimi model reference](https://www.kimi.com/code/docs/en/kimi-code/models.html).

Kimi is therefore a supported agent through the `acp` harness. Cursor, Grok,
and Gemini remain candidates: their ACP support reduces the adapter to
provider-specific startup and auth, but they are not selectable until those
adapters and probes land.

## Harness profiles

Each profile follows the same shape. Versions are "latest observed, May 2026"
and should be re-checked before any decision.

### Claude Code — Supported (default)

* **Vendor / model:** Anthropic. Anthropic models; non-Anthropic via CLIProxy.
* **OSS / license:** Proprietary (binary distribution).
* **Auth:** Claude Code OAuth subscription **or** Anthropic API key (exclusive).
* **Extensibility:** The richest surface in the field —
  * **Skills** at enterprise / personal (`~/.claude/skills/`) / project
    (`.claude/skills/`) / plugin scope, with name-conflict precedence
    enterprise > personal > project; plugin skills are namespaced and cannot
    conflict.
  * **Plugins** — distributable bundles (`.claude-plugin/plugin.json`) that can
    carry skills, subagents, commands, hooks, MCP servers, LSP servers,
    monitors, binaries, and output styles. **Marketplaces**
    (`.claude-plugin/marketplace.json`) catalog them; `/plugin marketplace add`,
    `/plugin install`.
  * **Session-scoped loading** — `--plugin-dir <path>`, `--plugin-url <url>`,
    `--agents '<json>'`, `--mcp-config` (+`--strict-mcp-config`),
    `--settings <file|json>`. This is the basis for
    [template conversations](/reference/template-conversations).
  * **Subagents** (`.claude/agents/*.md`, `--agents`), **hooks**, **output
    styles**, **MCP** (local/project/user/plugin scopes).
* **Headless:** `claude -p` / print mode; structured output; `--agent` to run
  the main thread as a named agent.
* **Why it's the default:** required for Anthropic-subscription users; the
  largest agent/skill/plugin surface; Overdeck's pipeline prompts assume it.

### oh-my-pi (ohmypi) — Supported (alternative)

* **Vendor / model:** oh-my-pi project (`@oh-my-pi/pi-coding-agent`, binary `omp`). **30+ providers** via its
  `pi-ai` layer — subscription auth for Anthropic, OpenAI, GitHub Copilot;
  API-key for \~25 more (Gemini, Vertex, Bedrock, Groq, Cerebras, xAI,
  OpenRouter, MiniMax, DashScope, …).
* **OSS / license:** MIT. TypeScript / Node.
* **Install:** `npm install -g @oh-my-pi/pi-coding-agent` — provides the `omp` binary.
* **Extensibility:**
  * **Skills** — reads `SKILL.md`. Discovery: `~/.omp/agent/skills/`,
    `.omp/skills/`, `~/.agents/skills/`, `.agents/skills/`, `skills/` in
    `package.json`, the `skills` array in `settings.json`, **and the repeatable
    `--skill <path>` CLI flag.** The `settings.json` `skills` array accepts
    arbitrary directories — Overdeck exploits this by writing
    `~/.omp/agent/settings.json` with `"skills": ["~/.claude/skills"]`.
  * **Extensions** — TypeScript modules subscribing to a rich lifecycle-event
    bus (`session_start`, `tool_execution_end`, `agent_start/end`, …); loaded by
    auto-discovery, `settings.json`, or `--extension`. Overdeck vendors one at
    `packages/ohmypi-extension/`.
  * **No MCP** — a deliberate design stance. omp tells users to wrap CLI tools as
    skills instead. The only path to MCP is a custom extension.
  * **AGENTS.md** read by default.
* **Headless:** `omp --mode rpc` — JSONL command/event protocol over stdin/stdout
  (Overdeck delivers commands via a named-pipe `mkfifo`).
* **Why it's supported:** multi-provider without CLIProxy; named-pipe RPC is
  faster than tmux paste-buffer; the only ToS-blocked cell is `ohmypi` + Anthropic
  model + Anthropic subscription auth.
* **Implementation files:** `src/lib/runtimes/ohmypi.ts`, `src/lib/runtimes/ohmypi-fifo.ts`,
  `src/lib/cost-parsers/ohmypi-parser.ts`, `packages/ohmypi-extension/`.

### OpenAI Codex CLI — Supported

* **Vendor / model:** OpenAI. OpenAI-centric (GPT-5.4, GPT-5.3-Codex); `--oss`
  flag runs open-weight models on local Ollama/LM Studio/MLX. Non-OpenAI cloud
  providers need a translating gateway.
* **OSS / license:** Open source, **Apache-2.0**. Written in **Rust**. Install
  via `npm i -g @openai/codex` or Homebrew. v0.133.0 (2026-05-21).
* **Auth:** Sign in with ChatGPT (Plus/Pro/Business/Edu/Enterprise) **or** API
  key. Overdeck's CLIProxy already mints ChatGPT-subscription tokens.
* **Extensibility:**
  * **Skills — yes**, `SKILL.md`, Claude Code-compatible. `~/.codex/skills/`,
    `.codex/skills/`.
  * **AGENTS.md — yes**, native and layered (root-down concatenation,
    closer-file-overrides, 32 KiB cap).
  * **MCP — yes**; Codex can also *run as* an MCP server (`codex mcp-server`).
  * Profiles in `config.toml` selected via `--profile`.
* **Headless / RPC:** `codex exec` non-interactive; `--json` newline-delimited
  event stream; `--output-schema` for validated output; `codex mcp-server` for
  stdio orchestration. Among the strongest headless interfaces in the field.
* **Why it's supported:** Apache-2.0, native AGENTS.md + skills, excellent
  headless story, and Overdeck's ChatGPT-subscription auth already exists. The
  Codex harness gives GPT-subscription users a first-party OpenAI agent loop
  (GPT-5.6 Sol as the current flagship, GPT-5.5 as the previous flagship and still
  supported, and the rest of the GPT model family) instead of CLIProxy-routing GPT
  into Claude Code. Work agents run as live, attachable TUI sessions
  (`codexMode: work-tui`) under the PTY supervisor — never one-shot `codex exec`.
* **Native terminal:** a conversation's app-server listens on a private Unix
  socket, and the Terminal view runs `codex resume --remote unix://… <threadId>`
  as a second client on the same thread (verified on 0.153.4), next to the
  app-server host's Runtime log.
* **Implementation files:** `src/lib/runtimes/codex.ts`,
  `src/lib/cost-parsers/codex-parser.ts` (per-agent thread-id pinning at
  `~/.overdeck/agents/<id>/codex-thread-id` for session introspection).

### Google Gemini CLI — Not supported (candidate)

* **Vendor / model:** Google. Gemini 3 models, 1M-token context. Google-locked.
* **OSS / license:** Open source, **Apache-2.0**. TypeScript. v0.43.0
  (2026-05-22).
* **Auth:** Google OAuth (free tier) / Gemini API key / Vertex AI (enterprise).
* **Extensibility:**
  * **Skills — yes**, `SKILL.md`, four discovery tiers (built-in →
    extension-bundled → user `~/.gemini/skills/` or `~/.agents/skills/` →
    workspace). Activated via an `activate_skill` tool with a confirmation
    prompt.
  * **⭐ Per-session skill toggling** — `/skills enable <name>` /
    `/skills disable <name>` turn skills on/off **for the current session**.
    This is a *native* primitive close to what template conversations want.
  * **GEMINI.md** context file; **AGENTS.md** opt-in via `contextFileName`.
  * **Extensions** bundle MCP servers + context file + custom TOML commands.
  * **MCP — yes**.
* **Headless / RPC:** `-p`/`--prompt`; `--output-format json` or
  `stream-json` (typed JSONL events); documented exit codes.
* **Why a candidate:** the `/skills enable/disable` primitive is a working
  reference for per-session skill curation; generous free tier; clean headless
  JSONL stream.

### GitHub Copilot CLI — Not supported (candidate)

* **Vendor / model:** GitHub (Microsoft). Runs the *same agentic harness as the
  Copilot coding agent*. Defaults to **Claude Sonnet 4.5**; `/model` switches to
  Claude Sonnet 4, GPT-5, GPT-5 mini, GPT-4.1 (the latter two free of premium
  requests on paid plans). **BYOK** custom models supported. Model access is
  bundled through the Copilot subscription, not direct provider keys.
* **OSS / license:** **Proprietary.** The CLI ships as a closed binary via
  `npm i -g @github/copilot`. The public `github/copilot-cli` repo is install
  scripts (Shell) + issue tracker + docs only — its `LICENSE.md` resolves to
  `NOASSERTION` ("Other"), and it is **not** the agent source. Node.js 22+.
  v1.0.40 (2026-05, \~4 days before survey). Also installable via
  `curl … gh.io/copilot-install`, Homebrew (`copilot-cli`), WinGet.
* **Auth:** GitHub Copilot subscription (Pro / Pro+ / Business / Enterprise) via
  GitHub OAuth — no separate provider API keys. This is GitHub's own model
  bundling, so the Pi-style "subscription + Anthropic model" ToS bar does **not**
  apply (the Claude access is sold *as* Copilot).
* **Extensibility:**
  * **Skills — yes** (since 2025-12-18), `SKILL.md`, Claude Code-compatible
    frontmatter. Discovery: `~/.copilot/skills/`, **`~/.agents/skills/`**, plus
    project skills; `/skills reload` re-scans mid-session. Does **not** read
    `.claude/skills/` natively — but Overdeck already writes the open
    `~/.agents/skills/` tree, so portability holds.
  * **Custom agents** — `.agent.md` files in `.github/agents/` (repo) and
    `~/.copilot/agents/` (user, wins on name conflict), selected via `--agent`.
    Ships built-in **Explore / Ask / Task** agents.
  * **AGENTS.md — yes**, native and layered (root + cwd +
    `COPILOT_CUSTOM_INSTRUCTIONS_DIRS`); merges with
    `.github/copilot-instructions.md` when both exist.
  * **MCP — yes**; ships with the GitHub MCP server pre-configured.
* **Headless / RPC:** `copilot --prompt "…"` non-interactive; `--agent <name>`;
  `--allow-all` / `--yolo` for unattended tool use; `--resume` / `--continue`.
  **⚠ No documented JSON or stream-json output** — interactive terminal text
  only. This is the load-bearing gap for Overdeck, which parses a
  machine-readable event/cost stream to drive readiness, heartbeat, and spend.
* **Why a candidate:** same harness as the Copilot coding agent, native
  AGENTS.md + `SKILL.md` + MCP, and it *defaults to Claude Sonnet 4.5* — a
  Copilot-subscription user could run a first-party GitHub agent loop on Claude
  without an Anthropic subscription. **Why not yet:** proprietary closed binary,
  GitHub-subscription-locked auth, and — most importantly — no machine-readable
  headless output, which makes cost/heartbeat parsing expensive to drive
  compared with Codex (`exec --json`) or Gemini (`stream-json`). Re-verify the
  headless surface (`copilot help`) before any decision — a JSON mode landing
  would materially change the calculus.

### Cursor CLI (`cursor-agent`) — Not supported

* **Vendor / model:** Anysphere. Multi-provider — Anthropic, OpenAI, Gemini,
  plus Cursor's in-house Composer model; `auto` selection.
* **OSS / license:** Proprietary, no public license. Standalone CLI (beta) plus
  the Cursor IDE.
* **Auth:** Cursor subscription; headless via `CURSOR_API_KEY`.
* **Extensibility:**
  * **Skills — yes** (Cursor 2.4+), `SKILL.md`. Reads `.cursor/skills/`,
    `.agents/skills/`, **and `.claude/skills/`** for compatibility — a Claude
    Code skill runs in Cursor unmodified.
  * **Rules** — `.cursor/rules/*.mdc` with four activation modes (always /
    intelligent / auto-attached by glob / manual `@rule`).
  * **AGENTS.md — yes**; **MCP — yes**; Claude Code-compatible **hooks**.
* **Headless / RPC:** `cursor-agent -p`; `--output-format text|json|stream-json`.
* **Why not yet:** proprietary with no license clarity; its differentiators
  (Composer model, IDE) are weak fits for a tmux-driven orchestrator. Skill
  portability means little integration cost if priorities change.

### Warp / Oz — Not supported (notable for skill interop)

* **Vendor / model:** Warp.dev. Multi-provider hosted models (OpenAI, Anthropic,
  Google) on a credit system; BYOK supported.
* **OSS / license:** **⚠ verify** — the terminal client went open source
  April 2026; sources disagree (AGPL-3.0, or dual MIT + AGPL-3.0). The **Oz**
  cloud orchestrator is reported MIT. Rust client.
* **Auth:** Warp account + credits; BYOK provider keys; `WARP_API_KEY` for
  headless Oz.
* **Extensibility:**
  * **Skills — yes**, and the **most aggressive cross-tool reader in the
    field**: Warp loads skills from `.agents/skills/`, `.warp/skills/`, **and
    `.claude/skills/`, `.codex/skills/`, `.cursor/skills/`, `.gemini/skills/`**
    and more. It directly consumes every other harness's skill directory.
  * **Rules** (persistent guidelines, distinct from skills), stored in-repo or
    in **Warp Drive** (shared team config).
  * **AGENTS.md / WARP.md — yes**; **MCP — yes**, and Warp *imports* MCP config
    from Claude Code and Codex.
* **Headless / RPC:** **Oz CLI** — `oz agent run` / `run-cloud`, `--profile`,
  `--mcp`, `--output-format json`. **⚠ verify** depth of the Oz API/SDK.
* **Why notable:** Warp's "read everyone's skill directory" model is the
  end-state of skill portability — a useful design reference even if Warp itself
  is never adopted.

### Amp (Sourcegraph) — Not supported

* **Vendor / model:** Sourcegraph. Multi-model behind named **modes** —
  `smart` (Claude Opus 4.7), `deep` (GPT-5.5 reasoning), `rush` (fast GPT-5.5);
  users pick a mode, not a raw model.
* **OSS / license:** Proprietary. CLI-first (`amp`), plus IDE integrations.
  Consumption/credits billing, no subscription.
* **Auth:** ampcode.com sign-in; `AMP_API_KEY` for headless.
* **Extensibility:** Among the richest non-Anthropic surfaces —
  * **Skills — yes**, `SKILL.md`; a skill can **bundle its own MCP server**
    (`mcp.json` inside the skill folder, tools hidden until the skill
    activates). `amp.skills.path` adds extra skill dirs.
  * **AGENTS.md — yes** (also reads `AGENT.md`, `CLAUDE.md`).
  * **Plugins** — event-driven **TypeScript** extensions (`.amp/plugins/*.ts`)
    with `session.start`/`tool.call`/… hooks, `registerCommand`,
    `registerTool` — the most powerful programmatic extension surface surveyed.
  * **Toolboxes** (script-based tools, no MCP server); **MCP — yes**.
* **Headless / RPC:** `amp -x`; `--stream-json` output, `--stream-json-input`
  for multi-turn stdin, mid-run steering.
* **Why notable:** skill-bundled MCP and the TS plugin API are design ideas
  worth borrowing regardless of adoption.

### OpenCode — Supported through ACP (Go and Zen)

Overdeck supports persistent OpenCode ACP sessions with the `opencode` (Zen)
and `opencode-go` provider namespaces. Verified version: 1.18.29. See
[OpenCode setup](/configuration/harnesses#opencode-with-go-and-zen) for credentials,
model discovery, resume behavior, and current transport limitations.

* **Vendor / model:** SST / Anomaly. Provider-agnostic — any LLM provider via
  configurable keys; ships a curated "OpenCode Zen" model list.
* **OSS / license:** Open source (**⚠ verify exact license**). The live repo is
  `anomalyco/opencode` — distinct from the archived Go `opencode-ai/opencode`.
* **Auth:** native saved credentials; OpenCode Go subscription or OpenCode Zen billing.
* **Extensibility:**
  * **Skills — yes**, `SKILL.md`; reads `.opencode/skills/`, `.claude/skills/`,
    `.agents/skills/` (and `~/` equivalents). Pattern-based per-agent skill
    permissions in `opencode.json`.
  * **⭐ Custom Agents** — primary agents (Build / Plan) and subagents
    (General / Explore / Scout), each a markdown file or `opencode.json` entry
    with its own `model`, `prompt`, `permission`, `temperature`, `tools`. The
    closest thing OpenCode has to a loadable per-session profile.
  * **AGENTS.md — yes**; **MCP — yes**.
* **Transport:** persistent `opencode acp`, verified with session creation,
  message delivery, and resume on 1.18.29. Overdeck reuses its ACP transcript and
  message transport while retaining the OpenCode harness identity.
* **Native terminal:** the conversation Terminal view runs `opencode attach` against
  the same server and session (verified on 1.18.31), next to the ACP host's
  Runtime log.
* **Provider scope:** Go and Zen. Other OpenCode providers are outside this integration.

### Goose (Block) — Not supported (strongest "bundle" primitive)

* **Vendor / model:** Block. 15+ providers (Anthropic, OpenAI, Google, Ollama,
  OpenRouter, Bedrock, …); can also bridge existing subscriptions via the
  **Agent Client Protocol (ACP)**.
* **OSS / license:** Open source, **Apache-2.0**. **Rust**. Desktop app + full
  CLI + embeddable API. Contributed to the Linux Foundation's Agentic AI
  Foundation (Dec 2025), alongside MCP and AGENTS.md.
* **Auth:** per-provider API keys; local models need none.
* **Extensibility:**
  * **Skills — yes**, `SKILL.md`; reads `~/.agents/skills/`, `.agents/skills/`,
    **`.claude/skills/`, `~/.claude/skills/`**, `.goose/skills/`.
  * **⭐⭐ Recipes** — portable **YAML** files that bundle `title`,
    `description`, typed templated `parameters`, `prompt`, **required
    extensions**, retry logic, and **subrecipes**. Shareable, CI-runnable. This
    is the **strongest native "load a curated bundle into a session"
    primitive** of any harness surveyed — it is, structurally, a "conversation
    template."
  * **.goosehints** (persistent project context); **AGENTS.md — yes**.
  * **Extensions = MCP** — 70+ first-party, plus the 3,000+ community MCP
    servers.
* **Headless / RPC:** `goose run` (`-t`, `--recipe`, `--no-session`); embeddable
  API.
* **Why notable:** if Overdeck ever wants a *native* per-session bundle
  instead of synthesizing one, Goose Recipes are the reference design — and a
  concrete reason to consider adopting Goose specifically.

### Charm Crush — Not supported

* **Vendor / model:** Charmbracelet. Multi-provider — Anthropic, OpenAI, Gemini,
  Groq, OpenRouter, Bedrock, Azure, Copilot, MiniMax, DashScope, +15 more.
* **OSS / license:** **Source-available, FSL-1.1-MIT** (Functional Source
  License — converts to MIT after a delay; not OSI-open at release). **Go**.
* **Auth:** API keys; also subscription plans from Synthetic, Z.ai, Kimi,
  MiniMax, DashScope.
* **Extensibility:**
  * **Skills — yes**, open Agent Skills standard; `user-invocable: true`
    surfaces a skill in the command palette.
  * **AGENTS.md — yes** (default generated context file; `CRUSH.md` also).
  * **MCP — yes** (stdio/http/sse); **LSP** integration; preliminary **hooks**.
* **Headless / RPC:** `crush run -q` (**⚠ verify** JSON output options — least
  documented headless interface surveyed).
* **Why not yet:** FSL licensing is a redistribution caveat; headless interface
  underdocumented.

### Aider — Not supported (poor fit)

* **Vendor / model:** Aider-AI (Paul Gauthier). Widest model support surveyed —
  OpenAI, Anthropic, Gemini, Azure, DeepSeek, Bedrock, Vertex, xAI, OpenRouter,
  Groq, Copilot, local via Ollama/LM Studio, any OpenAI-compatible endpoint.
* **OSS / license:** Open source, **Apache-2.0**. **Python**. v0.86.0
  (2025-08-09 — **⚠ verify** newer release).
* **Auth:** API keys only.
* **Extensibility — the field's outlier:**
  * **No Agent Skills** — does not implement `SKILL.md`.
  * **No native AGENTS.md.**
  * **No MCP** (open RFC only).
  * Customization is `CONVENTIONS.md` files loaded via `--read` / `/read` or
    `.aider.conf.yml`. Built-in slash commands only; no plugins.
* **Headless / RPC:** `--message` / `--message-file`; **no JSON output**; an
  unsupported, unstable Python API.
* **Why a poor fit:** no skills, no MCP, no machine-readable output. Aider's
  one-commit-per-change model is excellent for solo pairing but ill-suited to an
  orchestrator. Skill portability gives Overdeck *nothing* here — Aider can't
  read the `skills/` tree at all.

### Cline — Not supported

* **Vendor / model:** Cline Bot Inc. Multi-provider (Anthropic, OpenAI, Gemini,
  OpenRouter 200+, Bedrock, Vertex, Cerebras, Groq, Ollama, …).
* **OSS / license:** Open source, **Apache-2.0**. TypeScript. Historically a
  VS Code extension; now also a preview CLI, a Node SDK (`@cline/sdk`), and a
  web Kanban multi-agent board.
* **Auth:** per-provider API keys; optional Cline account.
* **Extensibility:**
  * **Rules** — `.clinerules/` directory; **⭐ each rule has a per-session
    UI toggle** (its main per-session-curation primitive).
  * **AGENTS.md — yes** (Agent Rules spec v1.0).
  * **Skills (`SKILL.md`) — ⚠ unverified, likely not first-class** — docs
    describe rules + Workflows, not the `SKILL.md` format.
  * **MCP — yes** (first-class since 2024).
* **Headless / RPC:** preview CLI with JSON output; `@cline/sdk` programmatic
  agent API.
* **Why not yet:** historically IDE-bound; uncertain `SKILL.md` support means
  Overdeck's `skills/` tree may not port cleanly.

### Continue — Not supported (notable for the bundle primitive)

* **Vendor / model:** Continue.dev. Multi-provider. Open source. IDE extension
  plus a CLI (`cn`).
* **Extensibility:** Its defining concept is **Continue Agents** — shareable,
  remixable definitions in `config.yaml` that bundle **models + rules + tools
  (MCP servers)** together. `cn --rule <namespace/name>` pulls a specific
  hub-hosted rule into one session. **AGENTS.md / SKILL.md — ⚠ unverified,
  likely not first-class.**
* **Why notable:** like Goose Recipes, "Continue Agents" are a native
  loadable-bundle primitive — a second reference design for template
  conversations.

## Comparison matrix

| Harness | OSS / License | Lang | `SKILL.md` | Reads `.claude/skills` | AGENTS.md | MCP | Headless JSON | Native per-session bundle | Overdeck |
| - | - | - | - | - | - | - | - | - | - |
| **Claude Code** | Proprietary | — | ✅ | ✅ (own) | Fallback only¹ | ✅ | ✅ | Synth via `--plugin-dir` | **Supported** |
| **Pi** | MIT | TS | ✅ | ✅ | ✅ | ❌ (by design) | ✅ (RPC) | `--skill` flag | **Supported** |
| **Codex CLI** | Apache-2.0 | Rust | ✅ | ✅ | ✅ native | ✅ (+is a server) | ✅ | Profiles | Candidate |
| **Gemini CLI** | Apache-2.0 | TS | ✅ | ✅ | Opt-in | ✅ | ✅ | ⭐ `/skills enable` | Candidate |
| **Copilot CLI** | Proprietary | — | ✅ | ❌ (`~/.agents`) | ✅ native | ✅ | ❌ ⚠ | `.agent.md` | Candidate |
| **Cursor CLI** | Proprietary | — | ✅ | ✅ | ✅ | ✅ | ✅ | Rule scopes | No |
| **Warp / Oz** | ⚠ AGPL-3.0? | Rust | ✅ | ✅ (+all dirs) | ✅ | ✅ (imports) | ✅ | Oz `--profile` | No |
| **Amp** | Proprietary | — | ✅ | ❌ | ✅ | ✅ | ✅ | TS plugins | No |
| **OpenCode** | OSS ⚠ | TS | ✅ | ✅ | ✅ | ✅ | ✅ | ⭐ Custom Agents | Go and Zen via ACP |
| **Goose** | Apache-2.0 | Rust | ✅ | ✅ | ✅ | ✅ (=ext) | ✅ | ⭐⭐ Recipes | Candidate |
| **Crush** | FSL-1.1-MIT | Go | ✅ | ⚠ | ✅ | ✅ | ⚠ | — | No |
| **Aider** | Apache-2.0 | Python | ❌ | ❌ | ❌ | ❌ | ❌ | — | No (poor fit) |
| **Cline** | Apache-2.0 | TS | ⚠ | — | ✅ | ✅ | ✅ | ⭐ rule toggles | No |
| **Continue** | OSS | TS | ⚠ | — | ⚠ | ✅ | ✅ | ⭐ Continue Agents | No |

¹ Claude Code uses `CLAUDE.md`; AGENTS.md works only as a fallback when no
`CLAUDE.md` exists, or via explicit `@AGENTS.md` import. Native support is an
open feature request ([anthropics/claude-code#34235](https://github.com/anthropics/claude-code/issues/34235)).

⭐ = a native primitive relevant to [template conversations](/reference/template-conversations).

## Implications for Overdeck

1. **Skill portability is real and already paid for.** Overdeck's `skills/`
   tree is `SKILL.md`-format. Codex, Gemini CLI, Cursor, OpenCode, Goose, Amp,
   Warp, and ohmypi all read `SKILL.md`, and most read `.claude/skills/` directly.
   Adding any of them is a *runtime adapter* problem, not a *skill re-authoring*
   problem. **Aider is the lone exception** — no skills, no MCP, no JSON output;
   not worth pursuing.

2. **Codex CLI is the highest-value next harness.** Apache-2.0, native
   AGENTS.md + skills, a best-in-class headless interface (`codex exec --json`,
   and it can *be* an MCP server), and Overdeck **already mints
   ChatGPT-subscription tokens via CLIProxy**. The Codex harness would give
   GPT-subscription users a first-party OpenAI agent loop instead of routing GPT
   through Claude Code.

3. **For template conversations, harness choice matters.** Three harnesses ship
   a *native* loadable-bundle primitive that Overdeck would otherwise have to
   synthesize:

   * **Goose Recipes** — parameterized YAML bundles of prompt + extensions +
     subrecipes. Structurally identical to a "conversation template."
   * **Continue Agents** — `config.yaml` bundles of models + rules + tools.
   * **Gemini CLI `/skills enable/disable`** — true per-session skill toggling.

   Claude Code and ohmypi have no native bundle object, but **can synthesize one**:
   Claude Code via `--plugin-dir`, ohmypi via repeatable `--skill`. The
   [template-conversations proposal](/reference/template-conversations) builds
   on those. "Adding a harness specifically for its bundle primitive" is
   therefore a *real option* — Goose is the candidate if Overdeck wants the
   primitive native rather than synthesized.

4. **MCP is near-universal; ohmypi is the exception.** Any feature that assumes MCP
   availability must account for ohmypi rejecting MCP by design.

5. **Headless quality varies and gates orchestration.** Codex, Gemini CLI,
   Cursor, and Amp have first-class JSON/stream interfaces. Aider has none.
   Crush's is underdocumented. **Copilot CLI has a non-interactive `--prompt`
   mode but no documented machine-readable output** — a real gate, since
   Overdeck parses an event/cost stream to drive readiness, heartbeat, and
   spend. A harness without a machine-readable interface is expensive for
   Overdeck to drive, regardless of how good its model access is.

6. **Re-verify before deciding.** Flagged ⚠ items — Warp's license,
   OpenCode/Crush licenses and headless schemas, Cline's
   `SKILL.md` support, the Agent Skills spec date — must be confirmed against
   primary sources at decision time. This document is a snapshot of a
   fast-moving field.

## Sources

Primary documentation consulted (May 2026):

* Claude Code — [code.claude.com/docs](https://code.claude.com/docs/en/skills)
* oh-my-pi — [oh-my-pi/pi-coding-agent](https://github.com/oh-my-pi/pi-coding-agent)
* Codex CLI — [openai/codex](https://github.com/openai/codex),
  [developers.openai.com/codex](https://developers.openai.com/codex/cli)
* Gemini CLI — [google-gemini/gemini-cli](https://github.com/google-gemini/gemini-cli)
* Copilot CLI — [github/copilot-cli](https://github.com/github/copilot-cli),
  [docs.github.com/copilot/concepts/agents/about-copilot-cli](https://docs.github.com/en/copilot/concepts/agents/about-copilot-cli),
  [Agent Skills changelog (2025-12-18)](https://github.blog/changelog/2025-12-18-github-copilot-now-supports-agent-skills/)
* Cursor — [cursor.com/docs/cli](https://cursor.com/docs/cli/overview)
* Warp — [docs.warp.dev/agent-platform](https://docs.warp.dev/agent-platform/)
* Amp — [ampcode.com/manual](https://ampcode.com/manual)
* OpenCode — [opencode.ai/docs](https://opencode.ai/docs/)
* Goose — [goose-docs.ai](https://goose-docs.ai/)
* Crush — [charmbracelet/crush](https://github.com/charmbracelet/crush)
* Aider — [aider.chat/docs](https://aider.chat/docs/)
* Cline — [cline/cline](https://github.com/cline/cline)
* Continue — [docs.continue.dev](https://docs.continue.dev/)
* Standards — [agents.md](https://agents.md/),
  [agentskills/agentskills](https://github.com/agentskills/agentskills),
  [vercel-labs/skills](https://github.com/vercel-labs/skills)

## See also

* [Harnesses](/configuration/harnesses) — operational guide for the two
  supported harnesses (install, picker locations, ToS rules, troubleshooting)
* [Template Conversations](/reference/template-conversations) — proposal:
  loading curated skill bundles into a single conversation
* [Skills System](/features/skills) — how Overdeck distributes skills


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.