# AgentAtlas

> The verified map of the AI agent stack: official MCP servers checked against the MCP registry, Agent Skills published by vendors, which harnesses support MCP / Agent Skills / AGENTS.md / ACP, and short explainers of each open standard. Every entry links to its primary source.

## Directory
- [Official MCP servers](https://agentatlas.dev/mcp): 125 servers published under the vendor's own namespace in the official MCP registry, with install commands.
- [Agent Skills](https://agentatlas.dev/skills): 120 skills from the official repositories of Anthropic, OpenAI, Vercel, Hugging Face, Cloudflare, Supabase, Stripe and Google.
- [Harness compatibility](https://agentatlas.dev/harnesses): 24 coding and personal agents compared on MCP, Agent Skills, AGENTS.md and ACP support.
- [A2A agents](https://agentatlas.dev/a2a): agents that speak the Agent2Agent protocol.
- [AGENTS.md](https://agentatlas.dev/agents-md): template and the agents that read it.
- [Agent radar](https://agentatlas.dev/radar): daily feed of agent releases, official announcements, rising GitHub repos and Hacker News discussions, tagged by tool and protocol.
- [Latest releases](https://agentatlas.dev/latest): new versions of coding agents, agent frameworks and official MCP servers, refreshed daily.
- [Subagents, custom agents, parallel agents and hooks](https://agentatlas.dev/subagents): which coding agents support each, with vendor sources.
- [Cloud coding agents](https://agentatlas.dev/cloud-agents): 18 background agents that turn tasks into pull requests (Codex, Copilot, Cursor, Claude Code, Jules, Devin and more).
- [Agent orchestration frameworks](https://agentatlas.dev/orchestration): 23 agent SDKs and multi-agent frameworks with patterns, MCP/A2A support and latest versions.
- [AgentAtlas MCP server](https://agentatlas.dev/mcp-server): remote MCP endpoint at https://agentatlas.dev/api/mcp with search_atlas, get_guide, get_mcp_server, get_pricing, get_setup_config (MCP config for 15 clients, with the file path) and get_trending tools. Agents can set up MCP servers for their user with it.
- [AgentAtlas Weekly newsletter](https://agentatlas.dev/newsletter): free Monday email with agent releases, new MCP servers, rising repos and top discussions.
- [Trending in AI agents](https://agentatlas.dev/trending): fastest-rising new agent and MCP repos on GitHub, stars gained by tracked agent projects, most-discussed agent posts on Hacker News, and verified accounts to follow.
- Trending by topic, refreshed twice a day: [Claude Code repos](https://agentatlas.dev/trending/claude-code), [Codex repos](https://agentatlas.dev/trending/codex), [agent skills (SKILL.md)](https://agentatlas.dev/trending/agent-skills), [MCP servers](https://agentatlas.dev/trending/mcp-servers).
- [MCP setup kit](https://agentatlas.dev/tools/setup-kit): pick official MCP servers and a coding agent, get one-click install links and ready-to-paste config. Shareable as https://agentatlas.dev/tools/setup-kit?servers=github,stripe&client=cursor.
- [Agent permissions generator](https://agentatlas.dev/tools/permissions-generator): exact allow/deny command rules for Claude Code, Codex, Cursor, Gemini CLI, Copilot CLI, OpenCode, Kiro, Factory Droid, Qwen Code, Junie and Zed.
- [Rules file converter](https://agentatlas.dev/tools/rules-converter): convert project rules between AGENTS.md, Cursor .mdc, Claude Code, GitHub Copilot, Kiro steering, Antigravity, Devin/Windsurf, Cline, Continue, Gemini CLI and Amp, keeping glob and on-demand scope.
- [Slash command converter](https://agentatlas.dev/tools/command-converter): convert custom slash commands between Claude Code skills, Cursor skills, Gemini CLI TOML, Qwen Code, VS Code Copilot prompt files, OpenCode and Junie, mapping arguments, shell output and file injection.
- [Agent setup in one paste](https://agentatlas.dev/tools/agent-setup): one script that writes MCP config, project rules and command permissions for Claude Code, Cursor, VS Code, Codex, Gemini CLI, Antigravity, Kiro, Copilot CLI, OpenCode, Cline, Devin Desktop, Amp and Zed.
- [MCP config converter](https://agentatlas.dev/tools/mcp-config-converter): convert an MCP config between Claude Code, Cursor, VS Code, Codex, Gemini CLI, Antigravity CLI, Copilot CLI, OpenCode, Cline, Kiro, Zed and more.
- [Coding agent pricing](https://agentatlas.dev/pricing): every plan for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI and more, copied from vendor pricing pages.
- [Agent evals](https://agentatlas.dev/evals): 16 eval frameworks (agent trajectories, LLM judges, tracing, CI) and 24 agent benchmarks with scoring and official leaderboards.
- [Coding agent plugins](https://agentatlas.dev/plugins): 19 plugin, extension and mod systems compared on what they bundle, manifest, install command and marketplace.

## Setup guides
- [How to allow Cursor to run all commands: Run Everything, allowlist and sandbox](https://agentatlas.dev/guides/cursor-allow-all-commands): Open Settings > Agents > Approvals & Execution and pick a Run Mode.
- [How to allow Claude Code to run all commands: permission modes, allow rules and skip permissions](https://agentatlas.dev/guides/claude-code-allow-all-commands): Press Shift+Tab to cycle permission modes, start with claude --permission-mode <mode>, or pre-approve specific commands with permissions.allow rules such as Bash(npm run *) in .claude/settings.json.
- [Claude Code permissions: allow, ask and deny rules, rule syntax and allowed tools](https://agentatlas.dev/guides/claude-code-permissions): Claude Code checks every tool call against permission rules in your settings files.
- [Codex CLI: approval and sandbox modes (and what --yolo does)](https://agentatlas.dev/guides/codex-approval-modes): Codex combines an approval policy (--ask-for-approval: on-request or never) with a sandbox (--sandbox: read-only, workspace-write or danger-full-access).
- [Gemini CLI: YOLO mode, auto_edit and allowing specific shell commands](https://agentatlas.dev/guides/gemini-cli-yolo-mode): Start Gemini CLI with --approval-mode auto_edit to auto-approve edits, or --yolo (--approval-mode yolo) to auto-approve everything.
- [Cursor Privacy Mode: telemetry, training and data retention](https://agentatlas.dev/guides/cursor-privacy-mode-data-retention): With Privacy Mode on, Cursor says customer data is not used for training and it has zero data retention agreements with its model providers, though providers may run abuse classifiers.
- [Claude Code telemetry and data retention: what is sent and how to turn it off](https://agentatlas.dev/guides/claude-code-telemetry-data-retention): Set DISABLE_TELEMETRY=1 to stop usage metrics, DISABLE_ERROR_REPORTING=1 to stop error reports, or CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 to stop all non-essential traffic.
- [Gemini CLI: turn off usage statistics and telemetry](https://agentatlas.dev/guides/gemini-cli-telemetry): Set privacy.usageStatisticsEnabled to false in ~/.gemini/settings.json to stop usage statistics, and keep telemetry.enabled false (it can also be set with GEMINI_TELEMETRY_ENABLED).
- [CLAUDE.md: where it goes, how it loads, and how it works with AGENTS.md](https://agentatlas.dev/guides/claude-code-claude-md): Put team instructions in ./CLAUDE.md (or ./.claude/CLAUDE.md), personal ones in ~/.claude/CLAUDE.md, and private project notes in ./CLAUDE.local.md.
- [Claude Code hooks: all events, exit codes, PreToolUse and PermissionRequest JSON, examples](https://agentatlas.dev/guides/claude-code-hooks): Add a hooks block to .claude/settings.json (project) or ~/.claude/settings.json (user).
- [Claude Code subagents: create one, limit its tools, and call it](https://agentatlas.dev/guides/claude-code-subagents): Create a Markdown file in .claude/agents/ (project) or ~/.claude/agents/ (all projects) with YAML frontmatter: name and description are required; tools, model and permissionMode are optional.
- [Add MCP servers to Cursor with mcp.json](https://agentatlas.dev/guides/cursor-mcp-json): Install a server in one click from Customize in the sidebar, or define it under "mcpServers" in .cursor/mcp.json (one project) or ~/.cursor/mcp.json (all projects).
- [Keep files out of Cursor with .cursorignore](https://agentatlas.dev/guides/cursor-ignore): Create a .cursorignore file in your project root using .gitignore syntax, and Cursor will block matching files from Agent, Tab, Inline Edit, and @ mentions.
- [Configure Codex with config.toml](https://agentatlas.dev/guides/codex-config-toml): Codex reads your personal settings from ~/.codex/config.toml.
- [Configure Gemini CLI with settings.json](https://agentatlas.dev/guides/gemini-cli-settings-json): Gemini CLI reads your personal settings from ~/.gemini/settings.json and project settings from .gemini/settings.json in the project root, and there are also system-level files.
- [Add MCP servers to Claude Code (claude mcp add, .mcp.json, scopes)](https://agentatlas.dev/guides/claude-code-mcp): Run claude mcp add --transport http NAME URL for a remote server, or claude mcp add [options] NAME -- COMMAND [args] for a local stdio server.
- [Claude Code custom slash commands and skills (SKILL.md)](https://agentatlas.dev/guides/claude-code-skills-slash-commands): Create a SKILL.md file in .claude/skills/SKILL-NAME/ for one project, or in ~/.claude/skills/SKILL-NAME/ for all your projects.
- [GitHub Copilot custom instructions](https://agentatlas.dev/guides/github-copilot-custom-instructions): Put repository-wide guidance in .github/copilot-instructions.md and file-specific guidance in .github/instructions/NAME.instructions.md files with an applyTo glob in the frontmatter.
- [Adding MCP servers to GitHub Copilot](https://agentatlas.dev/guides/github-copilot-mcp): In VS Code, define servers under a top-level servers key in .vscode/mcp.json for a workspace, or in your user profile mcp.json via the MCP: Open User Configuration command.
- [Claude Code settings.json: file locations, precedence, and key settings](https://agentatlas.dev/guides/claude-code-settings-json): Claude Code reads settings from ~/.claude/settings.json (user), .claude/settings.json (shared project), .claude/settings.local.json (project local), and managed settings deployed by your organization.
- [Claude Code plugins and marketplaces: install, create, and share](https://agentatlas.dev/guides/claude-code-plugins): A Claude Code plugin is a directory of skills, agents, hooks, MCP servers, or other components, usually with a manifest at .claude-plugin/plugin.json, that Claude Code installs and loads as one unit.
- [Gemini CLI extensions and custom commands](https://agentatlas.dev/guides/gemini-cli-extensions): Gemini CLI extensions package MCP servers, context files, custom commands, hooks, themes, sub-agents, and agent skills behind a gemini-extension.json manifest, and you manage them with the gemini extensions command group from your terminal.
- [Configuring OpenCode with opencode.json](https://agentatlas.dev/guides/opencode-config): OpenCode reads JSON or JSONC config from ~/.config/opencode/opencode.json globally and opencode.json in your project, and it merges every source instead of replacing them, with later sources winning only on conflicting keys.
- [Cline Rules: workspace, global, and conditional rules](https://agentatlas.dev/guides/cline-rules): Put project rules as markdown files in a .clinerules/ or .cline/rules/ folder at your project root, and personal rules in your global Cline Rules directory such as ~/Documents/Cline/Rules.
- [Kiro steering files: .kiro/steering, inclusion modes, and AGENTS.md](https://agentatlas.dev/guides/kiro-steering-files): Put markdown files in .kiro/steering/ in your workspace, or in ~/.kiro/steering/ for global rules, and Kiro loads them as persistent project knowledge.
- [Zed agent: instruction files, MCP servers, tool permissions, and ACP agents](https://agentatlas.dev/guides/zed-agent-rules-mcp): The Zed Agent loads personal instructions from ~/.config/zed/AGENTS.md plus the first project file it finds from a fixed list that starts with .rules and includes AGENTS.md and CLAUDE.md.
- [Cursor CLI: install, headless mode, permissions and CI](https://agentatlas.dev/guides/cursor-cli): Install the Cursor CLI with the official install script, then run the agent command for an interactive session or agent -p for non-interactive print mode.
- [Aider: CONVENTIONS.md, .aider.conf.yml and API keys](https://agentatlas.dev/guides/aider-conventions): Write your coding guidelines in a small markdown file such as CONVENTIONS.md and load it read-only with aider --read CONVENTIONS.md, or add read: CONVENTIONS.md to .aider.conf.yml so it always loads.
- [Junie guidelines, MCP and the Action Allowlist](https://agentatlas.dev/guides/junie-guidelines): Junie CLI reads project guidelines from .junie/AGENTS.md first, then a root AGENTS.md, and still supports the legacy .junie/guidelines.md file.
- [Amp AGENTS.md, settings.json and MCP](https://agentatlas.dev/guides/amp-settings): Amp always loads AGENTS.md from the working directory and its parents, plus your personal and system-wide files, and pulls in subtree AGENTS.md files when it reads files there.
- [Configure Goose extensions, hints, recipes and permissions](https://agentatlas.dev/guides/goose-extensions-config): Goose reads its settings from config.yaml, which lives at ~/.config/goose/config.yaml on macOS and Linux and under %APPDATA%\Block\goose\config on Windows.
- [Customize OpenHands with skills, AGENTS.md, setup.sh and MCP](https://agentatlas.dev/guides/openhands-skills-microagents): OpenHands now calls microagents skills, and new skills go in .agents/skills/SKILL_NAME/SKILL.md, while the legacy .openhands/skills and .openhands/microagents folders still work.
- [Configure Factory Droid CLI: AGENTS.md, settings.json, autonomy, custom droids and MCP](https://agentatlas.dev/guides/factory-droid-config): Install Droid with the official install script, Homebrew or npm, then run droid inside your project.
- [Configure Qwen Code: settings.json, providers, QWEN.md, MCP and approval modes](https://agentatlas.dev/guides/qwen-code-settings): Qwen Code reads JSON settings from ~/.qwen/settings.json for your user and .qwen/settings.json for a project, with system level files above them.
- [Cursor hooks: hooks.json, beforeShellExecution, afterFileEdit and exit codes](https://agentatlas.dev/guides/cursor-hooks): Create a hooks.json file at <project>/.cursor/hooks.json or ~/.cursor/hooks.json with "version": 1 and a "hooks" object that maps event names like afterFileEdit or beforeShellExecution to commands.
- [Cursor sandbox: sandbox.json, network allowlist and run modes](https://agentatlas.dev/guides/cursor-sandbox): On macOS and Linux, Cursor can run agent terminal commands in a sandbox that limits writes to the workspace and blocks network access you have not allowed.
- [Cursor settings: settings.json, Cursor Settings and the ~/.cursor config files](https://agentatlas.dev/guides/cursor-settings-json): Cursor has two settings surfaces: the Cursor Settings panel (Ctrl/Cmd + Shift + J) for AI and agent features, and the VS Code style editor settings opened with Preferences: Open Settings (UI).
- [Cursor browser agent: @browser, browser automation and approval modes](https://agentatlas.dev/guides/cursor-browser-agent): Mention @browser in your Agent prompt and Agent controls a built-in browser in Cursor.
- [Cursor subagents: .cursor/agents, frontmatter, built-in Explore and Browser](https://agentatlas.dev/guides/cursor-subagents): Create a markdown file with YAML frontmatter in .cursor/agents/ for a project or ~/.cursor/agents/ for all your projects, then call it with /name in a prompt or let Agent delegate to it automatically.
- [Cursor telemetry and OpenTelemetry export (Privacy Mode, OTLP, Analytics API)](https://agentatlas.dev/guides/cursor-telemetry-opentelemetry): Turn on Privacy Mode in Cursor Settings > General so your code is not used for training by Cursor or model providers.
- [Cursor rules setup: project, user and Team Rules, .mdc frontmatter, globs and AGENTS.md](https://agentatlas.dev/guides/cursor-rules-setup): Create .mdc files in your repo's .cursor/rules folder, each with frontmatter that sets description, globs and alwaysApply.
- [Claude Code headless mode: claude -p, --output-format json, --bare and CI flags](https://agentatlas.dev/guides/claude-code-headless-mode-claude-p): Add -p (or --print) to any claude command to run it once without the interactive interface, for example claude -p "What does the auth module do?".
- [Claude Code statusline: custom status bar in settings.json with context %, cost and git branch](https://agentatlas.dev/guides/claude-code-statusline): Run /statusline with a plain English description and Claude Code writes the script and updates your settings for you.
- [Claude Code /model: switch models, aliases (opus, sonnet, haiku, opusplan), ANTHROPIC_MODEL and effort](https://agentatlas.dev/guides/claude-code-model-selection): Run /model inside a session to open the picker, or /model sonnet to switch directly.
- [Claude Code /cost and /usage: check token spend, usage limits and reduce costs](https://agentatlas.dev/guides/claude-code-cost-usage-limits): Run /usage (or its aliases /cost and /stats) to see session cost, plan usage limits and activity stats.
- [Claude Code VS Code extension: install, shortcuts, settings and /ide (works in Cursor too)](https://agentatlas.dev/guides/claude-code-vs-code-extension): Open the Extensions view (Cmd+Shift+X or Ctrl+Shift+X), search for Claude Code, and click Install.
- [Codex AGENTS.md: global, project and override instruction files explained](https://agentatlas.dev/guides/codex-agents-md): Put a global AGENTS.md in your Codex home (~/.codex by default) and an AGENTS.md at your repository root, plus nested files in subfolders that need different rules.
- [Codex MCP servers: codex mcp add and [mcp_servers] in config.toml](https://agentatlas.dev/guides/codex-mcp-servers): Run codex mcp add with a name and the server command, for example codex mcp add context7 -- npx -y @upstash/context7-mcp, or add a [mcp_servers.<name>] table to ~/.codex/config.toml.
- [Codex sandbox modes: read-only, workspace-write, danger-full-access and network access](https://agentatlas.dev/guides/codex-sandbox-modes): Codex has three sandbox modes: read-only, workspace-write and danger-full-access.
- [codex exec: run Codex non-interactively in scripts and CI with JSON output](https://agentatlas.dev/guides/codex-exec-non-interactive): Run codex exec "your task" to run Codex once without the interactive TUI.
- [Codex skills: create SKILL.md, skill folder locations and $skill invocation](https://agentatlas.dev/guides/codex-skills): A Codex skill is a folder with a SKILL.md file whose YAML frontmatter has a name and a description.
- [GEMINI.md in Gemini CLI: context file locations, imports and /memory](https://agentatlas.dev/guides/gemini-cli-gemini-md): Put shared instructions in ~/.gemini/GEMINI.md and project instructions in a GEMINI.md at your project root.
- [Gemini CLI MCP servers: gemini mcp add and mcpServers in settings.json](https://agentatlas.dev/guides/gemini-cli-mcp-servers): Run gemini mcp add with a name and a command or URL, or add an entry under mcpServers in settings.json.
- [Gemini CLI custom slash commands: TOML files, {{args}}, !{shell} and @{file}](https://agentatlas.dev/guides/gemini-cli-custom-commands): Create a .toml file with a prompt field in ~/.gemini/commands/ for global commands or .gemini/commands/ in your project.
- [Gemini CLI headless mode: gemini -p, JSON output and exit codes for scripts and CI](https://agentatlas.dev/guides/gemini-cli-headless-mode): Pass your prompt with -p (or --prompt), or run the CLI with piped input in a non-TTY environment.
- [Gemini CLI sandbox: enable Docker, Podman, macOS Seatbelt or gVisor](https://agentatlas.dev/guides/gemini-cli-sandbox): Start the CLI with -s (or --sandbox), set GEMINI_SANDBOX, or set tools.sandbox in settings.json.
- [copilot-setup-steps.yml: set up the GitHub Copilot cloud (coding) agent environment](https://agentatlas.dev/guides/github-copilot-setup-steps): Add .github/workflows/copilot-setup-steps.yml with a single job named copilot-setup-steps and merge it to your default branch.
- [GitHub Copilot CLI permissions: --allow-tool, --deny-tool, --allow-all-tools and trusted directories](https://agentatlas.dev/guides/github-copilot-cli-permissions): Use --allow-tool and --deny-tool with shell(COMMAND), write, or an MCP server name, or --allow-all-tools to skip all prompts.
- [GitHub Copilot custom agents: .github/agents/*.agent.md profiles, tools and frontmatter](https://agentatlas.dev/guides/github-copilot-custom-agents): Add a Markdown file ending in .agent.md to .github/agents with YAML frontmatter that includes a required description, then merge it to the default branch.
- [GitHub Copilot code review settings: automatic PR reviews, rulesets, effort level and approvals](https://agentatlas.dev/guides/github-copilot-code-review): For your own PRs, open Copilot settings, click Code review, and enable Automatic Copilot code review.
- [OpenCode MCP Server Setup: Local and Remote Servers in opencode.json](https://agentatlas.dev/guides/opencode-mcp-servers): Add the server under the top-level mcp key in opencode.json or opencode.jsonc.
- [OpenCode Permissions: Allow, Ask or Deny Bash, Edit and Webfetch](https://agentatlas.dev/guides/opencode-permissions): Set the permission key in opencode.json.
- [OpenCode Custom Agents and Subagents: Markdown Files, Modes and @ Mentions](https://agentatlas.dev/guides/opencode-agents-subagents): Put a markdown file in .opencode/agents/ for a project or ~/.config/opencode/agents/ for every project, or add an entry under the agent key in opencode.json.
- [Cline MCP Setup: cline_mcp_settings.json for Local and Remote Servers](https://agentatlas.dev/guides/cline-mcp-servers): Add the server under mcpServers in cline_mcp_settings.json.
- [Cline Auto Approve and YOLO Mode: Run Commands and Edits Without Prompts](https://agentatlas.dev/guides/cline-auto-approve-yolo-mode): Turn on the Auto Approve toggles you want, such as Read project files or Execute safe commands.
- [Cline Skills: SKILL.md Location, Format and Slash Command Use](https://agentatlas.dev/guides/cline-skills): Create a folder with a SKILL.md file in .cline/skills/ for a project or ~/.cline/skills/ for every project.
- [Amp MCP Setup: amp mcp add, amp.mcpServers and Workspace Approval](https://agentatlas.dev/guides/amp-mcp-servers): Run amp mcp add with a name and either a command or a URL, or add the server to amp.mcpServers in ~/.config/amp/settings.json or .amp/settings.json.
- [Amp AGENTS.md: File Locations, @ Mentions and Glob-Scoped Guidance](https://agentatlas.dev/guides/amp-agents-md): Put an AGENTS.md file in your repo.
- [Amp Skills: SKILL.md Folders, amp skill add and Search Order](https://agentatlas.dev/guides/amp-skills): Create a folder with a SKILL.md in .agents/skills/ for the project, or install one with amp skill add <source>.
- [Kiro MCP Setup: .kiro/settings/mcp.json, autoApprove and OAuth](https://agentatlas.dev/guides/kiro-mcp-json): Add the server under mcpServers in .kiro/settings/mcp.json for one workspace or ~/.kiro/settings/mcp.json for all workspaces.
- [Kiro Hooks: .kiro/hooks JSON, PreToolUse, PostFileSave and Stop](https://agentatlas.dev/guides/kiro-hooks): Create a JSON file in .kiro/hooks/ with a version of v1 and a hooks array.
- [Kiro Permissions: permissions.yaml Allow, Ask and Deny Rules](https://agentatlas.dev/guides/kiro-permissions-yaml): Create ~/.kiro/settings/permissions.yaml with rules that set a capability, optional match patterns and an effect of allow, ask or deny.
- [Factory Droid MCP Setup: droid mcp add, mcp.json Locations and /mcp](https://agentatlas.dev/guides/factory-droid-mcp): Run droid mcp add with a name, a URL or command, and --type stdio, http or sse.
- [Factory Droid Hooks: hooks.json, PreToolUse Matchers and Exit Codes](https://agentatlas.dev/guides/factory-droid-hooks): Put hooks in ~/.factory/hooks.json for yourself or .factory/hooks.json in the repo for your team, keyed by event name such as PreToolUse.
- [Factory Droid Custom Droids (Subagents): .factory/droids Markdown Files](https://agentatlas.dev/guides/factory-droid-custom-droids): Add a Markdown file with YAML frontmatter to .factory/droids/ in your repo or ~/.factory/droids/ for personal use.
- [Junie MCP Setup: .junie/mcp/mcp.json for CLI and /mcp Command](https://agentatlas.dev/guides/junie-mcp-json): Put an mcpServers object in .junie/mcp/mcp.json in your project, or in ~/.junie/mcp/mcp.json for all your projects.
- [Junie Brave Mode and Action Allowlist: Auto-Approve Commands in Junie CLI](https://agentatlas.dev/guides/junie-brave-mode-allowlist): Add allow rules to ~/.junie/allowlist.json so trusted commands run without asking, or turn on brave mode with /brave or Ctrl+B.
- [Junie Custom Slash Commands: .junie/commands Markdown Files and Arguments](https://agentatlas.dev/guides/junie-custom-slash-commands): Create a Markdown file with a description in YAML frontmatter in .junie/commands for the project or ~/.junie/commands for yourself.
- [goose .goosehints and AGENTS.md: Global and Project Instructions](https://agentatlas.dev/guides/goose-goosehints-agents-md): Create a .goosehints file in your project folder, or ~/.config/goose/.goosehints for rules that apply everywhere.
- [goose Permission Modes: GOOSE_MODE auto, approve, smart_approve and chat](https://agentatlas.dev/guides/goose-permission-modes): Set GOOSE_MODE to auto, approve, smart_approve or chat in ~/.config/goose/config.yaml, as an environment variable, or through goose configure.
- [goose Recipes: recipe.yaml Format, Parameters and goose run --recipe](https://agentatlas.dev/guides/goose-recipes): A recipe is a YAML or JSON file with a title, a description, and instructions or a prompt.
- [Zed Agent Tool Permissions: Auto-Approve Terminal Commands with tool_permissions](https://agentatlas.dev/guides/zed-tool-permissions): Set agent.tool_permissions in your Zed settings.
- [Use Claude, Codex and Gemini CLI in Zed: External Agents and agent_servers (ACP)](https://agentatlas.dev/guides/zed-external-agents-acp): Install them as External Agents from the ACP Registry with the zed: acp registry command, then start a thread from the Agent Panel agent selector.
- [Zed with Ollama, LM Studio and llama.cpp: Local Model Setup and Context Length](https://agentatlas.dev/guides/zed-ollama-local-models): Install Ollama, pull a model, make sure the server is running, then pick the Ollama model in Zed's model dropdown.
- [MCP 2026-07-28 Migration Guide: Stateless Protocol, No Sessions, server/discover, MRTR, and SDK v2 Upgrade](https://agentatlas.dev/guides/mcp-2026-07-28-migration): MCP 2026-07-28 makes the protocol stateless.
- [Subagents and Custom Agents Compared: Claude Code vs Codex vs Cursor vs Gemini CLI vs GitHub Copilot (2026)](https://agentatlas.dev/guides/subagents-claude-code-codex-cursor-gemini-copilot): All five tools let you define custom agents in files.
- [Allow all commands in any AI coding agent: Cursor, Claude Code, Codex, Gemini CLI, Copilot CLI and 7 more (2026)](https://agentatlas.dev/guides/allow-all-commands-ai-coding-agents): Every major coding agent has two levers: a full auto-approve switch (Run Everything in Cursor, --dangerously-skip-permissions in Claude Code, --yolo in Codex, Gemini CLI and Copilot CLI, YOLO Mode in Cline) and a scoped allowlist that pre-approves only the commands you trust.
- [Add an MCP server to any AI coding agent: Claude Code, Cursor, Codex, Gemini CLI, VS Code and 8 more (2026)](https://agentatlas.dev/guides/add-mcp-server-ai-coding-agents): Most agents read a JSON file with an mcpServers object: .cursor/mcp.json in Cursor, .mcp.json in Claude Code, .kiro/settings/mcp.json in Kiro, .factory/mcp.json in Factory Droid and .junie/mcp/mcp.json in Junie.
- [Settings file locations for every AI coding agent: Claude Code, Cursor, Codex, Gemini CLI, OpenCode, Qwen Code, Amp and Factory Droid (2026)](https://agentatlas.dev/guides/settings-file-locations-ai-coding-agents): Claude Code uses ~/.claude/settings.json plus .claude/settings.json and .claude/settings.local.json in the project.
- [Rules and instruction files in every AI coding agent: .cursor/rules, CLAUDE.md, AGENTS.md, GEMINI.md, Copilot instructions and more (2026)](https://agentatlas.dev/guides/rules-instruction-files-ai-coding-agents): Cursor reads .mdc files in .cursor/rules plus AGENTS.md.
- [Gemini CLI hooks: settings.json, BeforeTool, AfterTool, exit codes and /hooks](https://agentatlas.dev/guides/gemini-cli-hooks): Add a hooks object to .gemini/settings.json (project) or ~/.gemini/settings.json (user).
- [GitHub Copilot hooks: .github/hooks/*.json for Copilot CLI and the cloud agent](https://agentatlas.dev/guides/github-copilot-hooks): Commit a JSON file to .github/hooks/ with "version": 1 and a hooks object keyed by event, such as preToolUse or sessionStart.
- [Hooks in every AI coding agent: Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Kiro and Factory Droid (2026)](https://agentatlas.dev/guides/hooks-ai-coding-agents): Claude Code reads a hooks block in .claude/settings.json, Gemini CLI a hooks block in .gemini/settings.json, Cursor reads .cursor/hooks.json, Factory Droid .factory/hooks.json, GitHub Copilot .github/hooks/*.json and Kiro any JSON file in .kiro/hooks/, and Codex .codex/hooks.json or [hooks] in config.toml.
- [Agent Skills (SKILL.md) in every AI coding agent: Claude Code, Codex, Cline, Amp and OpenHands (2026)](https://agentatlas.dev/guides/skills-skill-md-ai-coding-agents): Every one of these agents reads a folder with a SKILL.md file whose YAML frontmatter has a name and a description.
- [How to deploy a remote MCP server (Streamable HTTP): Cloudflare Workers, Vercel, Railway and more (2026)](https://agentatlas.dev/guides/deploy-remote-mcp-server): Build your server with an official SDK's Streamable HTTP handler (createMcpHandler in the TypeScript SDK v2, or mcp.run(transport="streamable-http") or streamable_http_app() in the Python SDK v2), expose it at a single endpoint such as /mcp, and deploy it to any HTTPS host: Cloudflare Workers, a Next.js route on Vercel, or a web service on Railway that listens on 0.0.0.0:$PORT.
- [Headless mode in every AI coding agent: claude -p, codex exec, gemini -p, Cursor agent -p and copilot -p for scripts and CI (2026)](https://agentatlas.dev/guides/headless-mode-ai-coding-agents): Every major coding agent CLI has a one-shot mode: claude -p for Claude Code, codex exec for Codex, gemini -p for Gemini CLI, agent -p for the Cursor CLI and copilot -p for GitHub Copilot CLI.
- [Claude Code sandbox: /sandbox, sandbox.enabled, allowedDomains, excludedCommands and strict mode](https://agentatlas.dev/guides/claude-code-sandbox): The sandbox is off by default.
- [Sandbox modes in every AI coding agent: Claude Code, Cursor, Codex and Gemini CLI compared (2026)](https://agentatlas.dev/guides/sandbox-ai-coding-agents): Claude Code: run /sandbox or set sandbox.enabled and list hosts in sandbox.network.allowedDomains.
- [Custom slash commands in every AI coding agent: file locations, arguments and examples (2026)](https://agentatlas.dev/guides/custom-slash-commands-ai-coding-agents): Most agents turn a prompt file into a /command named after the file.
- [Migrate from Gemini CLI to Antigravity CLI (2026): Config, MCP, Skills, Flags](https://agentatlas.dev/guides/migrate-gemini-cli-to-antigravity-cli): Install Antigravity CLI with the official install script, run agy, and work through the interactive migration checklist it shows when it finds legacy Gemini CLI configs.
- [Run GitHub Copilot CLI with copilot -p in scripts and CI (2026)](https://agentatlas.dev/guides/github-copilot-cli-programmatic-mode): Pass a prompt with -p or --prompt and Copilot CLI runs it and exits.
- [Agent Loops 2026: Ralph Loop, /loop, /goal and Headless Loops for AI Coding Agents](https://agentatlas.dev/guides/agent-loops-ralph-loop-ai-coding-agents): The Ralph loop is Geoffrey Huntley's technique of feeding the same prompt file to a coding agent over and over in a Bash loop.
- [Web Scraping MCP Servers Compared (2026): Bright Data, Firecrawl, Apify, Tavily and Browserbase](https://agentatlas.dev/guides/web-scraping-mcp-servers-compared): For pages that block bots, Bright Data's MCP server is the only one of the five whose docs say it handles anti-bot measures, CAPTCHAs and proxy rotation on every request, and it has the largest free tier (5,000 requests a month).
- [Cursor skills and custom slash commands: .cursor/skills SKILL.md, .cursor/commands and /migrate-to-skills](https://agentatlas.dev/guides/cursor-skills-commands): Create a folder in .cursor/skills/ (project) or ~/.cursor/skills/ (user) holding a SKILL.md file whose frontmatter has a name that matches the folder and a description.
- [Codex hooks: hooks.json, PreToolUse allow/deny, exit code 2 and config.toml [hooks]](https://agentatlas.dev/guides/codex-hooks): Codex hooks are on by default.
- [GitHub Copilot prompt files in VS Code: .github/prompts/*.prompt.md slash commands](https://agentatlas.dev/guides/github-copilot-prompt-files): Save a Markdown file with the .prompt.md extension in .github/prompts (workspace) or in your VS Code user profile.
- [OpenCode custom commands: .opencode/commands, $ARGUMENTS, shell output and subtasks](https://agentatlas.dev/guides/opencode-custom-commands): Add a Markdown file to .opencode/commands/ in your project or ~/.config/opencode/commands/ for every project.
- [Qwen Code custom commands: .qwen/commands Markdown files, {{args}}, !{shell} and @{file}](https://agentatlas.dev/guides/qwen-code-custom-commands): Add a Markdown file to .qwen/commands/ in your project or ~/.qwen/commands/ for all projects.
- [Web Search MCP Servers Compared (2026): Tavily, Exa, Brave Search, Perplexity, Parallel, SerpApi and Firecrawl](https://agentatlas.dev/guides/web-search-mcp-servers-compared): For the lowest cost, start with Parallel Search: its hosted MCP server is free to use without an API key, and its API costs $1 per 1,000 fast searches.
- [Browser Automation MCP Servers Compared (2026): Playwright, Browserbase, Browserless, Browser Use, Bright Data and Chrome DevTools](https://agentatlas.dev/guides/browser-automation-mcp-servers-compared): For local testing and CI, use Playwright MCP from Microsoft: it is open source, runs on your machine, needs no account, and drives pages through the accessibility tree.
- [Database MCP Servers Compared (2026): Supabase, Neon, PlanetScale, Prisma Postgres, MongoDB, Redis, MotherDuck and ClickHouse](https://agentatlas.dev/guides/database-mcp-servers-compared): For Postgres with safe schema changes, Neon is the strongest pick: its MCP server tests migrations on a temporary branch first, has a readonly=true switch, and Neon's free plan includes 10 branches per project.
- [Best MCP Servers in 2026 by Job: Scraping, Search, Browsers, Databases, Hosting, Monitoring, Payments, Auth and Design](https://agentatlas.dev/guides/best-mcp-servers): For scraping sites that block bots, use Bright Data; for clean Markdown or JSON, use Firecrawl.
- [Payments MCP Servers Compared (2026): Stripe, PayPal, Paddle, Square and Adyen](https://agentatlas.dev/guides/payments-mcp-servers-compared): For SaaS subscriptions where you want sales tax handled for you, use Paddle: it is the merchant of record and charges 5% + 50¢ per checkout transaction, and its MCP server has a sandbox endpoint.
- [Deploy and Hosting MCP Servers Compared (2026): Vercel, Cloudflare, Railway, Cloud Run, Firebase, AWS and Netlify](https://agentatlas.dev/guides/deploy-hosting-mcp-servers-compared): For a front-end or Next.js app, Vercel's hosted MCP server covers the most ground: it can deploy, read build and runtime logs, edit environment variables and DNS records, with OAuth sign-in.
- [Error Tracking and Observability MCP Servers Compared (2026): Sentry, Grafana, Honeycomb, New Relic, Axiom, Honeybadger, Dynatrace and PagerDuty](https://agentatlas.dev/guides/observability-mcp-servers-compared): To debug app errors from your editor, use Sentry's hosted MCP server, or Honeybadger's if you already use Honeybadger, since its self-hosted server is read-only by default and the hosted one can be connected with read-only access.
- [Auth MCP Servers Compared (2026): Clerk, Auth0 and WorkOS](https://agentatlas.dev/guides/auth-mcp-servers-compared): For B2B apps with organizations, SSO and roles, use WorkOS: its hosted MCP server manages organizations, connections, directories and users, starts in a sandbox, and AuthKit is free for the first 1 million monthly active users.
- [Design MCP Servers Compared (2026): Figma, Canva, Webflow, Wix, Miro, Cloudinary](https://agentatlas.dev/guides/design-mcp-servers-compared): For design to code, use Figma's remote MCP server: it reads design context, variables and screenshots from a Figma file, and real use needs a Dev or Full seat on a paid plan (Starter gets 20 tool calls a month).

## Standards
- [Model Context Protocol (MCP)](https://agentatlas.dev/standards/mcp): The standard way to connect an agent to tools, data and services. One server works in every MCP client. Current revision 2026-07-28.
- [Agent2Agent Protocol (A2A)](https://agentatlas.dev/standards/a2a): Lets independent agents discover each other, delegate tasks and stream results, whoever built them. Stable, v1.0.1 (May 2026).
- [Agent Skills (SKILL.md)](https://agentatlas.dev/standards/agent-skills): Portable folders of instructions, scripts and references that an agent loads only when a task needs them. Supported by 45+ agent products.
- [AGENTS.md (AGENTS.md)](https://agentatlas.dev/standards/agents-md): A README for coding agents: build steps, test commands and conventions in one file at the repo root. Read by 20+ coding agents.
- [Agent Client Protocol (ACP)](https://agentatlas.dev/standards/acp): Lets any editor drive any coding agent, the way LSP lets any editor use any language server. 40+ agents implement it.
- [Universal Commerce Protocol (UCP)](https://agentatlas.dev/standards/ucp): Common building blocks for agents to discover products, build carts, check out and handle orders. Stable, v2026-08-25; lodging in draft.
- [Agent Payments Protocol (AP2)](https://agentatlas.dev/standards/ap2): Proves that a user really authorized what their agent is buying, using signed mandates. v0.2 (April 2026); used with UCP for agent checkout.
- [Personal Agent Protocol (PAP)](https://agentatlas.dev/standards/pap): A draft open standard, nicknamed Poppy, for how personal AI agents, such as Meta's Muse, connect to businesses on a user's behalf. Draft 0.2 is the current docs version; draft v0.1 (October 9, 2026) stays frozen at its own URL; working toward 1.0 with design partners.
- [Agent User Interaction Protocol (AG-UI) (AG-UI)](https://agentatlas.dev/standards/ag-ui): An event-based protocol that streams agent runs, state, tool calls and user input between an agent backend and a user-facing app. Stable, v1.0 (September 2026).
- [A2UI (A2UI)](https://agentatlas.dev/standards/a2ui): A declarative JSON format that lets agents send interactive UIs that clients render with their own native components. v0.9.1 current, v1.0 release candidate.
- [MCP Apps (MCP Apps)](https://agentatlas.dev/standards/mcp-apps): The official MCP extension that lets MCP servers return interactive HTML interfaces that render inside the host's chat. Stable extension, spec 2026-01-26.
- [Agentic Commerce Protocol (ACP (commerce))](https://agentatlas.dev/standards/agentic-commerce-protocol): An open spec for agent-driven checkout, where an AI agent runs the purchase flow and passes payment credentials while the business stays merchant of record. Beta; latest stable snapshot 2026-04-17.
- [x402 (x402)](https://agentatlas.dev/standards/x402): An open standard for paying for APIs and content directly over HTTP using the 402 Payment Required status code. Stable, protocol v2; foundation launched July 2026.
- [Trusted Agent Protocol (TAP)](https://agentatlas.dev/standards/trusted-agent-protocol): A signature scheme that lets merchants verify that an AI agent is a known, trusted agent acting for a real user with a specific intent. Open spec, launched October 2025, no formal version number.
- [Personal Agent Consent & Trust Protocol (PACT) (PACT)](https://agentatlas.dev/standards/pact): An open protocol, built on A2A and OAuth, that lets businesses verify which personal agent is calling and what the customer has authorized it to do. New, open-sourced October 6, 2026; spec labelled PACT 1.0.
- [Agent Network Protocol (ANP)](https://agentatlas.dev/standards/anp): An open protocol stack for decentralized agent identity, description, discovery, messaging and payments on the open web. v1.2 (latest).
- [Open Agentic Schema Framework (OASF)](https://agentatlas.dev/standards/oasf): A standard schema for describing AI agents' skills, domains and metadata so they can be published to and found in agent directories. Stable, v1.1.0.
- [WebMCP (WebMCP)](https://agentatlas.dev/standards/webmcp): A proposed browser API that lets web pages expose JavaScript functions as tools that AI agents in the browser can call. Draft Community Group Report (20 October 2026).
- [llms.txt (llms.txt)](https://agentatlas.dev/standards/llms-txt): A proposed markdown file at /llms.txt that gives agents a short, LLM-friendly guide and links to a site's key content. Proposal, v2 (updated August 2026).
- [Open Agent Specification (Agent Spec)](https://agentatlas.dev/standards/open-agent-spec): A portable, framework-agnostic configuration language for defining agents, workflows and multi-agent systems. Active, v26.3.1 (September 2026).

## Optional
- [Full index](https://agentatlas.dev/llms-full.txt): every server, skill and harness on one page.