Claude Code vs Cursor vs Windsurf: Agent Support Compared

Why compare agent support specifically?

Most comparisons of AI coding tools focus on model quality, autocomplete speed, or pricing. Those matter, but they change constantly — a model update can shift the rankings overnight.

Agent support is different. It's an architectural choice that determines how extensible your tool is, how well you can customize its behavior, and how portable your configuration is across tools. This comparison focuses specifically on how Claude Code, Cursor, and Windsurf handle agent definitions, skills, and MCP servers.

Quick comparison

| Feature | Claude Code | Cursor | Windsurf | |---------|-------------|--------|----------| | Agent Skills spec | Full support | Full support | Full support | | Agent discovery | .claude/agents/, .agents/ | .cursor/agents/, .agents/ | .agents/, auto-discover | | Skill discovery | .claude/skills/, .agents/skills/ | .cursor/skills/, .agents/skills/ | .agents/skills/, ~/.agents/skills/ | | Legacy format | CLAUDE.md | .cursorrules | .windsurfrules | | MCP support | Full (stdio + HTTP) | Full (stdio + HTTP) | Full (stdio + HTTP) | | MCP config | .mcp.json | MCP settings | MCP settings | | Agent mode | Native (CLI-based) | Agent mode in editor | Cascade agent mode | | Progressive loading | Yes | Yes | Yes |

All three tools support the Agent Skills specification, MCP, and portable agent definitions. The differences are in the details: where they look for files, how they handle legacy formats, and how the agent interaction model works.

Agent definitions

Claude Code

Claude Code reads agent definitions from .claude/agents/ and .agents/agents/ in your project. Agents are Markdown files with YAML frontmatter. Claude Code also reads CLAUDE.md for project-level instructions — this isn't an agent definition, but it provides context that agents can build on.

Claude Code is CLI-native. You interact with agents in the terminal, which means agents have access to your full development environment: file system, git, running processes, and shell commands. This makes Claude Code particularly strong for agents that need to execute multi-step operations (running tests, making changes across files, checking build output).

Strengths for agents:

• Deep system access — agents can do anything you can do in a terminal
• Natural multi-step workflows — agents read files, make changes, and verify results in one interaction
• MCP integration works seamlessly from the CLI
• Skills have full access to shell scripts for automation

Cursor

Cursor reads agent definitions from .cursor/agents/ and .agents/agents/. It also supports the legacy .cursorrules file for backward compatibility. Skills are discovered from .cursor/skills/ and .agents/skills/.

Cursor's agent mode operates inside the editor, with a chat interface that can read and edit files, run terminal commands, and interact with MCP servers. Cursor's strength is the integration between AI and the editing experience — inline suggestions, multi-file diffs, and visual feedback on changes.

Strengths for agents:

• Visual diff review — see agent-proposed changes before accepting
• Inline code suggestions guided by agent instructions
• Strong editor integration for coding-focused agents
• Familiar IDE experience for developers coming from VS Code

Windsurf

Windsurf reads agent definitions from .agents/agents/ and discovers AGENTS.md files throughout your project hierarchy. It also supports .windsurfrules (legacy) and the newer .windsurf/rules/ directory format.

Windsurf's Cascade is its AI assistant, and it has a distinctive feature: directory-scoped rules. An AGENTS.md in a subdirectory automatically applies only when Cascade works with files in that directory. This is useful for monorepos or projects where different directories have different conventions.

Windsurf also supports rule activation modes: always-on rules that apply to every conversation, manual rules that you activate explicitly, and glob-based rules that trigger on file patterns.

Strengths for agents:

• Directory-scoped agent context — different rules for different parts of your codebase
• Activation modes let you control when agents are active
• Memory and rules system persists context across conversations
• Flow feature for understanding broader codebase context

Skills

All three tools support the Agent Skills specification with progressive loading: they read the name and description from YAML frontmatter, match skills to your prompt based on relevance, and load the full instructions only when needed.

Discovery paths

| Tool | Skill directories | |------|-------------------| | Claude Code | .claude/skills/, .agents/skills/, ~/.claude/skills/ | | Cursor | .cursor/skills/, .agents/skills/ | | Windsurf | .agents/skills/, ~/.agents/skills/ |

The shared .agents/skills/ directory is supported by all three, making it the best place to install skills for maximum portability. Skills installed there work regardless of which tool you're using.

How they load skills

The loading process is similar across tools:

1. On startup, the tool scans skill directories
2. It reads the name and description from each SKILL.md frontmatter
3. When you ask a question, the tool matches your prompt to relevant skills
4. Matched skills have their full body loaded into context

This means having many installed skills has minimal overhead — only relevant skills consume context window space.

MCP servers

MCP support is strong across all three tools. Each supports both local (stdio) and remote (Streamable HTTP) MCP servers.

Configuration

| Tool | MCP config location | |------|---------------------| | Claude Code | .mcp.json in project root | | Cursor | Cursor settings → MCP | | Windsurf | Windsurf MCP configuration |

The .mcp.json format is becoming a de facto standard. If you use this file, it's easy to share MCP configurations across team members through version control.

Practical differences

• Claude Code has the most mature MCP integration for command-line workflows. Since Claude Code is a terminal tool, MCP tools that interact with the system (running commands, managing processes) feel natural.
• Cursor integrates MCP tools into its agent mode chat interface. MCP results appear inline alongside code suggestions and file edits.
• Windsurf connects MCP to Cascade, and MCP tools are available alongside its built-in capabilities. Windsurf's Memories feature can persist MCP-related context across sessions.

The AgentShelf MCP server

The AgentShelf MCP server works with all three tools. It lets you search, discover, and download agents from the registry without leaving your coding environment. Since it supports remote Streamable HTTP, there's nothing to install — just add the URL to your MCP config.

Legacy format migration

Each tool has its own legacy format. If you're still using them, here's how they map to the portable standard:

| Legacy format | Portable equivalent | Migration guide | |---------------|--------------------|--------------------| | .cursorrules | .agents/agents/*.md | Migrating from .cursorrules | | .windsurfrules | .agents/agents/*.md | Split into agent definitions with frontmatter | | CLAUDE.md | Keep it — it serves a different purpose | CLAUDE.md is project context; agents are in .agents/ | | Custom GPTs | .agents/agents/*.md | Migrating from Custom GPTs |

Note that CLAUDE.md isn't exactly a legacy format — it's project-level context that all agents benefit from. Keep using it alongside portable agent definitions.

Which tool should you choose for agents?

Choose Claude Code if you prefer working in the terminal, need deep system access for your agents, or want the most mature MCP integration for DevOps and infrastructure workflows. Claude Code's CLI-native approach makes it the strongest choice for agents that need to execute complex multi-step operations.

Choose Cursor if you prefer a visual IDE experience, want to review agent-proposed changes as diffs before accepting them, or are coming from a VS Code workflow. Cursor's editor integration makes it the best choice for coding-focused agents where seeing the changes matters.

Choose Windsurf if you work with monorepos or codebases where different directories need different agent contexts, want directory-scoped rules, or prefer an IDE with built-in memory that persists across sessions.

The good news: since all three support the Agent Skills specification, your agent definitions are portable. You can try all three tools with the same agents and pick the one whose interaction model fits your workflow best. Agents on Agent Shelf work with all of them.

Learn more

• Best Agents for Claude Code
• Best Agents for Cursor
• Best Agents for Windsurf
• MCP vs Agent Skills: What's the Difference
• The Agent Skills Specification, Explained