​

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.

​

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, 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.

• 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).

​

What Overdeck supports today

The native acp harness is a reusable protocol integration, but version one registers only Kimi Code CLI as a selectable ACP provider. The remaining profiles are surveyed for planning unless their status explicitly says supported.

​

ACP-capable agents

Overdeck now speaks Agent Client Protocol 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. 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.
  • 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.
• 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 — Not supported (candidate)

• 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 sst/opencode — distinct from the archived Go opencode-ai/opencode.
• Auth: per-provider API keys; 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.
• Headless / RPC: CLI run mode, Web mode, Server/SDK mode — drivable by an orchestrator (⚠ verify exact flags/JSON schema).
• Why a candidate: fully open, multi-provider, SKILL.md-native, and its custom-Agent model is a clean fit for Overdeck’s role taxonomy.

​

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

¹ 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). ⭐ = a native primitive relevant to 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 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
• oh-my-pi — oh-my-pi/pi-coding-agent
• Codex CLI — openai/codex, developers.openai.com/codex
• Gemini CLI — google-gemini/gemini-cli
• Copilot CLI — github/copilot-cli, docs.github.com/copilot/concepts/agents/about-copilot-cli, Agent Skills changelog (2025-12-18)
• Cursor — cursor.com/docs/cli
• Warp — docs.warp.dev/agent-platform
• Amp — ampcode.com/manual
• OpenCode — opencode.ai/docs
• Goose — goose-docs.ai
• Crush — charmbracelet/crush
• Aider — aider.chat/docs
• Cline — cline/cline
• Continue — docs.continue.dev
• Standards — agents.md, agentskills/agentskills, vercel-labs/skills

​

See also

• Harnesses — operational guide for the two supported harnesses (install, picker locations, ToS rules, troubleshooting)
• Template Conversations — proposal: loading curated skill bundles into a single conversation
• Skills System — how Overdeck distributes skills