{
 "verified": "2026-10-12",
 "levels": {
  "yes": "Yes",
  "partial": "Partial",
  "no": "No",
  "unknown": "Not documented"
 },
 "columns": [
  {
   "key": "instr_global",
   "label": "Global instructions"
  },
  {
   "key": "instr_project",
   "label": "Project instructions"
  },
  {
   "key": "instr_nested",
   "label": "Nested / subfolder"
  },
  {
   "key": "agents_md",
   "label": "AGENTS.md"
  },
  {
   "key": "skills",
   "label": "Skills (SKILL.md)"
  },
  {
   "key": "mcp",
   "label": "MCP config"
  },
  {
   "key": "permissions",
   "label": "Permissions / allowlist"
  },
  {
   "key": "sandbox",
   "label": "Sandbox"
  },
  {
   "key": "hooks",
   "label": "Hooks"
  },
  {
   "key": "sub_claude",
   "label": "Claude Pro/Max login"
  },
  {
   "key": "sub_chatgpt",
   "label": "ChatGPT Plus/Pro login"
  },
  {
   "key": "api_key",
   "label": "API key / own plan"
  }
 ],
 "agents": [
  {
   "slug": "claude-code",
   "name": "Claude Code",
   "tool": "claude-code",
   "vendor": "Anthropic",
   "surfaces": [
    "cli",
    "ide"
   ],
   "title": "Claude Code Config Guide: CLAUDE.md, settings.json Permissions, MCP",
   "desc": "Where Claude Code reads CLAUDE.md, AGENTS.md, rules and skills, how .mcp.json works, and a copy-paste settings.json that blocks rm -rf, force-push and DROP TABLE.",
   "answer": "Claude Code reads `CLAUDE.md` (project root or `.claude/CLAUDE.md`), `CLAUDE.local.md`, `~/.claude/CLAUDE.md` and `.claude/rules/*.md`. Since v2.1.277 it also reads `AGENTS.md`, but by default only when no `CLAUDE.md` exists in the working directory or above it. Permissions live in `settings.json` as `allow` / `ask` / `deny` rules (deny wins). MCP servers go in `.mcp.json` (project) or `~/.claude.json` (user). You can log in with a Claude Pro or Max subscription or use an API key.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`~/.claude/CLAUDE.md`, `~/.claude/rules/*.md`; org-managed `/etc/claude-code/CLAUDE.md` (Linux) or `/Library/Application Support/ClaudeCode/CLAUDE.md` (macOS)"
    },
    "instr_project": {
     "level": "yes",
     "text": "`CLAUDE.md` or `.claude/CLAUDE.md`, personal `CLAUDE.local.md`, `.claude/rules/*.md` (optional `paths:` globs); loaded from the working dir and every parent dir"
    },
    "instr_nested": {
     "level": "yes",
     "text": "Subdirectory `CLAUDE.md` loads on demand when Claude reads or edits a file there"
    },
    "agents_md": {
     "level": "partial",
     "text": "Yes since v2.1.277, but only if there is no `CLAUDE.md` / `CLAUDE.local.md` in the working dir or above (default). Set Project instructions to `claude-md-and-agents-md` to read both. `@AGENTS.md` import always works"
    },
    "skills": {
     "level": "yes",
     "text": "`~/.claude/skills/<name>/SKILL.md`, `.claude/skills/<name>/SKILL.md`. `.agents/skills` is not listed in the docs"
    },
    "mcp": {
     "level": "yes",
     "text": "`.mcp.json` at project root (shared, needs approval); user and local scopes in `~/.claude.json`; `claude mcp add --scope project|user|local`"
    },
    "permissions": {
     "level": "yes",
     "text": "`permissions.allow` / `ask` / `deny` in `~/.claude/settings.json`, `.claude/settings.json`, `.claude/settings.local.json`, managed settings. Deny > ask > allow. Modes: default, acceptEdits, plan, auto, dontAsk, bypassPermissions"
    },
    "sandbox": {
     "level": "yes",
     "text": "Opt-in: `/sandbox` or `sandbox.enabled: true`. Seatbelt on macOS, bubblewrap + socat on Linux/WSL2"
    },
    "hooks": {
     "level": "yes",
     "text": "`hooks` in settings.json: PreToolUse, PostToolUse, SessionStart, Stop, UserPromptSubmit and more; exit code 2 blocks a tool call"
    },
    "sub_claude": {
     "level": "yes",
     "text": "Log in with Claude Pro or Max (also Team/Enterprise)"
    },
    "sub_chatgpt": {
     "level": "no",
     "text": "Not supported"
    },
    "api_key": {
     "level": "yes",
     "text": "`ANTHROPIC_API_KEY`, Claude Console, Bedrock, Google Cloud, Microsoft Foundry"
    }
   },
   "files": [
    {
     "path": "~/.claude/CLAUDE.md",
     "scope": "User",
     "note": "Personal instructions for every project"
    },
    {
     "path": "CLAUDE.md or .claude/CLAUDE.md",
     "scope": "Project",
     "note": "Team instructions, commit to git"
    },
    {
     "path": "CLAUDE.local.md",
     "scope": "Project (personal)",
     "note": "Your uncommitted notes; add to .gitignore"
    },
    {
     "path": ".claude/rules/*.md",
     "scope": "Project",
     "note": "Topic rules; `paths:` frontmatter scopes them to globs"
    },
    {
     "path": "AGENTS.md",
     "scope": "Project",
     "note": "Read when no CLAUDE.md exists (v2.1.277+)"
    },
    {
     "path": ".claude/settings.json",
     "scope": "Project",
     "note": "Shared permissions, hooks, sandbox, env"
    },
    {
     "path": ".claude/settings.local.json",
     "scope": "Project (personal)",
     "note": "Your local overrides; 'don't ask again' approvals are saved here"
    },
    {
     "path": "~/.claude/settings.json",
     "scope": "User",
     "note": "Personal settings for every project"
    },
    {
     "path": ".mcp.json",
     "scope": "Project",
     "note": "Team MCP servers (`mcpServers` object)"
    },
    {
     "path": "~/.claude.json",
     "scope": "User / local",
     "note": "User- and local-scope MCP servers, trust state"
    },
    {
     "path": ".claude/skills/<name>/SKILL.md",
     "scope": "Project",
     "note": "Agent Skills (also ~/.claude/skills/)"
    }
   ],
   "examples": [
    {
     "title": "CLAUDE.md that reuses your AGENTS.md",
     "file": "CLAUDE.md",
     "lang": "markdown",
     "code": "@AGENTS.md\n\n## Claude Code\n\n- Use plan mode for changes under `src/billing/`.\n- Run `npm test` before you say a task is done.\n"
    },
    {
     "title": "Project MCP server",
     "file": ".mcp.json",
     "lang": "json",
     "code": "{\n  \"mcpServers\": {\n    \"github\": {\n      \"type\": \"http\",\n      \"url\": \"https://api.githubcopilot.com/mcp/\"\n    }\n  }\n}\n"
    },
    {
     "title": "Hook that hard-blocks destructive shell commands",
     "file": ".claude/settings.json (hooks)",
     "lang": "json",
     "code": "{\n  \"hooks\": {\n    \"PreToolUse\": [\n      {\n        \"matcher\": \"Bash\",\n        \"hooks\": [\n          { \"type\": \"command\", \"command\": \"\\\"$CLAUDE_PROJECT_DIR\\\"/.claude/hooks/block-destructive.sh\" }\n        ]\n      }\n    ]\n  }\n}\n"
    },
    {
     "title": "The hook script",
     "file": ".claude/hooks/block-destructive.sh",
     "lang": "bash",
     "code": "#!/usr/bin/env bash\n# Reads the tool call as JSON on stdin; exit 2 blocks it and shows the reason to Claude.\ncmd=$(jq -r '.tool_input.command // \"\"')\nif echo \"$cmd\" | grep -Eiq 'rm -[a-z]*r[a-z]*f|git push.*(--force|-f( |$))|drop (table|database)|truncate table|terraform destroy'; then\n  echo \"Blocked by project policy: $cmd\" >&2\n  exit 2\nfi\nexit 0\n"
    }
   ],
   "preset": {
    "title": "Safe settings.json: block destructive commands and secrets",
    "file": ".claude/settings.json",
    "lang": "json",
    "code": "{\n  \"permissions\": {\n    \"allow\": [\n      \"Bash(npm run test *)\",\n      \"Bash(npm run lint *)\",\n      \"Bash(git status)\",\n      \"Bash(git diff *)\",\n      \"Bash(git log *)\"\n    ],\n    \"ask\": [\n      \"Bash(git push *)\",\n      \"Bash(git commit *)\",\n      \"Bash(npm install *)\"\n    ],\n    \"deny\": [\n      \"Bash(rm -rf *)\",\n      \"Bash(rm -fr *)\",\n      \"Bash(sudo *)\",\n      \"Bash(git push --force*)\",\n      \"Bash(git push * --force*)\",\n      \"Bash(git push -f*)\",\n      \"Bash(git push * -f*)\",\n      \"Bash(git reset --hard*)\",\n      \"Bash(git clean *)\",\n      \"Bash(*DROP TABLE*)\",\n      \"Bash(*drop table*)\",\n      \"Bash(*DROP DATABASE*)\",\n      \"Bash(*TRUNCATE TABLE*)\",\n      \"Bash(terraform destroy*)\",\n      \"Bash(kubectl delete *)\",\n      \"Read(./.env)\",\n      \"Read(./.env.*)\",\n      \"Read(./secrets/**)\",\n      \"Read(~/.ssh/**)\",\n      \"Read(~/.aws/**)\"\n    ],\n    \"disableBypassPermissionsMode\": \"disable\"\n  },\n  \"sandbox\": {\n    \"enabled\": true\n  }\n}\n",
    "note": "Deny rules are checked first, so an allow rule can never re-open a denied command. Deny rules match the command text Claude writes: they do not catch `/bin/rm -rf`, `bash -c 'rm -rf …'` or `git -C . push --force`. Turn on the sandbox and add the PreToolUse hook above for a real boundary."
   },
   "gotchas": [
    "If any `CLAUDE.md` or `CLAUDE.local.md` exists in the working directory or a parent, Claude Code reads it instead of `AGENTS.md`. Adding a personal `CLAUDE.local.md` silently switches AGENTS.md off unless you set Project instructions to `claude-md-and-agents-md`.",
    "Claude Code does not read `AGENTS.override.md`, `AGENTS.local.md` or anything under `.agents/` (per the memory docs).",
    "Instructions in CLAUDE.md are context, not enforcement. Use permission rules, the sandbox or a PreToolUse hook for anything that must never happen.",
    "Keep each CLAUDE.md under about 200 lines; `@imports` organize content but still load at launch.",
    "A symlinked `CLAUDE.md -> AGENTS.md` works, but Windows clones without `core.symlinks` get a one-line text file. Prefer the `@AGENTS.md` import for mixed-OS teams.",
    "`.mcp.json` servers need approval on first run; a cloned repo cannot approve its own servers."
   ],
   "faqs": [
    {
     "q": "Does Claude Code read AGENTS.md?",
     "a": "Yes, since v2.1.277. By default it reads AGENTS.md only when there is no CLAUDE.md or CLAUDE.local.md in the working directory or above it. To read both, set Project instructions to claude-md-and-agents-md in /config, or put @AGENTS.md in your CLAUDE.md."
    },
    {
     "q": "Where is the Claude Code settings.json?",
     "a": "User settings: ~/.claude/settings.json. Project (shared): .claude/settings.json. Project (personal, gitignored): .claude/settings.local.json. Organizations can deploy managed settings that override all of them."
    },
    {
     "q": "How do I stop Claude Code from running rm -rf?",
     "a": "Add \"Bash(rm -rf *)\" to permissions.deny in settings.json. Deny rules beat allow rules. Because rules match the command text, also enable the sandbox (/sandbox) and a PreToolUse hook that exits with code 2 for destructive patterns."
    },
    {
     "q": "Where is the Claude Code MCP config file?",
     "a": "Project servers go in .mcp.json at the repository root (mcpServers object). User and local servers are stored in ~/.claude.json. Use claude mcp add --scope project|user|local to write them."
    }
   ],
   "sources": [
    {
     "label": "Memory: CLAUDE.md and AGENTS.md",
     "url": "https://code.claude.com/docs/en/memory"
    },
    {
     "label": "Permissions",
     "url": "https://code.claude.com/docs/en/permissions"
    },
    {
     "label": "Settings",
     "url": "https://code.claude.com/docs/en/settings"
    },
    {
     "label": "MCP",
     "url": "https://code.claude.com/docs/en/mcp"
    },
    {
     "label": "Sandboxing",
     "url": "https://code.claude.com/docs/en/sandboxing"
    },
    {
     "label": "Hooks",
     "url": "https://code.claude.com/docs/en/hooks"
    },
    {
     "label": "Skills",
     "url": "https://code.claude.com/docs/en/skills"
    },
    {
     "label": "Authentication",
     "url": "https://code.claude.com/docs/en/authentication"
    },
    {
     "label": "Legal and compliance",
     "url": "https://code.claude.com/docs/en/legal-and-compliance"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Add a `CLAUDE.md` whose first line is `@AGENTS.md` (or `ln -s AGENTS.md CLAUDE.md`). With no CLAUDE.md at all, v2.1.277+ reads AGENTS.md directly."
  },
  {
   "slug": "codex",
   "name": "Codex CLI",
   "tool": "codex",
   "vendor": "OpenAI",
   "surfaces": [
    "cli",
    "ide",
    "cloud"
   ],
   "title": "Codex CLI Config Guide: AGENTS.md, config.toml, Sandbox & Approvals",
   "desc": "How OpenAI Codex discovers AGENTS.md, where config.toml MCP servers and skills live, sandbox and approval modes, and .rules that forbid rm -rf and force-push.",
   "answer": "Codex reads `AGENTS.md` natively: `~/.codex/AGENTS.md` (or `AGENTS.override.md`) first, then one file per directory from the git root down to your working directory, up to 32 KiB. Everything else lives in `~/.codex/config.toml` (or a trusted project's `.codex/config.toml`): MCP servers under `[mcp_servers.<name>]`, `sandbox_mode` (`read-only`, `workspace-write`, `danger-full-access`) and `approval_policy` (`on-request` or `never`). Command allow/forbid lists are `.rules` files. Sign in with ChatGPT to use your plan, or use an API key.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`~/.codex/AGENTS.override.md` or `~/.codex/AGENTS.md` (`$CODEX_HOME`); first non-empty file wins"
    },
    "instr_project": {
     "level": "yes",
     "text": "In each dir from git root to cwd: `AGENTS.override.md`, else `AGENTS.md`, else names in `project_doc_fallback_filenames`; max one per dir; 32 KiB total (`project_doc_max_bytes`)"
    },
    "instr_nested": {
     "level": "partial",
     "text": "Directories between the repo root and where you launch Codex; files below the launch dir are not read"
    },
    "agents_md": {
     "level": "yes",
     "text": "Native, primary format. CLAUDE.md only if you add it to `project_doc_fallback_filenames`"
    },
    "skills": {
     "level": "yes",
     "text": "`.agents/skills` from cwd up to repo root, `~/.agents/skills`, `/etc/codex/skills`"
    },
    "mcp": {
     "level": "yes",
     "text": "`[mcp_servers.<name>]` in `~/.codex/config.toml` or project `.codex/config.toml` (trusted projects only); `codex mcp add`"
    },
    "permissions": {
     "level": "yes",
     "text": "`approval_policy` = `on-request` | `never` | `granular` (`untrusted` retired, `on-failure` deprecated); `.rules` files with `prefix_rule()` decisions allow / prompt / forbidden"
    },
    "sandbox": {
     "level": "yes",
     "text": "On by default: `sandbox_mode` read-only / workspace-write / danger-full-access; no network by default. Seatbelt (macOS), bubblewrap (Linux/WSL2), native Windows sandbox"
    },
    "hooks": {
     "level": "yes",
     "text": "`~/.codex/hooks.json`, `<repo>/.codex/hooks.json` or `[hooks]` in config.toml; PreToolUse can deny; enabled by default"
    },
    "sub_claude": {
     "level": "no",
     "text": "Not supported"
    },
    "sub_chatgpt": {
     "level": "yes",
     "text": "Sign in with ChatGPT uses your plan's Codex usage (required for Codex cloud)"
    },
    "api_key": {
     "level": "yes",
     "text": "Sign in with an API key for usage-based billing"
    }
   },
   "files": [
    {
     "path": "~/.codex/AGENTS.md",
     "scope": "User",
     "note": "Global working agreements (AGENTS.override.md takes priority)"
    },
    {
     "path": "AGENTS.md (repo root to cwd)",
     "scope": "Project",
     "note": "One file per directory, concatenated root first"
    },
    {
     "path": "AGENTS.override.md",
     "scope": "Project dir",
     "note": "Replaces AGENTS.md in that directory"
    },
    {
     "path": "~/.codex/config.toml",
     "scope": "User",
     "note": "Sandbox, approvals, MCP servers, profiles, features"
    },
    {
     "path": ".codex/config.toml",
     "scope": "Project",
     "note": "Project config, loaded for trusted projects only"
    },
    {
     "path": "~/.codex/rules/default.rules",
     "scope": "User",
     "note": "prefix_rule() command rules (TUI 'always allow' writes here)"
    },
    {
     "path": ".codex/rules/*.rules",
     "scope": "Project",
     "note": "Project command rules"
    },
    {
     "path": "~/.codex/hooks.json / .codex/hooks.json",
     "scope": "User / project",
     "note": "Lifecycle hooks"
    },
    {
     "path": ".agents/skills/<name>/SKILL.md",
     "scope": "Project",
     "note": "Skills (also ~/.agents/skills, /etc/codex/skills)"
    }
   ],
   "examples": [
    {
     "title": "Read CLAUDE.md too (fallback names)",
     "file": "~/.codex/config.toml",
     "lang": "toml",
     "code": "project_doc_fallback_filenames = [\"CLAUDE.md\"]\nproject_doc_max_bytes = 65536\n"
    },
    {
     "title": "MCP server",
     "file": "~/.codex/config.toml",
     "lang": "toml",
     "code": "[mcp_servers.context7]\ncommand = \"npx\"\nargs = [\"-y\", \"@upstash/context7-mcp\"]\n"
    },
    {
     "title": "PreToolUse hook output that denies a command",
     "file": "stdout of a .codex/hooks.json command",
     "lang": "json",
     "code": "{\n  \"hookSpecificOutput\": {\n    \"hookEventName\": \"PreToolUse\",\n    \"permissionDecision\": \"deny\",\n    \"permissionDecisionReason\": \"Destructive command blocked by hook.\"\n  }\n}\n"
    }
   ],
   "preset": {
    "title": "Safe Codex setup: workspace sandbox, no network, forbidden commands",
    "file": "~/.codex/config.toml + ~/.codex/rules/default.rules",
    "lang": "toml",
    "code": "# ~/.codex/config.toml\nsandbox_mode = \"workspace-write\"     # edits only inside the workspace\napproval_policy = \"on-request\"       # ask before leaving the sandbox\n\n[sandbox_workspace_write]\nnetwork_access = false               # no network for model-run commands\n\n# ~/.codex/rules/default.rules  (separate file; test with `codex execpolicy check`)\nprefix_rule(pattern = [\"rm\", [\"-rf\", \"-fr\"]], decision = \"forbidden\",\n            justification = \"No recursive deletes. Ask the user instead.\")\nprefix_rule(pattern = [\"git\", \"push\", [\"--force\", \"-f\", \"--force-with-lease\"]], decision = \"forbidden\",\n            justification = \"Never force-push.\")\nprefix_rule(pattern = [\"git\", \"push\"], decision = \"prompt\", justification = \"Review before pushing.\")\nprefix_rule(pattern = [\"git\", \"reset\", \"--hard\"], decision = \"forbidden\")\nprefix_rule(pattern = [\"terraform\", \"destroy\"], decision = \"forbidden\")\nprefix_rule(pattern = [\"kubectl\", \"delete\"], decision = \"prompt\")\n",
    "note": "The config and the rules are two separate files (shown together here). Rules match command prefixes exactly: `git push origin main --force` does not match `[\"git\", \"push\", \"--force\"]`. Per the docs, rules govern commands that run outside the sandbox; inside `workspace-write`, sandboxed commands can still change workspace files without a prompt, so keep work committed. With `network_access = false`, a sandboxed `psql … DROP TABLE` cannot reach a remote database."
   },
   "gotchas": [
    "`approval_policy = \"untrusted\"` is retired and can stop Codex from starting; remove it. Use `on-request` (interactive) or `never` (non-interactive).",
    "Codex includes at most one instruction file per directory and stops at 32 KiB by default. Raise `project_doc_max_bytes` or split files.",
    "Nested AGENTS.md files only load for directories between the repo root and the launch directory. Start Codex in the subfolder (`codex --cd services/payments`) to pick up its file.",
    "`.codex/config.toml` in a repo (MCP servers, settings) is only loaded once you trust the project.",
    "`--yolo` / `danger-full-access` removes the sandbox entirely. Only use it inside a disposable container or VM."
   ],
   "faqs": [
    {
     "q": "Where is the Codex config file?",
     "a": "~/.codex/config.toml (or $CODEX_HOME/config.toml). A trusted project can add .codex/config.toml. MCP servers, sandbox_mode, approval_policy and hooks are configured there."
    },
    {
     "q": "Does Codex read CLAUDE.md?",
     "a": "Not by default. Add project_doc_fallback_filenames = [\"CLAUDE.md\"] to config.toml and Codex will use CLAUDE.md in any directory that has no AGENTS.md."
    },
    {
     "q": "What are the Codex sandbox and approval modes?",
     "a": "sandbox_mode is read-only, workspace-write or danger-full-access. approval_policy is on-request or never (or a granular table). The Auto preset is --sandbox workspace-write --ask-for-approval on-request."
    },
    {
     "q": "Can I use my ChatGPT subscription with Codex?",
     "a": "Yes. Choose Sign in with ChatGPT in the CLI or IDE extension and usage counts against your ChatGPT plan. Codex cloud requires ChatGPT sign-in; an API key gives usage-based billing instead."
    }
   ],
   "sources": [
    {
     "label": "Custom instructions with AGENTS.md",
     "url": "https://learn.chatgpt.com/docs/agent-configuration/agents-md"
    },
    {
     "label": "Configuration reference",
     "url": "https://learn.chatgpt.com/docs/config-file/config-reference"
    },
    {
     "label": "Agent approvals & security",
     "url": "https://learn.chatgpt.com/docs/agent-approvals-security"
    },
    {
     "label": "Sandbox",
     "url": "https://learn.chatgpt.com/docs/sandboxing"
    },
    {
     "label": "Rules",
     "url": "https://learn.chatgpt.com/docs/agent-configuration/rules"
    },
    {
     "label": "MCP",
     "url": "https://learn.chatgpt.com/docs/extend/mcp"
    },
    {
     "label": "Skills",
     "url": "https://learn.chatgpt.com/docs/build-skills"
    },
    {
     "label": "Hooks",
     "url": "https://learn.chatgpt.com/docs/hooks"
    },
    {
     "label": "Authentication",
     "url": "https://learn.chatgpt.com/docs/auth"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native: nothing to do. Use `AGENTS.override.md` for temporary local overrides."
  },
  {
   "slug": "cursor",
   "name": "Cursor",
   "tool": "cursor",
   "vendor": "Anysphere",
   "surfaces": [
    "ide",
    "cli",
    "cloud"
   ],
   "title": "Cursor Rules File Location, AGENTS.md, MCP & Permissions Guide",
   "desc": "Where Cursor rules live (.cursor/rules/*.mdc), nested AGENTS.md, .cursor/mcp.json, hooks.json, skills dirs, Run Modes, sandbox.json and CLI allow/deny permissions.",
   "answer": "Cursor project rules live in `.cursor/rules/` as `.mdc` files with `description`, `globs` and `alwaysApply` frontmatter. Cursor also reads `AGENTS.md` in the project root and in subdirectories, and User Rules from Customize → Rules. MCP servers go in `.cursor/mcp.json` or `~/.cursor/mcp.json`, hooks in `.cursor/hooks.json`. Run Modes (Auto-review, Allowlist, Run Everything) plus `sandbox.json` control what the agent may run. You pay with a Cursor plan or bring your own API keys; Claude and ChatGPT subscriptions are not a login option.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "User Rules in Customize → Rules (stored in Cursor, not a file); Team Rules from the dashboard"
    },
    "instr_project": {
     "level": "yes",
     "text": "`.cursor/rules/*.mdc` (frontmatter: description, globs, alwaysApply), `AGENTS.md`. Precedence Team → Project → User"
    },
    "instr_nested": {
     "level": "yes",
     "text": "Nested `AGENTS.md` in any subdirectory; `.cursor/rules/` subfolders"
    },
    "agents_md": {
     "level": "yes",
     "text": "Root and nested AGENTS.md, combined with parents"
    },
    "skills": {
     "level": "yes",
     "text": "`.cursor/skills/`, `.agents/skills/`, `~/.cursor/skills/`, `~/.agents/skills/`; also `.claude/skills/` and `.codex/skills/` for compatibility"
    },
    "mcp": {
     "level": "yes",
     "text": "`.cursor/mcp.json` (project) and `~/.cursor/mcp.json` (global), `mcpServers` object"
    },
    "permissions": {
     "level": "yes",
     "text": "IDE Run Modes: Auto-review, Allowlist, Run Everything; `permissions.json` steers Auto-review. CLI: `permissions.allow`/`deny` with `Shell()`, `Read()`, `Write()`, `WebFetch()` in `~/.cursor/cli-config.json` or `.cursor/cli.json`"
    },
    "sandbox": {
     "level": "yes",
     "text": "Terminal sandbox; configure with `~/.cursor/sandbox.json` or `.cursor/sandbox.json`; network blocked by default inside it"
    },
    "hooks": {
     "level": "yes",
     "text": "`.cursor/hooks.json` and `~/.cursor/hooks.json`: preToolUse, beforeShellExecution, afterFileEdit and more; can load Claude Code hooks"
    },
    "sub_claude": {
     "level": "no",
     "text": "Not a login option; add an Anthropic API key instead"
    },
    "sub_chatgpt": {
     "level": "no",
     "text": "Not a login option; add an OpenAI API key instead"
    },
    "api_key": {
     "level": "yes",
     "text": "BYOK for OpenAI, Anthropic, Google, Azure OpenAI, AWS Bedrock (chat models only; Tab stays on Cursor models)"
    }
   },
   "files": [
    {
     "path": ".cursor/rules/*.mdc",
     "scope": "Project",
     "note": "Project rules with description / globs / alwaysApply"
    },
    {
     "path": "AGENTS.md (root and subfolders)",
     "scope": "Project",
     "note": "Plain-markdown instructions, nested files supported"
    },
    {
     "path": "Customize → Rules",
     "scope": "User",
     "note": "User Rules (global preferences)"
    },
    {
     "path": ".cursor/mcp.json / ~/.cursor/mcp.json",
     "scope": "Project / user",
     "note": "MCP servers"
    },
    {
     "path": ".cursor/hooks.json / ~/.cursor/hooks.json",
     "scope": "Project / user",
     "note": "Agent hooks (project hooks also run in cloud agents)"
    },
    {
     "path": ".cursor/permissions.json / ~/.cursor/permissions.json",
     "scope": "Project / user",
     "note": "Auto-review allow/block instructions"
    },
    {
     "path": ".cursor/sandbox.json / ~/.cursor/sandbox.json",
     "scope": "Project / user",
     "note": "Sandbox network and path rules"
    },
    {
     "path": ".cursor/cli.json / ~/.cursor/cli-config.json",
     "scope": "Project / user",
     "note": "Cursor CLI permission tokens"
    },
    {
     "path": ".cursor/skills/<name>/SKILL.md",
     "scope": "Project",
     "note": "Skills (also .agents/skills, ~/.cursor/skills)"
    }
   ],
   "examples": [
    {
     "title": "Always-on project rule",
     "file": ".cursor/rules/project.mdc",
     "lang": "markdown",
     "code": "---\ndescription: Core project conventions\nalwaysApply: true\n---\n\n- Use pnpm, never npm or yarn.\n- Run `pnpm test` before finishing a task.\n- API handlers live in `src/api/handlers/`.\n"
    },
    {
     "title": "Glob-scoped rule",
     "file": ".cursor/rules/react.mdc",
     "lang": "markdown",
     "code": "---\ndescription: React component guidelines\nglobs: src/components/**/*.tsx\nalwaysApply: false\n---\n\nUse function components and hooks. No class components.\n"
    },
    {
     "title": "Project MCP server",
     "file": ".cursor/mcp.json",
     "lang": "json",
     "code": "{\n  \"mcpServers\": {\n    \"postgres-readonly\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"@modelcontextprotocol/server-postgres\", \"postgresql://readonly@localhost/app\"]\n    }\n  }\n}\n"
    }
   ],
   "preset": {
    "title": "Safe Cursor CLI permissions (deny destructive commands and secrets)",
    "file": ".cursor/cli.json",
    "lang": "json",
    "code": "{\n  \"permissions\": {\n    \"allow\": [\n      \"Shell(ls)\",\n      \"Shell(git:status*)\",\n      \"Shell(git:diff*)\",\n      \"Read(src/**)\",\n      \"Write(src/**)\"\n    ],\n    \"deny\": [\n      \"Shell(rm)\",\n      \"Shell(sudo)\",\n      \"Shell(git:push*)\",\n      \"Read(.env*)\",\n      \"Write(**/.env*)\",\n      \"Write(**/*.key)\"\n    ]\n  }\n}\n",
    "note": "Shell() matches the first token of the command; `command:args` globs (e.g. `git:push*`) narrow it. Deny rules take precedence over allow rules. In the IDE, pick the Allowlist or Auto-review Run Mode instead of Run Everything and keep the sandbox on; Cursor says Auto-review is not a security boundary."
   },
   "gotchas": [
    "A plain `.md` file in `.cursor/rules/` is ignored by the rules system; project rules must use the `.mdc` extension. Use AGENTS.md if you want plain markdown.",
    "User Rules are stored in Cursor settings, not in a file you can commit. Put team rules in `.cursor/rules/` or AGENTS.md.",
    "Custom API keys only work for chat models; Tab completion keeps using Cursor's own models.",
    "User-level hooks (`~/.cursor/hooks.json`) do not run in cloud agents; only the repo's `.cursor/hooks.json` does.",
    "Legacy `.cursorrules` is not described in the current rules docs; migrate it to `.cursor/rules/*.mdc` or AGENTS.md."
   ],
   "faqs": [
    {
     "q": "Where is the Cursor rules file?",
     "a": "Project rules are .mdc files in .cursor/rules/ at the repository root (subfolders allowed). User Rules live in Customize → Rules. Cursor also reads AGENTS.md in the root and in subdirectories."
    },
    {
     "q": "Does Cursor support AGENTS.md?",
     "a": "Yes. Cursor reads AGENTS.md in the project root and in subdirectories; nested files are combined with their parents, more specific instructions taking precedence."
    },
    {
     "q": "Where is the Cursor MCP config?",
     "a": ".cursor/mcp.json in the project for project servers and ~/.cursor/mcp.json for servers available in every project. Both use an mcpServers object."
    },
    {
     "q": "Can I use my Claude or ChatGPT subscription in Cursor?",
     "a": "No. Cursor bills through its own plans. You can add your own Anthropic, OpenAI, Google, Azure or Bedrock API key for chat models."
    }
   ],
   "sources": [
    {
     "label": "Rules",
     "url": "https://cursor.com/docs/rules"
    },
    {
     "label": "Skills",
     "url": "https://cursor.com/docs/skills"
    },
    {
     "label": "MCP",
     "url": "https://cursor.com/docs/mcp"
    },
    {
     "label": "Hooks",
     "url": "https://cursor.com/docs/hooks"
    },
    {
     "label": "Run Modes & sandbox",
     "url": "https://cursor.com/docs/agent/security/run-modes"
    },
    {
     "label": "CLI permissions",
     "url": "https://cursor.com/docs/cli/reference/permissions"
    },
    {
     "label": "Bring your own API key",
     "url": "https://cursor.com/help/models-and-usage/api-keys"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native (root and nested). Add `.cursor/rules/*.mdc` only for glob-scoped rules."
  },
  {
   "slug": "github-copilot",
   "name": "GitHub Copilot",
   "tool": "copilot",
   "vendor": "GitHub / Microsoft",
   "surfaces": [
    "ide",
    "cloud",
    "cli"
   ],
   "title": "GitHub Copilot Instructions: copilot-instructions.md, AGENTS.md, MCP",
   "desc": "Copilot agent mode (VS Code) and Copilot cloud agent: .github/copilot-instructions.md, AGENTS.md/CLAUDE.md support, skills, hooks, mcp.json and terminal auto-approve rules.",
   "answer": "Copilot reads `.github/copilot-instructions.md`, path-specific `.github/instructions/**/*.instructions.md` (with `applyTo` globs) and `AGENTS.md`. The Copilot cloud agent (formerly coding agent) also accepts a root `CLAUDE.md` or `GEMINI.md`, and the nearest `AGENTS.md` wins. In VS Code, MCP servers go in `.vscode/mcp.json` (or a portable `.mcp.json`) and terminal approvals in `chat.tools.terminal.autoApprove`; the cloud agent's MCP servers are set in the repository settings and its internet access is behind a firewall. Billing is your Copilot plan.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "Personal and organization instructions on GitHub.com; `~/.copilot/copilot-instructions.md` for Copilot Agent Host / CLI sessions"
    },
    "instr_project": {
     "level": "yes",
     "text": "`.github/copilot-instructions.md`, `.github/instructions/**/*.instructions.md` (`applyTo`), `AGENTS.md`; cloud agent also `CLAUDE.md` or `GEMINI.md` at root"
    },
    "instr_nested": {
     "level": "partial",
     "text": "Cloud agent: AGENTS.md anywhere, nearest wins. VS Code: nested AGENTS.md is experimental (`chat.useNestedAgentsMdFiles`, off by default)"
    },
    "agents_md": {
     "level": "yes",
     "text": "VS Code agent mode and cloud agent; toggle `chat.useAgentsMdFile` in VS Code"
    },
    "skills": {
     "level": "yes",
     "text": "`.github/skills`, `.claude/skills`, `.agents/skills`; personal `~/.copilot/skills`, `~/.agents/skills` (cloud agent, CLI, VS Code)"
    },
    "mcp": {
     "level": "yes",
     "text": "VS Code: `.vscode/mcp.json` (`servers`) or `.mcp.json` (`mcpServers`), plus user-profile mcp.json. Cloud agent: JSON in repository Settings (`mcpServers`)"
    },
    "permissions": {
     "level": "yes",
     "text": "VS Code permission levels and Autopilot; `chat.tools.terminal.autoApprove` (true / false / regex), `chat.tools.edits.autoApprove`, `chat.tools.urls.autoApprove`"
    },
    "sandbox": {
     "level": "yes",
     "text": "VS Code agent sandboxing (Preview on macOS/Linux/WSL2, experimental on Windows). Cloud agent: ephemeral cloud environment + internet firewall"
    },
    "hooks": {
     "level": "yes",
     "text": "`.github/hooks/*.json` for cloud agent and Copilot CLI (personal `~/.copilot/hooks/*.json`); VS Code also reads `.github/hooks/` (Preview)"
    },
    "sub_claude": {
     "level": "no",
     "text": "Not documented"
    },
    "sub_chatgpt": {
     "level": "no",
     "text": "Not documented"
    },
    "api_key": {
     "level": "partial",
     "text": "Copilot plan required; bring-your-own-key options not verified here"
    }
   },
   "files": [
    {
     "path": ".github/copilot-instructions.md",
     "scope": "Repository",
     "note": "Repo-wide instructions (Chat, cloud agent, code review)"
    },
    {
     "path": ".github/instructions/NAME.instructions.md",
     "scope": "Repository",
     "note": "Path-specific instructions with `applyTo:` globs"
    },
    {
     "path": "AGENTS.md",
     "scope": "Repository",
     "note": "Agent instructions; nearest file wins for the cloud agent"
    },
    {
     "path": "CLAUDE.md / GEMINI.md (root)",
     "scope": "Repository",
     "note": "Accepted by the cloud agent"
    },
    {
     "path": "~/.copilot/copilot-instructions.md",
     "scope": "User",
     "note": "Personal always-on instructions (Agent Host / CLI)"
    },
    {
     "path": ".vscode/mcp.json or .mcp.json",
     "scope": "Workspace",
     "note": "MCP servers for VS Code agent mode"
    },
    {
     "path": "Repo Settings → Copilot → MCP",
     "scope": "Repository",
     "note": "MCP servers for the cloud agent (JSON)"
    },
    {
     "path": ".github/hooks/*.json",
     "scope": "Repository",
     "note": "Hooks for cloud agent, Copilot CLI and VS Code"
    },
    {
     "path": ".github/skills/<name>/SKILL.md",
     "scope": "Repository",
     "note": "Agent skills (also .claude/skills, .agents/skills)"
    }
   ],
   "examples": [
    {
     "title": "Path-specific instructions",
     "file": ".github/instructions/ts.instructions.md",
     "lang": "markdown",
     "code": "---\napplyTo: \"**/*.ts,**/*.tsx\"\n---\n\n- Use strict TypeScript; no `any`.\n- Run `npm run typecheck` after edits.\n"
    },
    {
     "title": "VS Code MCP server",
     "file": ".vscode/mcp.json",
     "lang": "json",
     "code": "{\n  \"servers\": {\n    \"github\": {\n      \"type\": \"http\",\n      \"url\": \"https://api.githubcopilot.com/mcp/\"\n    }\n  }\n}\n"
    },
    {
     "title": "Cloud agent / CLI hook",
     "file": ".github/hooks/security.json",
     "lang": "json",
     "code": "{\n  \"version\": 1,\n  \"hooks\": {\n    \"preToolUse\": [\n      { \"type\": \"command\", \"bash\": \"./scripts/security-check.sh\", \"cwd\": \"scripts\", \"timeoutSec\": 15 }\n    ]\n  }\n}\n"
    }
   ],
   "preset": {
    "title": "Safe VS Code settings for Copilot agent mode",
    "file": ".vscode/settings.json",
    "lang": "json",
    "code": "{\n  \"chat.tools.terminal.enableAutoApprove\": true,\n  \"chat.tools.terminal.autoApprove\": {\n    \"/^git (status|diff|log)\\\\b/\": true,\n    \"/^npm (test|run lint)\\\\b/\": true,\n    \"rm\": false,\n    \"sudo\": false,\n    \"/git push.*(--force|-f\\\\b)/\": false,\n    \"/DROP (TABLE|DATABASE)|drop (table|database)/\": false,\n    \"/terraform destroy|kubectl delete/\": false\n  },\n  \"chat.tools.edits.autoApprove\": {\n    \"**/.env*\": false,\n    \"**/*.pem\": false\n  },\n  \"chat.tools.global.autoApprove\": false\n}\n",
    "note": "In VS Code a `false` rule means \"always ask\", it does not block. To block a command outright, use a PreToolUse hook that denies it, and turn on agent sandboxing. VS Code calls terminal auto-approval best-effort, not a security boundary."
   },
   "gotchas": [
    "Instruction support differs by surface: VS Code reads `AGENTS.md`, while the cloud agent also accepts `CLAUDE.md` / `GEMINI.md`. Check GitHub's support matrix before relying on one file.",
    "Custom instructions are not used for inline completions as you type.",
    "VS Code's `.vscode/mcp.json` uses a top-level `servers` key; the portable `.mcp.json` uses `mcpServers`. Copying between them is a common mistake.",
    "`chat.tools.global.autoApprove` skips every confirmation in every workspace. Prefer a session-scoped permission level.",
    "The cloud agent's firewall limits internet access by default; add hosts to its allowlist rather than disabling it."
   ],
   "faqs": [
    {
     "q": "Where does GitHub Copilot read custom instructions from?",
     "a": ".github/copilot-instructions.md for repository-wide guidance, .github/instructions/**/*.instructions.md for path-specific rules, and AGENTS.md. The Copilot cloud agent also reads CLAUDE.md or GEMINI.md at the repository root."
    },
    {
     "q": "Does GitHub Copilot support AGENTS.md?",
     "a": "Yes. VS Code agent mode reads AGENTS.md (setting chat.useAgentsMdFile), with nested files as an experimental option. The Copilot cloud agent reads AGENTS.md anywhere in the repo and uses the nearest one."
    },
    {
     "q": "Where is the MCP config for Copilot in VS Code?",
     "a": ".vscode/mcp.json in the workspace (top-level servers object), a portable .mcp.json at the project root (mcpServers), or the user-profile mcp.json opened with MCP: Open User Configuration."
    },
    {
     "q": "How do I stop Copilot agent mode from running dangerous terminal commands?",
     "a": "Add false entries for those commands to chat.tools.terminal.autoApprove so they always need approval, block them with a PreToolUse hook, and enable agent sandboxing."
    }
   ],
   "sources": [
    {
     "label": "Add repository custom instructions",
     "url": "https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions"
    },
    {
     "label": "Custom instructions support matrix",
     "url": "https://docs.github.com/en/copilot/reference/custom-instructions-support"
    },
    {
     "label": "About agent skills",
     "url": "https://docs.github.com/en/copilot/concepts/agents/about-agent-skills"
    },
    {
     "label": "About hooks",
     "url": "https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-hooks"
    },
    {
     "label": "Cloud agent MCP",
     "url": "https://docs.github.com/en/copilot/how-tos/use-copilot-agents/coding-agent/extend-coding-agent-with-mcp"
    },
    {
     "label": "VS Code custom instructions",
     "url": "https://code.visualstudio.com/docs/copilot/customization/custom-instructions"
    },
    {
     "label": "VS Code MCP servers",
     "url": "https://code.visualstudio.com/docs/copilot/customization/mcp-servers"
    },
    {
     "label": "VS Code approvals & permissions",
     "url": "https://code.visualstudio.com/docs/agents/run/approvals"
    },
    {
     "label": "VS Code security",
     "url": "https://code.visualstudio.com/docs/copilot/security"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native in VS Code (`chat.useAgentsMdFile`) and the cloud agent. Keep `.github/copilot-instructions.md` only for Copilot-specific notes."
  },
  {
   "slug": "antigravity-gemini-cli",
   "name": "Antigravity / Gemini CLI",
   "tool": "antigravity",
   "vendor": "Google",
   "surfaces": [
    "cli",
    "ide"
   ],
   "title": "Gemini CLI & Antigravity Config: GEMINI.md, AGENTS.md, MCP Location",
   "desc": "GEMINI.md and AGENTS.md loading in Gemini CLI and Antigravity, mcp_config.json and settings.json locations, skills dirs, permission presets, policy engine and sandbox.",
   "answer": "Google moved individual Gemini CLI users to Antigravity CLI on June 18, 2026. Antigravity loads `AGENTS.md` or `GEMINI.md` (plus `.agents/rules/*.md`) per directory and global rules from `~/.gemini/AGENTS.md` or `~/.gemini/GEMINI.md`. Its MCP servers live in `~/.gemini/config/mcp_config.json` or `.agents/mcp_config.json`, and permissions are Deny / Ask / Allow lists on top of a Default, Request Review or Turbo preset. Gemini CLI uses `~/.gemini/settings.json` / `.gemini/settings.json` (`mcpServers`, `context.fileName`) plus policy TOML files, and reads only `GEMINI.md` unless you set `context.fileName`. Sign in with a Google account (Google AI Pro/Ultra included) or use a Gemini API key.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "Antigravity: `~/.gemini/AGENTS.md`, `~/.gemini/GEMINI.md`, `~/.gemini/config/AGENTS.md`. Gemini CLI: `~/.gemini/GEMINI.md`"
    },
    "instr_project": {
     "level": "yes",
     "text": "Antigravity: `AGENTS.md` / `GEMINI.md`, `.agents/AGENTS.md`, `.agents/rules/*.md`. Gemini CLI: `GEMINI.md` in workspace dirs and parents"
    },
    "instr_nested": {
     "level": "yes",
     "text": "Directory-scoped rules at each level; Gemini CLI loads GEMINI.md just-in-time when a tool touches a directory"
    },
    "agents_md": {
     "level": "partial",
     "text": "Antigravity: yes, native. Gemini CLI: only via `context.fileName` (e.g. `[\"AGENTS.md\", \"GEMINI.md\"]`)"
    },
    "skills": {
     "level": "yes",
     "text": "`.agents/skills/` (workspace), `~/.gemini/config/skills/` (Antigravity), `~/.gemini/antigravity-cli/skills/` (CLI); Gemini CLI: `.gemini/skills/` or `.agents/skills/`, `~/.gemini/skills/`"
    },
    "mcp": {
     "level": "yes",
     "text": "Antigravity: `~/.gemini/config/mcp_config.json`, `.agents/mcp_config.json`. Gemini CLI: `mcpServers` in `~/.gemini/settings.json` or `.gemini/settings.json`"
    },
    "permissions": {
     "level": "yes",
     "text": "Antigravity: Deny > Ask > Allow rules (`command()`, `read_file()`, `write_file()`, `read_url()`, `mcp()`) over a Default / Request Review / Turbo preset. Gemini CLI: policy engine TOML in `~/.gemini/policies/` (allow / deny / ask_user)"
    },
    "sandbox": {
     "level": "yes",
     "text": "Antigravity terminal sandbox on under the Default preset (workspace + temp only, no network). Gemini CLI: `--sandbox` / `-s` (Docker, Podman or macOS Seatbelt)"
    },
    "hooks": {
     "level": "yes",
     "text": "Antigravity: `.agents/hooks.json`, `~/.gemini/config/hooks.json`. Gemini CLI: `hooks` in settings.json"
    },
    "sub_claude": {
     "level": "no",
     "text": "Not supported"
    },
    "sub_chatgpt": {
     "level": "no",
     "text": "Not supported"
    },
    "api_key": {
     "level": "yes",
     "text": "Google account sign-in (free, Google AI Pro/Ultra, enterprise) or a Gemini API key; Vertex AI for Gemini CLI"
    }
   },
   "files": [
    {
     "path": "AGENTS.md / GEMINI.md",
     "scope": "Workspace dirs",
     "note": "Antigravity context files (Gemini CLI: GEMINI.md by default)"
    },
    {
     "path": ".agents/rules/*.md",
     "scope": "Workspace",
     "note": "Antigravity modular rules (flat folder)"
    },
    {
     "path": "~/.gemini/GEMINI.md / ~/.gemini/AGENTS.md",
     "scope": "User",
     "note": "Global rules"
    },
    {
     "path": "~/.gemini/config/mcp_config.json",
     "scope": "User",
     "note": "Antigravity MCP servers"
    },
    {
     "path": ".agents/mcp_config.json",
     "scope": "Workspace",
     "note": "Antigravity project MCP servers"
    },
    {
     "path": "~/.gemini/settings.json / .gemini/settings.json",
     "scope": "User / project",
     "note": "Gemini CLI settings: mcpServers, context, tools, hooks"
    },
    {
     "path": "~/.gemini/policies/*.toml",
     "scope": "User",
     "note": "Gemini CLI policy-engine rules"
    },
    {
     "path": ".agents/hooks.json",
     "scope": "Workspace",
     "note": "Antigravity hooks"
    },
    {
     "path": ".agents/skills/<name>/SKILL.md",
     "scope": "Workspace",
     "note": "Skills for both tools"
    }
   ],
   "examples": [
    {
     "title": "Make Gemini CLI read AGENTS.md",
     "file": ".gemini/settings.json",
     "lang": "json",
     "code": "{\n  \"context\": {\n    \"fileName\": [\"AGENTS.md\", \"GEMINI.md\"]\n  }\n}\n"
    },
    {
     "title": "Antigravity workspace MCP server",
     "file": ".agents/mcp_config.json",
     "lang": "json",
     "code": "{\n  \"mcpServers\": {\n    \"context7\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"@upstash/context7-mcp\"]\n    }\n  }\n}\n"
    },
    {
     "title": "Gemini CLI policy: deny rm -rf",
     "file": "~/.gemini/policies/safety.toml",
     "lang": "toml",
     "code": "[[rule]]\ntoolName = \"run_shell_command\"\ncommandPrefix = \"rm -rf\"\ndecision = \"deny\"\npriority = 100\n\n[[rule]]\ntoolName = \"run_shell_command\"\ncommandPrefix = \"git push\"\ndecision = \"ask_user\"\npriority = 100\n"
    }
   ],
   "preset": {
    "title": "Safe Antigravity permissions (Deny / Ask lists)",
    "file": "Settings → Permissions",
    "lang": "text",
    "code": "Preset: Default   (terminal sandbox on, workspace + temp dirs only, no network)\n\nDeny:\n  command(rm -rf)\n  command(sudo)\n  command(git push --force)\n  command(git push -f)\n  command(git reset --hard)\n  command(terraform destroy)\n  read_file(~/.ssh)\n  read_file(~/.aws)\n  write_file(.env)\n\nAsk:\n  command(git push)\n  command(kubectl)\n  command(psql)\n  command(mysql)\n",
    "note": "Antigravity evaluates Deny > Ask > Allow and matches commands by literal token prefix (or `regex:` per token), so a SQL statement inside `psql -c` can't be matched; put database clients in Ask instead. Turbo disables the sandbox and allows everything. The docs don't name the file these lists are stored in, so set them in Settings."
   },
   "gotchas": [
    "Gemini CLI stopped serving free, Google AI Pro and Ultra individual users on June 18, 2026; they were moved to Antigravity CLI. API-key, Vertex and enterprise users can still run Gemini CLI.",
    "Gemini CLI ignores AGENTS.md unless `context.fileName` lists it; Antigravity reads it natively.",
    "Antigravity only scans the immediate `.md` children of `.agents/rules/`.",
    "Antigravity's Turbo preset turns the sandbox off and allows commands without prompting.",
    "Command substitution such as `$(...)` or backticks can hide a command behind a harmless prefix; Antigravity treats those constructs specially, but keep destructive tools in Deny."
   ],
   "faqs": [
    {
     "q": "Does Gemini CLI read AGENTS.md?",
     "a": "Not by default: it reads GEMINI.md. Set context.fileName to [\"AGENTS.md\", \"GEMINI.md\"] in settings.json. Antigravity (the successor for individual users) reads AGENTS.md and GEMINI.md natively."
    },
    {
     "q": "Where is the MCP config for Antigravity?",
     "a": "Globally in ~/.gemini/config/mcp_config.json and per workspace in .agents/mcp_config.json. Gemini CLI uses the mcpServers key in ~/.gemini/settings.json or .gemini/settings.json."
    },
    {
     "q": "Where is GEMINI.md loaded from?",
     "a": "~/.gemini/GEMINI.md globally, then GEMINI.md files in your workspace directories and their parents, plus just-in-time files in directories a tool touches."
    },
    {
     "q": "Can I use Google AI Pro with Gemini CLI or Antigravity?",
     "a": "Sign in with the Google account that has your Google AI Pro or Ultra subscription. Since June 18, 2026 individual accounts are served through Antigravity CLI rather than Gemini CLI."
    }
   ],
   "sources": [
    {
     "label": "Antigravity rules",
     "url": "https://antigravity.google/docs/rules"
    },
    {
     "label": "Antigravity MCP",
     "url": "https://antigravity.google/docs/mcp"
    },
    {
     "label": "Antigravity skills",
     "url": "https://antigravity.google/docs/skills"
    },
    {
     "label": "Antigravity permissions",
     "url": "https://antigravity.google/docs/permissions"
    },
    {
     "label": "Antigravity terminal sandbox",
     "url": "https://antigravity.google/docs/sandbox"
    },
    {
     "label": "Antigravity hooks",
     "url": "https://antigravity.google/docs/hooks"
    },
    {
     "label": "Antigravity CLI install & auth",
     "url": "https://antigravity.google/docs/cli/install"
    },
    {
     "label": "Gemini CLI to Antigravity migration",
     "url": "https://antigravity.google/docs/cli/gcli-migration"
    },
    {
     "label": "Gemini CLI GEMINI.md",
     "url": "https://geminicli.com/docs/cli/gemini-md"
    },
    {
     "label": "Gemini CLI configuration",
     "url": "https://geminicli.com/docs/reference/configuration"
    },
    {
     "label": "Gemini CLI policy engine",
     "url": "https://geminicli.com/docs/reference/policy-engine"
    },
    {
     "label": "Gemini CLI sandbox",
     "url": "https://geminicli.com/docs/cli/sandbox"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Antigravity: native. Gemini CLI: set `context.fileName` to `[\"AGENTS.md\", \"GEMINI.md\"]` in `.gemini/settings.json` (or symlink GEMINI.md)."
  },
  {
   "slug": "devin-desktop-windsurf",
   "name": "Devin Desktop (ex-Windsurf)",
   "tool": "windsurf",
   "vendor": "Cognition",
   "status": "changed",
   "status_note": "Windsurf was renamed Devin Desktop on June 2, 2026; the legacy Cascade agent is being replaced by Devin Local (the Devin CLI harness).",
   "surfaces": [
    "ide",
    "cli"
   ],
   "title": "Windsurf / Devin Desktop Rules: .devin/rules, AGENTS.md, mcp_config.json",
   "desc": "Where Devin Desktop (formerly Windsurf) reads rules: .devin/rules, legacy .windsurf/rules, global_rules.md, AGENTS.md; MCP config, skills, hooks and Devin Local permissions.",
   "answer": "Devin Desktop (formerly Windsurf) reads workspace rules from `.devin/rules/*.md` (legacy `.windsurf/rules/` still works), a global `global_rules.md` (6,000 characters max) and `AGENTS.md` files, which feed the same rules engine (root = always on, subfolders = scoped). The Devin Local agent also reads `CLAUDE.md`, `.windsurfrules` and `.cursor/rules`. It keeps MCP servers in `.devin/mcp_config.json` (project), `.devin/mcp_config.local.json` or `~/.config/devin/mcp_config.json`, and permissions in `.devin/config.json` as allow / ask / deny rules.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "Cascade: `~/.codeium/windsurf/memories/global_rules.md` (6,000 chars). Devin Local/CLI: `~/.config/devin/AGENTS.md`, `~/.claude/CLAUDE.md`"
    },
    "instr_project": {
     "level": "yes",
     "text": "`.devin/rules/*.md` (preferred) or `.windsurf/rules/*.md`, 12,000 chars per file; `AGENTS.md`; Devin Local also `AGENTS.local.md`, `AGENT.md`, `CLAUDE.md`, `.windsurfrules`, `.cursor/rules/*.mdc`"
    },
    "instr_nested": {
     "level": "yes",
     "text": "Subdirectory AGENTS.md is scoped to that folder; rules dirs found in subfolders and parents up to the git root"
    },
    "agents_md": {
     "level": "yes",
     "text": "Root AGENTS.md is an always-on rule; nested files apply to their directory"
    },
    "skills": {
     "level": "yes",
     "text": "`.devin/skills/` or `.windsurf/skills/`, `.agents/skills/`; global `~/.config/devin/skills/`, `~/.agents/skills/`"
    },
    "mcp": {
     "level": "yes",
     "text": "Devin Local/CLI: `.devin/mcp_config.json` (project), `.devin/mcp_config.local.json` (local), `~/.config/devin/mcp_config.json` (user). Legacy Cascade: its own `mcp_config.json`"
    },
    "permissions": {
     "level": "yes",
     "text": "Devin Local: deny / ask / allow rules (`Read()`, `Write()`, `Exec()`, fetch, MCP) in `.devin/config.json` or `~/.config/devin/config.json`"
    },
    "sandbox": {
     "level": "yes",
     "text": "Devin Local supports OS-level sandboxing (filesystem + network filtering)"
    },
    "hooks": {
     "level": "yes",
     "text": "Devin CLI/Local hooks in `.devin/`; Cascade Hooks for the legacy agent"
    },
    "sub_claude": {
     "level": "no",
     "text": "Not documented"
    },
    "sub_chatgpt": {
     "level": "no",
     "text": "Not documented"
    },
    "api_key": {
     "level": "unknown",
     "text": "Uses Devin/Windsurf plan quota; BYOK not documented in the pages checked"
    }
   },
   "files": [
    {
     "path": ".devin/rules/*.md",
     "scope": "Workspace",
     "note": "One rule per file with `trigger` frontmatter (legacy .windsurf/rules/)"
    },
    {
     "path": "~/.codeium/windsurf/memories/global_rules.md",
     "scope": "User",
     "note": "Cascade global rules, always on, 6,000 chars"
    },
    {
     "path": "AGENTS.md (root / subfolders)",
     "scope": "Workspace",
     "note": "Always-on at root, directory-scoped below"
    },
    {
     "path": "~/.config/devin/AGENTS.md",
     "scope": "User",
     "note": "Devin Local / CLI global rules"
    },
    {
     "path": ".devin/config.json / ~/.config/devin/config.json",
     "scope": "Project / user",
     "note": "Devin Local permissions and settings"
    },
    {
     "path": ".devin/mcp_config.json",
     "scope": "Project",
     "note": "Devin Local MCP servers (mcp_config.local.json for personal)"
    },
    {
     "path": ".devin/skills/<name>/SKILL.md",
     "scope": "Project",
     "note": "Skills (also .windsurf/skills, .agents/skills)"
    }
   ],
   "examples": [
    {
     "title": "Glob-triggered workspace rule",
     "file": ".devin/rules/tests.md",
     "lang": "markdown",
     "code": "---\ntrigger: glob\nglobs: \"**/*.test.ts\"\n---\n\nUse vitest. Never mock the database layer; use the test container.\n"
    }
   ],
   "preset": {
    "title": "Safe Devin Local permissions",
    "file": ".devin/config.json",
    "lang": "json",
    "code": "{\n  \"permissions\": {\n    \"allow\": [\n      \"Read(**)\",\n      \"Exec(git status)\",\n      \"Exec(git diff)\",\n      \"Exec(npm test)\"\n    ],\n    \"ask\": [\n      \"Exec(git push)\",\n      \"Exec(npm install)\"\n    ],\n    \"deny\": [\n      \"Exec(rm)\",\n      \"Exec(sudo)\",\n      \"Exec(git push --force)\",\n      \"Exec(git reset --hard)\",\n      \"Exec(terraform destroy)\",\n      \"Read(**/.env)\",\n      \"Read(**/*.pem)\"\n    ]\n  }\n}\n",
    "note": "Deny has the highest priority. Shape follows the Devin CLI permissions reference. Turn on the Devin Local sandbox so `Read(...)` denies also hide paths from shell commands."
   },
   "gotchas": [
    "Windsurf was renamed Devin Desktop on June 2, 2026. `.devin/` is now preferred and takes precedence over `.windsurf/`.",
    "Workspace rule files are capped at 12,000 characters and the global rules file at 6,000.",
    "Devin Local prompts before MCP tool calls by default, unlike Cascade.",
    "The MCP config location changed in Devin CLI v3000.3; older versions kept servers in the main config file."
   ],
   "faqs": [
    {
     "q": "Where are Windsurf rules stored now?",
     "a": "In Devin Desktop (the renamed Windsurf), workspace rules go in .devin/rules/*.md, with .windsurf/rules/ still read as a fallback. The Cascade global rules file is ~/.codeium/windsurf/memories/global_rules.md."
    },
    {
     "q": "Does Windsurf / Devin Desktop support AGENTS.md?",
     "a": "Yes. AGENTS.md at the workspace root is treated as an always-on rule, and AGENTS.md files in subdirectories apply when working in those folders."
    },
    {
     "q": "Where is the Devin Desktop MCP config?",
     "a": "For the Devin Local agent: .devin/mcp_config.json in the project, .devin/mcp_config.local.json for personal servers, or ~/.config/devin/mcp_config.json for all projects."
    }
   ],
   "sources": [
    {
     "label": "Memories & Rules",
     "url": "https://docs.devin.ai/desktop/cascade/memories"
    },
    {
     "label": "Devin Local agent",
     "url": "https://docs.devin.ai/desktop/devin-local"
    },
    {
     "label": "Devin CLI rules",
     "url": "https://docs.devin.ai/cli/extensibility/rules"
    },
    {
     "label": "Devin CLI MCP configuration",
     "url": "https://docs.devin.ai/cli/extensibility/mcp/configuration"
    },
    {
     "label": "Devin CLI skills",
     "url": "https://docs.devin.ai/cli/extensibility/skills/overview"
    },
    {
     "label": "Devin CLI hooks",
     "url": "https://docs.devin.ai/cli/extensibility/hooks/overview"
    },
    {
     "label": "Devin CLI permissions",
     "url": "https://docs.devin.ai/cli/reference/permissions"
    }
   ],
   "verified": "2026-10-12",
   "bridge": "Native: root AGENTS.md is an always-on rule; subfolder files are scoped."
  },
  {
   "slug": "cline",
   "name": "Cline",
   "tool": "cline",
   "vendor": "Cline Bot Inc.",
   "surfaces": [
    "ide",
    "cli"
   ],
   "title": "Cline Rules Guide: .clinerules, AGENTS.md, MCP Settings, Auto-Approve",
   "desc": "Where Cline reads .clinerules and global rules, AGENTS.md support, skills folders, cline_mcp_settings.json, auto-approve and YOLO mode, and using a Claude or ChatGPT subscription.",
   "answer": "Cline reads workspace rules from `.clinerules/` or `.cline/rules/`, global rules from `~/Documents/Cline/Rules`, and also detects `.cursorrules`, `.windsurfrules`, `AGENTS.md` and `~/.agents/AGENTS.md`. MCP servers are stored in Cline's `cline_mcp_settings.json`. Auto Approve toggles control reads, edits and commands. You can use a Claude Pro/Max plan through the Claude Code provider (it calls your installed, logged-in Claude CLI) or a ChatGPT plan through the OpenAI Codex sign-in provider.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`~/Documents/Cline/Rules` (also `~/.cline/rules`), `~/.agents/AGENTS.md`"
    },
    "instr_project": {
     "level": "yes",
     "text": "`.clinerules/` or `.cline/rules/`; auto-detects `.cursorrules`, `.windsurfrules`, `AGENTS.md`"
    },
    "instr_nested": {
     "level": "unknown",
     "text": "Not documented"
    },
    "agents_md": {
     "level": "yes",
     "text": "`AGENTS.md` and global `~/.agents/AGENTS.md`"
    },
    "skills": {
     "level": "yes",
     "text": "`.cline/skills/` (recommended), `.clinerules/skills/`, `.claude/skills/`; global `~/.cline/skills/`"
    },
    "mcp": {
     "level": "yes",
     "text": "IDE: MCP Servers → Configure → `cline_mcp_settings.json` (`mcpServers`). CLI: `~/.cline/data/settings/cline_mcp_settings.json`"
    },
    "permissions": {
     "level": "partial",
     "text": "Auto Approve per category (read, edit, safe commands, all commands) and YOLO mode; the model flags commands as requiring approval, no fixed allowlist"
    },
    "sandbox": {
     "level": "unknown",
     "text": "Not documented for the local extension"
    },
    "hooks": {
     "level": "partial",
     "text": "Lifecycle hooks via plugins"
    },
    "sub_claude": {
     "level": "yes",
     "text": "Claude Code provider: uses your Claude Pro/Max limits via the installed, logged-in Claude CLI"
    },
    "sub_chatgpt": {
     "level": "yes",
     "text": "OpenAI Codex provider: sign in with your ChatGPT account (OAuth)"
    },
    "api_key": {
     "level": "yes",
     "text": "Anthropic, OpenAI, OpenRouter, Bedrock, Gemini and many more providers"
    }
   },
   "files": [
    {
     "path": ".clinerules/ or .cline/rules/",
     "scope": "Workspace",
     "note": "Rule markdown files"
    },
    {
     "path": "~/Documents/Cline/Rules",
     "scope": "User",
     "note": "Global rules"
    },
    {
     "path": "AGENTS.md / ~/.agents/AGENTS.md",
     "scope": "Workspace / user",
     "note": "Cross-tool instructions"
    },
    {
     "path": ".cursorrules / .windsurfrules",
     "scope": "Workspace",
     "note": "Detected automatically"
    },
    {
     "path": "cline_mcp_settings.json",
     "scope": "User",
     "note": "MCP servers (CLI: ~/.cline/data/settings/)"
    },
    {
     "path": ".cline/skills/<name>/SKILL.md",
     "scope": "Workspace",
     "note": "Skills (global: ~/.cline/skills/)"
    }
   ],
   "examples": [
    {
     "title": "Workspace rule",
     "file": ".clinerules/testing.md",
     "lang": "markdown",
     "code": "# Testing\n\n- Run `pytest -q` after every change to `app/`.\n- Never edit files under `migrations/` without asking.\n"
    }
   ],
   "preset": {
    "title": "Safe Cline Auto Approve settings",
    "file": "Cline → Auto Approve",
    "lang": "text",
    "code": "Read project files ............ ON\nRead all files ................ OFF   (keeps ~/.ssh, ~/.aws out of reach without asking)\nEdit project files ............ ON    (review diffs before committing)\nEdit all files ................ OFF\nExecute safe commands ......... ON\nExecute all commands .......... OFF   (rm -rf, git push --force, psql DROP ... always ask)\nUse the browser ............... OFF\nUse MCP servers ............... ask per tool\nYOLO mode ..................... OFF\n",
    "note": "Cline has no fixed command allowlist: the model marks each command as safe or requiring approval, so treat \"safe commands\" as best-effort. Keep \"Execute all commands\" and YOLO off and add a rule such as \"Never run destructive commands; ask first\" in .clinerules."
   },
   "gotchas": [
    "Command safety is decided by the model's approval flag, not by a deterministic list.",
    "The Claude Code provider runs your installed Claude CLI and uses its subscription limits; some features (such as images) are limited in that mode.",
    "Workspace rules win over global rules when they conflict; both are combined."
   ],
   "faqs": [
    {
     "q": "Where are Cline rules stored?",
     "a": "Workspace rules go in .clinerules/ or .cline/rules/ at the project root. Global rules go in ~/Documents/Cline/Rules. Cline also reads AGENTS.md, .cursorrules and .windsurfrules."
    },
    {
     "q": "Can Cline use my Claude Max subscription?",
     "a": "Yes, through the Claude Code provider: install and log in to the Claude CLI, then pick Claude Code as the provider. Requests use your subscription limits instead of API billing."
    },
    {
     "q": "Where is the Cline MCP settings file?",
     "a": "Open MCP Servers → Configure → Configure MCP Servers in the extension to edit cline_mcp_settings.json. The CLI uses ~/.cline/data/settings/cline_mcp_settings.json."
    }
   ],
   "sources": [
    {
     "label": "Rules",
     "url": "https://docs.cline.bot/customization/cline-rules"
    },
    {
     "label": "Skills",
     "url": "https://docs.cline.bot/customization/skills"
    },
    {
     "label": "MCP",
     "url": "https://docs.cline.bot/mcp/mcp-overview"
    },
    {
     "label": "Auto Approve & YOLO",
     "url": "https://docs.cline.bot/features/auto-approve"
    },
    {
     "label": "Anthropic / Claude Code provider",
     "url": "https://docs.cline.bot/provider-config/anthropic"
    },
    {
     "label": "OpenAI Codex provider",
     "url": "https://docs.cline.bot/provider-config/openai"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native: AGENTS.md is detected automatically."
  },
  {
   "slug": "roo-code",
   "name": "Roo Code",
   "tool": null,
   "vendor": "Roo Code, Inc.",
   "status": "sunset",
   "status_note": "The Roo Code extension was shut down on May 15, 2026 and its GitHub repository is archived.",
   "surfaces": [
    "ide"
   ],
   "title": "Roo Code Config (Discontinued): .roo/rules, AGENTS.md & Migration",
   "desc": "Roo Code shut down on May 15, 2026. Where its rules, .roo/mcp.json and skills lived, and how to move them to Cline, Kilo Code or another agent that reads AGENTS.md.",
   "answer": "Roo Code was shut down on May 15, 2026 and its repository is archived. Existing installs used `.roo/rules/` (or `.roorules`), mode-specific `.roo/rules-<mode>/`, global `~/.roo/rules/`, and `AGENTS.md` (on by default). MCP servers were in `mcp_settings.json` (global) and `.roo/mcp.json` (project). To migrate, move your rules into `AGENTS.md` and `.roo/mcp.json` into the new agent's MCP file. Cline, Kilo Code and OpenCode all read AGENTS.md.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`~/.roo/rules/`, `~/.roo/rules-<mode>/`"
    },
    "instr_project": {
     "level": "yes",
     "text": "`.roo/rules/` (preferred) or `.roorules`; `.roo/rules-<mode>/`"
    },
    "instr_nested": {
     "level": "unknown",
     "text": "Not documented"
    },
    "agents_md": {
     "level": "yes",
     "text": "Root `AGENTS.md` (or `AGENT.md`), on by default"
    },
    "skills": {
     "level": "yes",
     "text": "`.roo/skills/`, `.agents/skills/`; global `~/.roo/skills/`, `~/.agents/skills/`"
    },
    "mcp": {
     "level": "yes",
     "text": "Global `mcp_settings.json`; project `.roo/mcp.json`"
    },
    "permissions": {
     "level": "yes",
     "text": "Auto-approve with allowed / denied command prefix lists"
    },
    "sandbox": {
     "level": "unknown",
     "text": "Not documented"
    },
    "hooks": {
     "level": "unknown",
     "text": "Not documented"
    },
    "sub_claude": {
     "level": "unknown",
     "text": "Not verified (product discontinued)"
    },
    "sub_chatgpt": {
     "level": "unknown",
     "text": "Not verified (product discontinued)"
    },
    "api_key": {
     "level": "yes",
     "text": "Your own provider keys"
    }
   },
   "files": [
    {
     "path": ".roo/rules/*.md",
     "scope": "Workspace",
     "note": "Rules (fallback .roorules)"
    },
    {
     "path": ".roo/rules-<mode>/",
     "scope": "Workspace",
     "note": "Mode-specific rules"
    },
    {
     "path": "~/.roo/rules/",
     "scope": "User",
     "note": "Global rules"
    },
    {
     "path": ".roo/mcp.json",
     "scope": "Project",
     "note": "Project MCP servers"
    },
    {
     "path": "mcp_settings.json",
     "scope": "User",
     "note": "Global MCP servers"
    }
   ],
   "examples": [
    {
     "title": "Project MCP file to migrate",
     "file": ".roo/mcp.json",
     "lang": "json",
     "code": "{\n  \"mcpServers\": {\n    \"context7\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"@upstash/context7-mcp\"]\n    }\n  }\n}\n"
    }
   ],
   "preset": {
    "title": "Migration checklist",
    "file": "terminal",
    "lang": "bash",
    "code": "# 1. Merge Roo rules into one AGENTS.md at the repo root\ncat .roo/rules/*.md >> AGENTS.md        # review and dedupe afterwards\n# 2. Keep mode-specific rules as skills or separate sections\n# 3. Move .roo/mcp.json servers into the new agent's MCP file\n#    (Cline: cline_mcp_settings.json, Kilo: kilo.jsonc \"mcp\", OpenCode: opencode.json \"mcp\")\n# 4. Recreate your denied commands as the new agent's deny rules\n",
    "note": "Roo Code and Cline share history, so Cline is the closest switch; Kilo Code also reads AGENTS.md and .agents/skills."
   },
   "gotchas": [
    "The extension is discontinued; don't rely on it receiving security fixes.",
    "Roo's denied commands were prefix matches; check how your new agent matches commands before copying the list."
   ],
   "faqs": [
    {
     "q": "Is Roo Code discontinued?",
     "a": "Yes. The Roo Code extension was shut down on May 15, 2026 and the RooCodeInc/Roo-Code repository is archived."
    },
    {
     "q": "How do I migrate Roo Code rules?",
     "a": "Combine .roo/rules/*.md (and .roorules) into an AGENTS.md at the repository root, move .roo/mcp.json servers to your new agent's MCP config, and recreate your allowed/denied command lists as permission rules."
    }
   ],
   "sources": [
    {
     "label": "Roo Code repository (archived, shutdown notice)",
     "url": "https://github.com/RooCodeInc/Roo-Code"
    },
    {
     "label": "Custom instructions",
     "url": "https://docs.roocode.com/features/custom-instructions"
    },
    {
     "label": "MCP in Roo",
     "url": "https://docs.roocode.com/features/mcp/using-mcp-in-roo"
    },
    {
     "label": "Auto-approving actions",
     "url": "https://docs.roocode.com/features/auto-approving-actions"
    },
    {
     "label": "Skills",
     "url": "https://docs.roocode.com/features/skills"
    }
   ],
   "verified": "2026-10-12",
   "bridge": "Native (product discontinued)."
  },
  {
   "slug": "kilo-code",
   "name": "Kilo Code",
   "tool": "kilo-code",
   "vendor": "Kilo Code",
   "surfaces": [
    "ide",
    "cli"
   ],
   "title": "Kilo Code Config: AGENTS.md, kilo.jsonc Rules, MCP, Permissions",
   "desc": "Kilo Code reads AGENTS.md, rule files listed in kilo.jsonc, .kilo/ and legacy .kilocode/rules; MCP under the mcp key, skills dirs, allow/ask/deny permissions and ChatGPT sign-in.",
   "answer": "Kilo Code loads `AGENTS.md` (or `AGENT.md`) from the project root automatically, plus subdirectory AGENTS.md files when the agent works there. Other rules are files listed under `instructions` in `kilo.jsonc` (project, or `.kilo/kilo.jsonc`) or `~/.config/kilo/kilo.jsonc` (global); legacy `.kilocode/rules/` still works. MCP servers go under the `mcp` key of the same file, and permissions are allow / ask / deny rules under `permission`. You can connect a ChatGPT Plus/Pro subscription for OpenAI models.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`instructions` in `~/.config/kilo/kilo.jsonc`; `~/.kilo/rules/*.md`"
    },
    "instr_project": {
     "level": "yes",
     "text": "`AGENTS.md` / `AGENT.md`; files under `instructions` in `kilo.jsonc` or `.kilo/kilo.jsonc` (e.g. `.kilo/rules/*.md`); legacy `.kilocode/rules/`"
    },
    "instr_nested": {
     "level": "yes",
     "text": "Subdirectory AGENTS.md loads when the agent accesses files there"
    },
    "agents_md": {
     "level": "yes",
     "text": "Loaded automatically; replaces the deprecated memory bank"
    },
    "skills": {
     "level": "yes",
     "text": "`.kilo/skills/`, `~/.kilo/skills/`, `.agents/skills/`, `~/.agents/skills/`; `.claude/skills/` with Claude Code compatibility on"
    },
    "mcp": {
     "level": "yes",
     "text": "`mcp` key in `kilo.jsonc` / `.kilo/kilo.jsonc` or `~/.config/kilo/kilo.jsonc`"
    },
    "permissions": {
     "level": "yes",
     "text": "`permission` in kilo.jsonc: `allow` / `ask` / `deny` per tool (read, edit, bash, webfetch…) with patterns"
    },
    "sandbox": {
     "level": "yes",
     "text": "Optional OS sandbox (off by default; macOS/Linux, not Windows): limits writes and blocks network"
    },
    "hooks": {
     "level": "partial",
     "text": "Plugins (`.kilo/plugin/*.ts`) with events such as `tool.execute.before`"
    },
    "sub_claude": {
     "level": "unknown",
     "text": "Not documented"
    },
    "sub_chatgpt": {
     "level": "yes",
     "text": "Connect a ChatGPT Plus/Pro subscription for supported OpenAI models"
    },
    "api_key": {
     "level": "yes",
     "text": "Kilo Gateway credits or your own provider keys"
    }
   },
   "files": [
    {
     "path": "AGENTS.md",
     "scope": "Project",
     "note": "Primary instructions (root + subdirectories)"
    },
    {
     "path": "kilo.jsonc or .kilo/kilo.jsonc",
     "scope": "Project",
     "note": "instructions, mcp, permission"
    },
    {
     "path": "~/.config/kilo/kilo.jsonc",
     "scope": "User",
     "note": "Global config"
    },
    {
     "path": ".kilo/rules/*.md",
     "scope": "Project",
     "note": "Rule files referenced from instructions"
    },
    {
     "path": ".kilocode/rules/",
     "scope": "Project (legacy)",
     "note": "Still read"
    },
    {
     "path": ".kilo/skills/<name>/SKILL.md",
     "scope": "Project",
     "note": "Skills (also .agents/skills)"
    }
   ],
   "examples": [
    {
     "title": "Rules and MCP in one file",
     "file": "kilo.jsonc",
     "lang": "json",
     "code": "{\n  \"instructions\": [\".kilo/rules/*.md\"],\n  \"mcp\": {\n    \"context7\": {\n      \"type\": \"local\",\n      \"command\": [\"npx\", \"-y\", \"@upstash/context7-mcp\"],\n      \"enabled\": true\n    }\n  }\n}\n"
    }
   ],
   "preset": {
    "title": "Safe Kilo permissions",
    "file": "kilo.jsonc",
    "lang": "json",
    "code": "{\n  \"permission\": {\n    \"read\": \"allow\",\n    \"glob\": \"allow\",\n    \"grep\": \"allow\",\n    \"edit\": \"ask\",\n    \"webfetch\": \"ask\",\n    \"bash\": \"ask\"\n  }\n}\n",
    "note": "This is the documented safe baseline: every edit and shell command asks first, and \"Approve always\" saves narrow allow rules as you go. Enable the optional sandbox so model-run commands can't write outside the project or reach the network."
   },
   "gotchas": [
    "The memory bank feature is deprecated; move it into AGENTS.md.",
    "Sandboxing is off by default and not available on Windows.",
    "`.claude/skills` only load when Claude Code compatibility is enabled."
   ],
   "faqs": [
    {
     "q": "Does Kilo Code support AGENTS.md?",
     "a": "Yes. Kilo Code loads AGENTS.md (or AGENT.md) from the project root automatically and subdirectory AGENTS.md files when it works in those folders."
    },
    {
     "q": "Where is the Kilo Code MCP config?",
     "a": "Under the mcp key in kilo.jsonc (or .kilo/kilo.jsonc) in the project, or in ~/.config/kilo/kilo.jsonc for all projects."
    }
   ],
   "sources": [
    {
     "label": "AGENTS.md",
     "url": "https://kilo.ai/docs/customize/agents-md"
    },
    {
     "label": "Custom rules",
     "url": "https://kilo.ai/docs/customize/custom-rules"
    },
    {
     "label": "Skills",
     "url": "https://kilo.ai/docs/customize/skills"
    },
    {
     "label": "Agent permissions",
     "url": "https://kilo.ai/docs/customize/agent-permissions"
    },
    {
     "label": "MCP in Kilo Code",
     "url": "https://kilo.ai/docs/automate/mcp/using-in-kilo-code"
    },
    {
     "label": "Sandboxing",
     "url": "https://kilo.ai/docs/getting-started/settings/sandboxing"
    },
    {
     "label": "ChatGPT Plus/Pro",
     "url": "https://kilo.ai/docs/ai-providers/openai-chatgpt-plus-pro"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native: loaded automatically from the project root and subfolders."
  },
  {
   "slug": "aider",
   "name": "Aider",
   "tool": "aider",
   "vendor": "Aider (open source)",
   "surfaces": [
    "cli"
   ],
   "title": "Aider Config Guide: CONVENTIONS.md, .aider.conf.yml & AGENTS.md",
   "desc": "Aider does not auto-load AGENTS.md: load it with --read or read: in .aider.conf.yml. Config file locations, git safety and what Aider lacks (MCP, sandbox, hooks).",
   "answer": "Aider does not discover instruction files automatically. Load your conventions as read-only context with `aider --read CONVENTIONS.md` (or `--read AGENTS.md`), or make it permanent with `read: AGENTS.md` in `.aider.conf.yml`, which Aider looks for in your home directory, the git root and the current directory. Aider's docs do not describe MCP, a sandbox, hooks or skills. Its safety net is git: it commits each change so you can `/undo`. Use it with API keys for your model provider.",
   "cols": {
    "instr_global": {
     "level": "partial",
     "text": "`read:` in `~/.aider.conf.yml`"
    },
    "instr_project": {
     "level": "partial",
     "text": "Only files you pass with `--read` / `/read` or list under `read:` in `.aider.conf.yml`"
    },
    "instr_nested": {
     "level": "no",
     "text": "No automatic discovery"
    },
    "agents_md": {
     "level": "partial",
     "text": "Not auto-loaded; `read: AGENTS.md` works like any conventions file"
    },
    "skills": {
     "level": "unknown",
     "text": "Not documented"
    },
    "mcp": {
     "level": "unknown",
     "text": "Not documented in Aider's docs"
    },
    "permissions": {
     "level": "partial",
     "text": "Confirms suggested shell commands; `--yes-always` skips confirmations; auto-commits every edit"
    },
    "sandbox": {
     "level": "unknown",
     "text": "Not documented"
    },
    "hooks": {
     "level": "partial",
     "text": "`--lint-cmd` / `--test-cmd` run after edits (no general hook system documented)"
    },
    "sub_claude": {
     "level": "unknown",
     "text": "Not documented"
    },
    "sub_chatgpt": {
     "level": "unknown",
     "text": "Not documented"
    },
    "api_key": {
     "level": "yes",
     "text": "API keys for Anthropic, OpenAI, Gemini, DeepSeek, OpenRouter, local models and more"
    }
   },
   "files": [
    {
     "path": ".aider.conf.yml",
     "scope": "Home / git root / cwd",
     "note": "All CLI options as YAML"
    },
    {
     "path": "CONVENTIONS.md or AGENTS.md",
     "scope": "Project",
     "note": "Loaded only via read: / --read"
    },
    {
     "path": ".aiderignore",
     "scope": "Git root",
     "note": "Files Aider should ignore"
    }
   ],
   "examples": [
    {
     "title": "Always load AGENTS.md",
     "file": ".aider.conf.yml",
     "lang": "yaml",
     "code": "read: [AGENTS.md]\nauto-commits: true\ntest-cmd: npm test\nauto-test: true\n"
    }
   ],
   "preset": {
    "title": "Safe Aider config",
    "file": ".aider.conf.yml",
    "lang": "yaml",
    "code": "read: [AGENTS.md]\nauto-commits: true      # every edit is a git commit you can /undo\nyes-always: false       # keep confirming shell commands\ntest-cmd: npm test\nauto-test: true\n",
    "note": "Aider has no permission rule engine or sandbox in its docs, so run it in a container or VM for risky repos and never pass --yes-always there."
   },
   "gotchas": [
    "Nothing is loaded unless you ask: an AGENTS.md in the repo is ignored until you add `read:`.",
    "Files passed with `--read` are read-only context and can be cached when prompt caching is on.",
    "`--yes-always` auto-confirms everything, including suggested shell commands."
   ],
   "faqs": [
    {
     "q": "Does Aider read AGENTS.md?",
     "a": "Not automatically. Add read: [AGENTS.md] to .aider.conf.yml or start Aider with --read AGENTS.md; the file is then loaded read-only on every run."
    },
    {
     "q": "Where is the Aider config file?",
     "a": ".aider.conf.yml in your home directory, the git repository root or the current directory. Most command-line options can be set there."
    }
   ],
   "sources": [
    {
     "label": "Specifying coding conventions",
     "url": "https://aider.chat/docs/usage/conventions.html"
    },
    {
     "label": "YAML config file",
     "url": "https://aider.chat/docs/config/aider_conf.html"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Add `read: [AGENTS.md]` to `.aider.conf.yml` (or run `aider --read AGENTS.md`)."
  },
  {
   "slug": "opencode",
   "name": "OpenCode",
   "tool": "opencode",
   "vendor": "SST / Anomaly",
   "surfaces": [
    "cli",
    "ide"
   ],
   "title": "OpenCode Config: AGENTS.md, opencode.json Permissions, MCP, Skills",
   "desc": "OpenCode reads AGENTS.md (CLAUDE.md as fallback), ~/.config/opencode, opencode.json permission and mcp keys, skills dirs and plugins. Which subscriptions work: ChatGPT Plus, Copilot.",
   "answer": "OpenCode reads `AGENTS.md` by walking up from the current directory, falls back to `CLAUDE.md` if there is no AGENTS.md, and adds global `~/.config/opencode/AGENTS.md` (or `~/.claude/CLAUDE.md`). Configuration is `opencode.json` in the project or `~/.config/opencode/opencode.json`: `mcp` for servers, `permission` for allow / ask / deny rules (the last matching rule wins), `instructions` for extra files. Skills load from `.opencode/skills`, `.claude/skills` and `.agents/skills`. ChatGPT Plus and GitHub Copilot subscriptions work out of the box; Claude Pro/Max is not supported because Anthropic prohibits it.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`~/.config/opencode/AGENTS.md`, else `~/.claude/CLAUDE.md`"
    },
    "instr_project": {
     "level": "yes",
     "text": "`AGENTS.md` (else `CLAUDE.md`) found by traversing up from cwd; `instructions` array in opencode.json"
    },
    "instr_nested": {
     "level": "partial",
     "text": "Parent directories by traversing up; first match wins"
    },
    "agents_md": {
     "level": "yes",
     "text": "Primary format"
    },
    "skills": {
     "level": "yes",
     "text": "`.opencode/skills/`, `.claude/skills/`, `.agents/skills/`; global `~/.config/opencode/skills/`, `~/.claude/skills/`, `~/.agents/skills/`"
    },
    "mcp": {
     "level": "yes",
     "text": "`mcp` key in `opencode.json` / `opencode.jsonc` (project or `~/.config/opencode/`)"
    },
    "permissions": {
     "level": "yes",
     "text": "`permission` in opencode.json: allow / ask / deny per tool (bash, edit, webfetch, external_directory…) with wildcards; last matching rule wins"
    },
    "sandbox": {
     "level": "unknown",
     "text": "Not documented"
    },
    "hooks": {
     "level": "yes",
     "text": "Plugins in `.opencode/plugins/` subscribe to events such as tool execution"
    },
    "sub_claude": {
     "level": "no",
     "text": "Not supported: Anthropic prohibits Claude Pro/Max in third-party tools; OpenCode removed those plugins in v1.3.0"
    },
    "sub_chatgpt": {
     "level": "yes",
     "text": "ChatGPT Plus works with zero setup (also GitHub Copilot, GitLab Duo)"
    },
    "api_key": {
     "level": "yes",
     "text": "75+ providers via API keys, local models"
    }
   },
   "files": [
    {
     "path": "AGENTS.md",
     "scope": "Project",
     "note": "Instructions (CLAUDE.md fallback)"
    },
    {
     "path": "~/.config/opencode/AGENTS.md",
     "scope": "User",
     "note": "Global instructions"
    },
    {
     "path": "opencode.json / opencode.jsonc",
     "scope": "Project",
     "note": "permission, mcp, instructions, provider"
    },
    {
     "path": "~/.config/opencode/opencode.json",
     "scope": "User",
     "note": "Global config"
    },
    {
     "path": ".opencode/plugins/",
     "scope": "Project",
     "note": "Plugins / hooks"
    },
    {
     "path": ".opencode/skills/<name>/SKILL.md",
     "scope": "Project",
     "note": "Skills (also .claude/skills, .agents/skills)"
    }
   ],
   "examples": [
    {
     "title": "MCP server",
     "file": "opencode.json",
     "lang": "json",
     "code": "{\n  \"$schema\": \"https://opencode.ai/config.json\",\n  \"mcp\": {\n    \"context7\": {\n      \"type\": \"remote\",\n      \"url\": \"https://mcp.context7.com/mcp\"\n    }\n  }\n}\n"
    },
    {
     "title": "Turn off Claude Code compatibility",
     "file": "shell",
     "lang": "bash",
     "code": "export OPENCODE_DISABLE_CLAUDE_CODE=1   # ignore CLAUDE.md and .claude/skills\n"
    }
   ],
   "preset": {
    "title": "Safe opencode.json permissions",
    "file": "opencode.json",
    "lang": "json",
    "code": "{\n  \"$schema\": \"https://opencode.ai/config.json\",\n  \"permission\": {\n    \"edit\": \"ask\",\n    \"webfetch\": \"ask\",\n    \"bash\": {\n      \"*\": \"ask\",\n      \"git status*\": \"allow\",\n      \"git diff*\": \"allow\",\n      \"npm test*\": \"allow\",\n      \"rm -rf *\": \"deny\",\n      \"sudo *\": \"deny\",\n      \"git push --force*\": \"deny\",\n      \"git push -f*\": \"deny\",\n      \"git reset --hard*\": \"deny\",\n      \"*DROP TABLE*\": \"deny\",\n      \"terraform destroy*\": \"deny\"\n    }\n  }\n}\n",
    "note": "OpenCode applies the LAST matching rule, so keep the catch-all `*` first and put deny rules at the end. `*` matches zero or more of any character."
   },
   "gotchas": [
    "If both AGENTS.md and CLAUDE.md exist, only AGENTS.md is used.",
    "Permission rules are last-match-wins, the opposite of Claude Code's deny-first model.",
    "Older guides mention Claude Pro/Max plugins; OpenCode removed them in v1.3.0 and Anthropic prohibits that use."
   ],
   "faqs": [
    {
     "q": "Can I use Claude Max with OpenCode?",
     "a": "No. OpenCode's provider docs say Anthropic prohibits using Claude Pro/Max through third-party plugins, and OpenCode stopped bundling them in v1.3.0. Use an Anthropic API key, or a ChatGPT Plus or GitHub Copilot subscription, which OpenCode supports."
    },
    {
     "q": "Does OpenCode read CLAUDE.md?",
     "a": "Yes, as a fallback: CLAUDE.md in the project is used only if there is no AGENTS.md, and ~/.claude/CLAUDE.md only if there is no ~/.config/opencode/AGENTS.md. Set OPENCODE_DISABLE_CLAUDE_CODE=1 to turn this off."
    }
   ],
   "sources": [
    {
     "label": "Rules",
     "url": "https://opencode.ai/docs/rules"
    },
    {
     "label": "Permissions",
     "url": "https://opencode.ai/docs/permissions"
    },
    {
     "label": "MCP servers",
     "url": "https://opencode.ai/docs/mcp-servers"
    },
    {
     "label": "Skills",
     "url": "https://opencode.ai/docs/skills"
    },
    {
     "label": "Plugins",
     "url": "https://opencode.ai/docs/plugins"
    },
    {
     "label": "Providers",
     "url": "https://opencode.ai/docs/providers"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native. If CLAUDE.md also exists, OpenCode uses only AGENTS.md."
  },
  {
   "slug": "zed",
   "name": "Zed",
   "tool": "zed",
   "vendor": "Zed Industries",
   "surfaces": [
    "ide"
   ],
   "title": "Zed AI Config: .rules vs AGENTS.md, context_servers, Tool Permissions",
   "desc": "Which instruction file the Zed agent picks (.rules, .cursorrules, AGENTS.md, CLAUDE.md…), ~/.config/zed/AGENTS.md, MCP context_servers, tool_permissions and skills.",
   "answer": "Zed's own agent loads personal instructions from `~/.config/zed/AGENTS.md` and exactly one project file: the first match in `.rules`, `.cursorrules`, `.windsurfrules`, `.clinerules`, `.github/copilot-instructions.md`, `AGENT.md`, `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`. MCP servers are `context_servers` in Zed's `settings.json`, and tool approvals are regex rules in `agent.tool_permissions` (allow, confirm, deny). External agents such as Claude Agent and Codex run through ACP with their own login, so a Claude or ChatGPT subscription works only inside those agents.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`~/.config/zed/AGENTS.md`"
    },
    "instr_project": {
     "level": "yes",
     "text": "First match of `.rules`, `.cursorrules`, `.windsurfrules`, `.clinerules`, `.github/copilot-instructions.md`, `AGENT.md`, `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`"
    },
    "instr_nested": {
     "level": "unknown",
     "text": "Not documented"
    },
    "agents_md": {
     "level": "partial",
     "text": "Yes, but `.rules`, `.cursorrules`, `.windsurfrules`, `.clinerules`, `copilot-instructions.md` or `AGENT.md` take priority"
    },
    "skills": {
     "level": "yes",
     "text": "`~/.agents/skills/` and `<worktree>/.agents/skills/` (flat layout)"
    },
    "mcp": {
     "level": "yes",
     "text": "`context_servers` in Zed `settings.json`, or MCP extensions"
    },
    "permissions": {
     "level": "yes",
     "text": "`agent.tool_permissions` (v0.224+): `default` plus per-tool `always_allow` / `always_confirm` / `always_deny` regex patterns"
    },
    "sandbox": {
     "level": "unknown",
     "text": "Not documented"
    },
    "hooks": {
     "level": "unknown",
     "text": "Not documented"
    },
    "sub_claude": {
     "level": "partial",
     "text": "Only via the Claude Agent (ACP), which has its own login"
    },
    "sub_chatgpt": {
     "level": "partial",
     "text": "Only via the Codex external agent"
    },
    "api_key": {
     "level": "yes",
     "text": "Zed's hosted models or your own provider keys"
    }
   },
   "files": [
    {
     "path": "~/.config/zed/AGENTS.md",
     "scope": "User",
     "note": "Personal instructions"
    },
    {
     "path": ".rules … GEMINI.md (first match)",
     "scope": "Project",
     "note": "One project instruction file"
    },
    {
     "path": "~/.config/zed/settings.json",
     "scope": "User",
     "note": "agent.tool_permissions, context_servers"
    },
    {
     "path": ".agents/skills/<name>/SKILL.md",
     "scope": "Project",
     "note": "Skills (also ~/.agents/skills)"
    }
   ],
   "examples": [
    {
     "title": "MCP server",
     "file": "~/.config/zed/settings.json",
     "lang": "json",
     "code": "{\n  \"context_servers\": {\n    \"postgres\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"@modelcontextprotocol/server-postgres\", \"postgresql://readonly@localhost/app\"]\n    }\n  }\n}\n"
    }
   ],
   "preset": {
    "title": "Safe Zed tool permissions",
    "file": "~/.config/zed/settings.json",
    "lang": "json",
    "code": "{\n  \"agent\": {\n    \"tool_permissions\": {\n      \"default\": \"confirm\",\n      \"tools\": {\n        \"terminal\": {\n          \"default\": \"confirm\",\n          \"always_allow\": [\n            { \"pattern\": \"^git\\\\s+(status|diff|log)\" },\n            { \"pattern\": \"^npm\\\\s+(test|run lint)\" }\n          ],\n          \"always_deny\": [\n            { \"pattern\": \"rm\\\\s+-[a-z]*r[a-z]*f\" },\n            { \"pattern\": \"git\\\\s+push.*(--force|\\\\s-f)\" },\n            { \"pattern\": \"drop\\\\s+(table|database)\", \"case_sensitive\": false },\n            { \"pattern\": \"terraform\\\\s+destroy\" }\n          ],\n          \"always_confirm\": [\n            { \"pattern\": \"git\\\\s+push\" },\n            { \"pattern\": \"sudo\\\\s\" }\n          ]\n        }\n      }\n    }\n  }\n}\n",
    "note": "Patterns are regular expressions. `always_deny` blocks even when the global default is allow. These rules apply to Zed's own agent; external agents (Claude Agent, Codex) use their own permission settings."
   },
   "gotchas": [
    "Only one project instruction file loads, and `.rules` or `.cursorrules` beats AGENTS.md. Delete stale legacy files or Zed will ignore your AGENTS.md.",
    "Before v0.224 the setting was the boolean `agent.always_allow_tool_actions`.",
    "Skills must be direct children of the skills folder; nested groups are not discovered."
   ],
   "faqs": [
    {
     "q": "Does Zed read AGENTS.md?",
     "a": "Yes. ~/.config/zed/AGENTS.md is loaded as personal instructions, and a project AGENTS.md is used if no higher-priority file (.rules, .cursorrules, .windsurfrules, .clinerules, .github/copilot-instructions.md, AGENT.md) exists."
    },
    {
     "q": "Where do MCP servers go in Zed?",
     "a": "Under context_servers in Zed's settings.json, or install them as Zed MCP extensions."
    }
   ],
   "sources": [
    {
     "label": "Instructions (AGENTS.md)",
     "url": "https://zed.dev/docs/ai/instructions"
    },
    {
     "label": "MCP",
     "url": "https://zed.dev/docs/ai/mcp"
    },
    {
     "label": "Tool permissions",
     "url": "https://zed.dev/docs/ai/tool-permissions"
    },
    {
     "label": "Skills",
     "url": "https://zed.dev/docs/ai/skills"
    },
    {
     "label": "External agents",
     "url": "https://zed.dev/docs/ai/external-agents"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native, but delete `.rules`, `.cursorrules`, `.windsurfrules`, `.clinerules`, `.github/copilot-instructions.md` and `AGENT.md`, which win over AGENTS.md."
  },
  {
   "slug": "amp",
   "name": "Amp",
   "tool": "amp",
   "vendor": "Amp",
   "surfaces": [
    "cli",
    "cloud"
   ],
   "title": "Amp Config Guide: AGENTS.md, Skills, amp.mcpServers & Plugins",
   "desc": "Amp reads AGENTS.md in cwd, parents and subtrees (AGENT.md/CLAUDE.md fallback), ~/.config/amp/AGENTS.md, skills dirs, amp.mcpServers in settings.json and plugin tool.call hooks.",
   "answer": "Amp includes `AGENTS.md` files from the working directory and its parents, subtree AGENTS.md files when it reads files there, and personal `~/.config/amp/AGENTS.md` / `~/.config/AGENTS.md`. If a directory has no AGENTS.md, Amp uses `AGENT.md` or `CLAUDE.md`. Settings live in `~/.config/amp/settings.json` or a workspace `.amp/settings.json` (`amp.mcpServers`, `amp.mcpPermissions`, `amp.tools.disable`). Plugins in `.amp/plugins/` can allow or reject each tool call. You can sign in with ChatGPT Plus or Pro for OpenAI models.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`~/.config/amp/AGENTS.md`, `~/.config/AGENTS.md`; system `/etc/ampcode/AGENTS.md`"
    },
    "instr_project": {
     "level": "yes",
     "text": "`AGENTS.md` in cwd and parent dirs (fallback `AGENT.md` or `CLAUDE.md`)"
    },
    "instr_nested": {
     "level": "yes",
     "text": "Subtree AGENTS.md included when the agent reads a file in that subtree"
    },
    "agents_md": {
     "level": "yes",
     "text": "Primary format"
    },
    "skills": {
     "level": "yes",
     "text": "`.agents/skills/` (project and parents), `~/.config/agents/skills/`, `~/.agents/skills/`, `~/.config/amp/skills/`"
    },
    "mcp": {
     "level": "yes",
     "text": "`amp.mcpServers` in `~/.config/amp/settings.json` or `.amp/settings.json`"
    },
    "permissions": {
     "level": "partial",
     "text": "`amp.mcpPermissions`, `amp.tools.disable`; plugins handle `tool.call` to allow / reject / modify"
    },
    "sandbox": {
     "level": "unknown",
     "text": "Local CLI sandbox not documented"
    },
    "hooks": {
     "level": "yes",
     "text": "Plugins (`.amp/plugins/`, `~/.config/amp/plugins/`): `tool.call`, `tool.result`, session and agent events"
    },
    "sub_claude": {
     "level": "unknown",
     "text": "Not documented"
    },
    "sub_chatgpt": {
     "level": "yes",
     "text": "Sign in with ChatGPT Plus or Pro for OpenAI models"
    },
    "api_key": {
     "level": "partial",
     "text": "Amp credits / plans; BYOK not documented"
    }
   },
   "files": [
    {
     "path": "AGENTS.md",
     "scope": "Project",
     "note": "cwd, parents and subtrees"
    },
    {
     "path": "~/.config/amp/AGENTS.md",
     "scope": "User",
     "note": "Personal guidance"
    },
    {
     "path": "~/.config/amp/settings.json",
     "scope": "User",
     "note": "amp.* settings incl. MCP"
    },
    {
     "path": ".amp/settings.json",
     "scope": "Workspace",
     "note": "Workspace settings"
    },
    {
     "path": ".amp/plugins/",
     "scope": "Project",
     "note": "Plugins (hooks)"
    },
    {
     "path": ".agents/skills/<name>/SKILL.md",
     "scope": "Project",
     "note": "Skills"
    }
   ],
   "examples": [
    {
     "title": "MCP server",
     "file": ".amp/settings.json",
     "lang": "json",
     "code": "{\n  \"amp.mcpServers\": {\n    \"playwright\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"@playwright/mcp@latest\"]\n    }\n  }\n}\n"
    }
   ],
   "preset": {
    "title": "Plugin that rejects destructive shell commands",
    "file": ".amp/plugins/guard.ts",
    "lang": "typescript",
    "code": "import type { PluginAPI } from '@ampcode/plugin'\n\nexport default function (amp: PluginAPI) {\n  amp.on('tool.call', async (event) => {\n    const input = JSON.stringify((event as any).input ?? '')\n    if (/rm -[a-z]*r[a-z]*f|git push.*(--force|-f\\b)|drop (table|database)|terraform destroy/i.test(input)) {\n      return { action: 'reject-and-continue', message: `Blocked by project policy: ${event.tool}` }\n    }\n    return { action: 'allow' }\n  })\n}\n",
    "note": "Built on the documented tool.call event and its allow / reject-and-continue actions. The docs don't list the field that carries the tool's arguments, so `event.input` is an assumption: log `event` once to confirm before relying on this guard."
   },
   "gotchas": [
    "Amp removes features it doesn't use, so older guides may mention settings that no longer exist; check the current settings list.",
    "Project plugins run code on your machine; review `.amp/plugins/` in repos you clone."
   ],
   "faqs": [
    {
     "q": "Does Amp read CLAUDE.md?",
     "a": "Yes, as a fallback: in any directory without AGENTS.md, Amp includes AGENT.md or CLAUDE.md instead."
    },
    {
     "q": "Where does Amp store MCP servers?",
     "a": "Under amp.mcpServers in ~/.config/amp/settings.json, or in a workspace .amp/settings.json."
    }
   ],
   "sources": [
    {
     "label": "AGENTS.md",
     "url": "https://ampcode.com/docs/customize/agents-md"
    },
    {
     "label": "MCP",
     "url": "https://ampcode.com/docs/customize/mcp"
    },
    {
     "label": "Skills",
     "url": "https://ampcode.com/docs/customize/skills"
    },
    {
     "label": "CLI settings",
     "url": "https://ampcode.com/docs/cli/settings"
    },
    {
     "label": "Plugins",
     "url": "https://ampcode.com/docs/customize/plugins"
    },
    {
     "label": "Manual (ChatGPT sign-in)",
     "url": "https://ampcode.com/manual"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native (cwd, parents and subtrees)."
  },
  {
   "slug": "kiro",
   "name": "Kiro",
   "tool": "kiro",
   "vendor": "AWS",
   "surfaces": [
    "ide",
    "cli",
    "cloud"
   ],
   "title": "Kiro Config Guide: Steering Files, AGENTS.md, mcp.json, permissions.yaml",
   "desc": "Kiro steering in .kiro/steering and ~/.kiro/steering, AGENTS.md support, .kiro/settings/mcp.json, hooks, skills and capability-based permissions.yaml rules.",
   "answer": "Kiro calls instructions \"steering\": markdown files in `.kiro/steering/` (workspace) and `~/.kiro/steering/` (global) with inclusion modes. It also reads `AGENTS.md` at the workspace root and in the global steering folder, and always includes it. MCP servers are in `.kiro/settings/mcp.json` or `~/.kiro/settings/mcp.json`, hooks in `.kiro/hooks/`, skills in `.kiro/skills/`. Permissions are capability rules (deny > ask > allow) in `~/.kiro/settings/permissions.yaml`, and a cloned repo cannot inject them.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`~/.kiro/steering/*.md` (AGENTS.md allowed there)"
    },
    "instr_project": {
     "level": "yes",
     "text": "`.kiro/steering/*.md` with inclusion modes; `AGENTS.md` at root"
    },
    "instr_nested": {
     "level": "unknown",
     "text": "Not documented"
    },
    "agents_md": {
     "level": "yes",
     "text": "Always included (no inclusion modes)"
    },
    "skills": {
     "level": "yes",
     "text": "`.kiro/skills/` (workspace), `~/.kiro/skills/` (global)"
    },
    "mcp": {
     "level": "yes",
     "text": "`.kiro/settings/mcp.json` (workspace), `~/.kiro/settings/mcp.json` (user)"
    },
    "permissions": {
     "level": "yes",
     "text": "Capability rules (`shell`, `fs_read`, `fs_write`, `web_fetch`, `mcp`) with deny > ask > allow in `~/.kiro/settings/permissions.yaml`"
    },
    "sandbox": {
     "level": "partial",
     "text": "Kiro on the web runs in an isolated cloud sandbox; local sandbox not detailed"
    },
    "hooks": {
     "level": "yes",
     "text": "`.kiro/hooks/` (file events, tool events)"
    },
    "sub_claude": {
     "level": "no",
     "text": "Not supported"
    },
    "sub_chatgpt": {
     "level": "no",
     "text": "Not supported"
    },
    "api_key": {
     "level": "no",
     "text": "Kiro plans; sign in with GitHub, Google, AWS Builder ID or IAM Identity Center"
    }
   },
   "files": [
    {
     "path": ".kiro/steering/*.md",
     "scope": "Workspace",
     "note": "Steering with inclusion modes"
    },
    {
     "path": "~/.kiro/steering/",
     "scope": "User",
     "note": "Global steering, AGENTS.md allowed"
    },
    {
     "path": "AGENTS.md",
     "scope": "Workspace",
     "note": "Always-included steering"
    },
    {
     "path": ".kiro/settings/mcp.json",
     "scope": "Workspace",
     "note": "MCP servers (user: ~/.kiro/settings/mcp.json)"
    },
    {
     "path": "~/.kiro/settings/permissions.yaml",
     "scope": "User",
     "note": "Permission rules"
    },
    {
     "path": ".kiro/hooks/",
     "scope": "Workspace",
     "note": "Hooks"
    },
    {
     "path": ".kiro/skills/<name>/SKILL.md",
     "scope": "Workspace",
     "note": "Skills"
    }
   ],
   "examples": [
    {
     "title": "Workspace MCP server",
     "file": ".kiro/settings/mcp.json",
     "lang": "json",
     "code": "{\n  \"mcpServers\": {\n    \"fetch\": {\n      \"command\": \"uvx\",\n      \"args\": [\"mcp-server-fetch\"]\n    }\n  }\n}\n"
    }
   ],
   "preset": {
    "title": "Safe Kiro permissions",
    "file": "~/.kiro/settings/permissions.yaml",
    "lang": "yaml",
    "code": "rules:\n  - capability: fs_read\n    effect: allow\n  - capability: shell\n    match: [\"git status*\", \"git diff*\", \"npm test*\"]\n    effect: allow\n  - capability: shell\n    match: [\"git push*\"]\n    effect: ask\n  - capability: shell\n    match: [\"rm -rf *\", \"sudo *\", \"git push --force*\", \"git reset --hard*\", \"terraform destroy*\"]\n    effect: deny\n  - capability: fs_write\n    match: [\"**/.env\", \"**/*.pem\", \"**/*.key\"]\n    effect: deny\n",
    "note": "Deny always wins, regardless of scope. Rules live outside the repo, so a cloned project can't grant itself permissions."
   },
   "gotchas": [
    "AGENTS.md has no inclusion modes; it is always loaded, so keep it short and move scoped guidance into steering files.",
    "On Kiro web, your local `~/.kiro/steering` is not available automatically."
   ],
   "faqs": [
    {
     "q": "Does Kiro support AGENTS.md?",
     "a": "Yes. Kiro reads AGENTS.md at the workspace root and in ~/.kiro/steering/, and always includes it as steering."
    },
    {
     "q": "Where is the Kiro MCP config?",
     "a": ".kiro/settings/mcp.json in the workspace and ~/.kiro/settings/mcp.json for all workspaces."
    }
   ],
   "sources": [
    {
     "label": "Steering",
     "url": "https://kiro.dev/docs/steering/"
    },
    {
     "label": "MCP configuration",
     "url": "https://kiro.dev/docs/mcp/configuration/"
    },
    {
     "label": "Hooks",
     "url": "https://kiro.dev/docs/hooks/"
    },
    {
     "label": "Skills",
     "url": "https://kiro.dev/docs/skills/"
    },
    {
     "label": "Permissions",
     "url": "https://kiro.dev/docs/permissions/"
    },
    {
     "label": "Authentication",
     "url": "https://kiro.dev/docs/getting-started/authentication/"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native: always included as steering."
  },
  {
   "slug": "jules",
   "name": "Jules",
   "tool": "jules",
   "vendor": "Google",
   "surfaces": [
    "cloud"
   ],
   "title": "Jules Config: AGENTS.md, Setup Scripts, MCP & Plans",
   "desc": "Google Jules reads AGENTS.md in the repo root, runs each task in a short-lived VM with optional setup scripts, supports vetted MCP servers and uses Google AI Pro/Ultra plans.",
   "answer": "Jules automatically looks for `AGENTS.md` in the root of your repository and uses it (or the README) for hints when setting up its environment. Each task runs in a fresh, short-lived VM where you can add an environment setup script, and you approve Jules' plan before it changes code. MCP support covers a vetted list of services that you connect with API keys in Settings. Higher limits come with Google AI Pro and Ultra.",
   "cols": {
    "instr_global": {
     "level": "unknown",
     "text": "Not documented"
    },
    "instr_project": {
     "level": "yes",
     "text": "`AGENTS.md` in the repository root"
    },
    "instr_nested": {
     "level": "unknown",
     "text": "Not documented"
    },
    "agents_md": {
     "level": "yes",
     "text": "Root AGENTS.md, read automatically"
    },
    "skills": {
     "level": "unknown",
     "text": "Not documented"
    },
    "mcp": {
     "level": "partial",
     "text": "Vetted servers only (e.g. Linear, Neon, Supabase, Context7), configured in Settings with API keys"
    },
    "permissions": {
     "level": "partial",
     "text": "Plan review and approval before coding"
    },
    "sandbox": {
     "level": "yes",
     "text": "Every task runs in a fresh short-lived VM"
    },
    "hooks": {
     "level": "unknown",
     "text": "Not documented"
    },
    "sub_claude": {
     "level": "no",
     "text": "Not supported"
    },
    "sub_chatgpt": {
     "level": "no",
     "text": "Not supported"
    },
    "api_key": {
     "level": "no",
     "text": "Google account; higher limits via Google AI Pro / Ultra"
    }
   },
   "files": [
    {
     "path": "AGENTS.md",
     "scope": "Repository root",
     "note": "Instructions and environment hints"
    },
    {
     "path": "Environment setup script",
     "scope": "Jules repo settings",
     "note": "Install/test commands run in the VM"
    }
   ],
   "examples": [
    {
     "title": "AGENTS.md section Jules can use for setup",
     "file": "AGENTS.md",
     "lang": "markdown",
     "code": "## Setup\n\n```bash\nnpm ci\nnpm run build\n```\n\n## Test\n\n`npm test` must pass before you open a PR.\n"
    }
   ],
   "preset": {
    "title": "Safe Jules workflow",
    "file": "Jules settings",
    "lang": "text",
    "code": "1. Review every plan before approving it.\n2. Keep production secrets out of the repo and the setup script.\n3. Use a setup script with discrete install/test commands (no dev servers or watchers).\n4. Connect only the MCP services Jules needs, with scoped API keys.\n5. Require PR review / branch protection on main: Jules works through pull requests.\n",
    "note": "Jules' docs don't describe command allow/deny lists; isolation comes from the per-task VM and plan approval."
   },
   "gotchas": [
    "Long-running processes such as dev servers don't belong in setup scripts.",
    "Treat the VM like any internet-connected machine: don't put production credentials in it."
   ],
   "faqs": [
    {
     "q": "Does Jules use AGENTS.md?",
     "a": "Yes. Jules automatically looks for AGENTS.md in the root of your repository and also consults it for environment setup hints."
    },
    {
     "q": "Does Jules support MCP?",
     "a": "Yes, for a vetted list of services added in February 2026, connected with API keys in the Jules settings."
    }
   ],
   "sources": [
    {
     "label": "Getting started",
     "url": "https://jules.google/docs/"
    },
    {
     "label": "Environment",
     "url": "https://jules.google/docs/environment/"
    },
    {
     "label": "Usage limits & plans",
     "url": "https://jules.google/docs/usage-limits/"
    },
    {
     "label": "Changelog (MCP support)",
     "url": "https://jules.google/docs/changelog/"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native: repository-root AGENTS.md only."
  },
  {
   "slug": "factory-droid",
   "name": "Factory Droid",
   "tool": "factory",
   "vendor": "Factory",
   "surfaces": [
    "cli",
    "ide",
    "cloud"
   ],
   "title": "Factory Droid Config: AGENTS.md, .factory/settings.json, MCP, Hooks",
   "desc": "Factory Droid reads AGENTS.md (also in .factory/, .agents/), ~/.factory/mcp.json, hooks.json, skills dirs, permissionRules allow/ask/block and an OS sandbox.",
   "answer": "Droid loads `AGENTS.md` from each directory between your working directory and the git root, including the `.factory/`, `.agents/` and `.agent/` folders, plus personal files in `~/.factory/`. MCP servers are in `~/.factory/mcp.json` or `.factory/mcp.json`, hooks in `.factory/hooks.json`, skills in `.factory/skills/` (or `.agents/skills/`). Command policy is `permissionRules` in `.factory/settings.json`, with `allow`, `ask` and `block` decisions and required tests, plus an OS-level sandbox and an autonomy level.",
   "cols": {
    "instr_global": {
     "level": "yes",
     "text": "`~/.factory/`, `~/.agents/`, `~/.agent/` (AGENTS.md)"
    },
    "instr_project": {
     "level": "yes",
     "text": "`AGENTS.md` in each dir from cwd up to git root, and in `.factory/`, `.agents/`, `.agent/`"
    },
    "instr_nested": {
     "level": "yes",
     "text": "Nested AGENTS.md refines root files"
    },
    "agents_md": {
     "level": "yes",
     "text": "Primary format"
    },
    "skills": {
     "level": "yes",
     "text": "`.factory/skills/`, `.agents/skills/`; `~/.factory/skills/`, `~/.agents/skills/`"
    },
    "mcp": {
     "level": "yes",
     "text": "`~/.factory/mcp.json` (user), `.factory/mcp.json` (project)"
    },
    "permissions": {
     "level": "yes",
     "text": "`permissionRules` (allow / ask / block, token-prefix match, required tests) in `~/.factory/settings.json` or `.factory/settings.json`; autonomy levels"
    },
    "sandbox": {
     "level": "yes",
     "text": "OS sandbox: Seatbelt (macOS), bubblewrap (Linux/WSL2); per-command or whole-process"
    },
    "hooks": {
     "level": "yes",
     "text": "`~/.factory/hooks.json`, `.factory/hooks.json`"
    },
    "sub_claude": {
     "level": "unknown",
     "text": "Not documented"
    },
    "sub_chatgpt": {
     "level": "unknown",
     "text": "Not documented"
    },
    "api_key": {
     "level": "yes",
     "text": "Factory plans or BYOK custom models"
    }
   },
   "files": [
    {
     "path": "AGENTS.md (+ .factory/, .agents/)",
     "scope": "Project",
     "note": "Instructions"
    },
    {
     "path": "~/.factory/",
     "scope": "User",
     "note": "Personal instructions, settings, skills"
    },
    {
     "path": ".factory/settings.json",
     "scope": "Project",
     "note": "permissionRules and settings"
    },
    {
     "path": ".factory/mcp.json",
     "scope": "Project",
     "note": "MCP servers (user: ~/.factory/mcp.json)"
    },
    {
     "path": ".factory/hooks.json",
     "scope": "Project",
     "note": "Hooks"
    },
    {
     "path": ".factory/skills/<name>/SKILL.md",
     "scope": "Project",
     "note": "Skills"
    }
   ],
   "examples": [
    {
     "title": "Require approval before git push",
     "file": ".factory/settings.json",
     "lang": "json",
     "code": "{\n  \"permissionRules\": {\n    \"version\": 1,\n    \"rules\": [\n      {\n        \"id\": \"project/git-push\",\n        \"decision\": \"ask\",\n        \"reason\": \"Review remote Git changes before pushing.\",\n        \"match\": { \"prefix\": [\"git\", \"push\"] },\n        \"tests\": { \"match\": [\"git push origin main\"], \"noMatch\": [\"git status\"] }\n      }\n    ]\n  }\n}\n"
    }
   ],
   "preset": {
    "title": "Safe Droid permission rules",
    "file": ".factory/settings.json",
    "lang": "json",
    "code": "{\n  \"permissionRules\": {\n    \"version\": 1,\n    \"rules\": [\n      {\n        \"id\": \"project/no-rm-rf\",\n        \"decision\": \"block\",\n        \"reason\": \"No recursive deletes.\",\n        \"match\": { \"prefix\": [\"rm\", [\"-rf\", \"-fr\"]] },\n        \"tests\": { \"match\": [\"rm -rf build\"], \"noMatch\": [\"rm file.txt\"] }\n      },\n      {\n        \"id\": \"project/no-force-push\",\n        \"decision\": \"block\",\n        \"reason\": \"Never force-push.\",\n        \"match\": { \"prefix\": [\"git\", \"push\", [\"--force\", \"-f\"]] },\n        \"tests\": { \"match\": [\"git push --force\"], \"noMatch\": [\"git push origin main\"] }\n      },\n      {\n        \"id\": \"project/review-push\",\n        \"decision\": \"ask\",\n        \"reason\": \"Review before pushing.\",\n        \"match\": { \"prefix\": [\"git\", \"push\"] },\n        \"tests\": { \"match\": [\"git push origin main\"], \"noMatch\": [\"git status\"] }\n      }\n    ]\n  }\n}\n",
    "note": "Each rule needs tests that must match and must not match; Droid validates them. Prefix matching is token-exact, so `git -C /repo push` is a different spelling. Pair with the sandbox. The old commandAllowlist / commandDenylist keys are deprecated."
   },
   "gotchas": [
    "`commandAllowlist` and `commandDenylist` are deprecated in favour of `permissionRules`.",
    "Keep long runbooks out of AGENTS.md; use skills for procedures."
   ],
   "faqs": [
    {
     "q": "Where is the Factory Droid MCP config?",
     "a": "~/.factory/mcp.json for personal servers and .factory/mcp.json in the project for shared servers."
    },
    {
     "q": "Does Droid read AGENTS.md?",
     "a": "Yes. It searches from the working directory up to the git root, checking each directory and its .factory/, .agents/ and .agent/ folders, plus ~/.factory/ for personal files."
    }
   ],
   "sources": [
    {
     "label": "AGENTS.md",
     "url": "https://docs.factory.com/harness/agents-md"
    },
    {
     "label": "MCP",
     "url": "https://docs.factory.com/harness/mcp"
    },
    {
     "label": "Skills",
     "url": "https://docs.factory.com/harness/skills"
    },
    {
     "label": "Hooks",
     "url": "https://docs.factory.com/harness/hooks"
    },
    {
     "label": "Permission rules",
     "url": "https://docs.factory.com/autonomy-and-safety/permission-rules"
    },
    {
     "label": "Sandbox",
     "url": "https://docs.factory.com/autonomy-and-safety/sandbox"
    },
    {
     "label": "BYOK",
     "url": "https://docs.factory.com/model-independence/byok"
    }
   ],
   "status": "active",
   "status_note": "",
   "verified": "2026-10-12",
   "bridge": "Native (also in `.factory/` and `.agents/`)."
  },
  {
   "slug": "continue",
   "name": "Continue",
   "tool": "continue",
   "vendor": "Continue",
   "status": "sunset",
   "status_note": "Per multiple reports, the hosted Continue Hub shut down on July 15, 2026 (not confirmed in Continue docs); the open-source extension still installs.",
   "surfaces": [
    "ide",
    "cli"
   ],
   "title": "Continue Config (Legacy): .continue/rules & mcpServers",
   "desc": "Continue's Hub closed in July 2026. Where the open-source extension still reads rules (.continue/rules) and MCP servers (.continue/mcpServers), and what isn't documented.",
   "answer": "Continue's hosted Hub closed on July 15, 2026, but the open-source extension still works locally. It reads rules from `.continue/rules/*.md` (frontmatter `name`, `globs`, `regex`, `description`, `alwaysApply`) and MCP servers from `mcpServers` in config or files in `.continue/mcpServers/`, including JSON copied from Claude Desktop, Cursor or Cline. AGENTS.md support is not documented on the rules page.",
   "cols": {
    "instr_global": {
     "level": "unknown",
     "text": "Not documented on the rules page"
    },
    "instr_project": {
     "level": "yes",
     "text": "`.continue/rules/*.md` (Markdown or YAML)"
    },
    "instr_nested": {
     "level": "unknown",
     "text": "Not documented"
    },
    "agents_md": {
     "level": "unknown",
     "text": "Not documented"
    },
    "skills": {
     "level": "unknown",
     "text": "Not documented"
    },
    "mcp": {
     "level": "yes",
     "text": "`mcpServers` in config, or files in `.continue/mcpServers/` (accepts Claude/Cursor/Cline JSON)"
    },
    "permissions": {
     "level": "unknown",
     "text": "Not documented on the pages checked"
    },
    "sandbox": {
     "level": "unknown",
     "text": "Not documented"
    },
    "hooks": {
     "level": "unknown",
     "text": "Not documented"
    },
    "sub_claude": {
     "level": "unknown",
     "text": "Not documented"
    },
    "sub_chatgpt": {
     "level": "unknown",
     "text": "Not documented"
    },
    "api_key": {
     "level": "yes",
     "text": "Your own keys or local models"
    }
   },
   "files": [
    {
     "path": ".continue/rules/*.md",
     "scope": "Workspace",
     "note": "Rules"
    },
    {
     "path": ".continue/mcpServers/",
     "scope": "Workspace",
     "note": "MCP server files (YAML or JSON)"
    }
   ],
   "examples": [
    {
     "title": "Rule file",
     "file": ".continue/rules/docs.md",
     "lang": "markdown",
     "code": "---\nname: Documentation Standards\nglobs: docs/**/*.{md,mdx}\nalwaysApply: false\n---\n\n- Every page starts with a one-sentence summary.\n"
    }
   ],
   "preset": {
    "title": "Migration note",
    "file": "terminal",
    "lang": "bash",
    "code": "# Move rules to AGENTS.md so any agent can read them:\ncat .continue/rules/*.md >> AGENTS.md      # then remove the frontmatter blocks\n# MCP JSON in .continue/mcpServers/ already uses the common mcpServers shape.\n",
    "note": "Cursor, Cline, Kilo Code and OpenCode read AGENTS.md; most accept the same mcpServers JSON shape (OpenCode and Kilo use their own `mcp` key)."
   },
   "gotchas": [
    "Hub-hosted assistants and rules stopped working when the Hub closed; keep local copies in `.continue/`."
   ],
   "faqs": [
    {
     "q": "Is Continue still maintained?",
     "a": "The hosted Continue Hub shut down on July 15, 2026. The open-source extension still installs and works with your own keys or local models, but treat it as legacy."
    }
   ],
   "sources": [
    {
     "label": "Rules",
     "url": "https://docs.continue.dev/customize/deep-dives/rules"
    },
    {
     "label": "MCP",
     "url": "https://docs.continue.dev/customize/deep-dives/mcp"
    }
   ],
   "verified": "2026-10-12",
   "bridge": "Not documented: copy the content into `.continue/rules/`."
  }
 ]
}