CLI vs MCP vs Purpose-Built Tools, and Skills vs Agents: Claude Code, Copilot and Agentforce Vibes Compared

For developers, tech leads and Salesforce admins deciding how their team connects AI assistants to their systems. Admins who do not work in a terminal can start with the terms below and the section "For Salesforce admins" near the end.

TL;DR

• Three ways to connect an AI assistant to a system: let it run CLI commands, give it an MCP server, or give it a purpose-built tool that does the domain work. In my Salesforce benchmark the purpose-built route cost 35 to 41% less and used 57 to 68% fewer output tokens than the CLI or a general MCP server.
• The hidden cost of MCP is the tool list. A broad MCP server can cost tens of thousands of tokens per turn before any work starts. Every major tool now has a way to load tools on demand instead.
• Skills and agents solve different problems. A skill is a package of instructions and scripts that loads only when needed. An agent (or subagent) is a separate worker with its own context window that hands back a summary. Agents can use skills, and in Claude Code a skill can run inside a subagent.
• The four tools are converging. Claude Code, GitHub Copilot, Copilot Studio and Agentforce Vibes all support MCP and the Agent Skills open standard. They differ on where the work runs, terminal access, approvals and billing.
• Salesforce teams: the local Salesforce DX MCP server (@salesforce/mcp) reaches end of life on 2 November 2026, and Salesforce says its tooling is now delivered as skills.

What You'll Learn

• When to use CLI commands, an MCP server or a purpose-built tool, and what each costs in tokens
• What skills, agents and subagents are, and how they relate to MCP
• Whether agents can use skills in each tool
• How Claude Code, GitHub Copilot, Microsoft Copilot Studio and Agentforce Vibes differ and where they align

The Problem

Every AI coding and business assistant now offers several ways to reach your systems and several ways to package know-how: shell commands, MCP servers, connectors, skills, custom agents, subagents, instructions files. Each vendor uses the words slightly differently. Copilot Studio even uses "skills" for two unrelated things.

The choice matters because it decides cost, accuracy and what a smaller, cheaper model can handle. With GitHub Copilot moving to token-based billing on 1 June 2026, and Copilot Studio and Agentforce Vibes billing usage too, efficiency now shows up directly on the bill.

Common Questions This Article Answers:

• Should I let my AI assistant use the CLI, or connect it through MCP?
• What is the difference between a skill and an agent, and can an agent use a skill?
• If I build skills for Claude Code, will they work in Copilot or Agentforce Vibes?

Quick Answer

Use a purpose-built tool for questions you ask repeatedly in one domain: it is the cheapest and works with smaller models. Use the CLI for developer work when you are in a terminal with a strong model. Use an MCP server to connect systems the assistant has no other way to reach, and enable only the tools you need. Package repeatable procedures as skills, because they cost almost nothing until used. Use agents or subagents when a task needs a lot of reading or can run in parallel, so the detail stays out of your main conversation. Skills follow an open standard, so a well-written skill works across Claude Code, GitHub Copilot, Copilot Studio and Agentforce Vibes with little or no change.

A few words you will see

Part 1: CLI vs MCP vs Purpose-Built Tools

The three routes

A purpose-built tool can be delivered over MCP. The difference is the design of the tool, not the protocol.

What the measurements show

I measured all three routes on the same three Salesforce admin questions in Claude Code, on Haiku, Sonnet and Opus (full method and confounds). Disclosure: the purpose-built tool in that test, OrgPulse, is our product.

Each route answered the three questions on each of the three models: nine runs per route. The figures are totals for those nine runs.

Every miss was on Haiku. With the purpose-built tool, Haiku only had to read a clear result. With raw query tools, it had to know Salesforce well enough to plan the queries, and it guessed.

The tool list is the hidden cost of MCP

An MCP server sends its tool definitions to the model, and a big tool list is paid for before any work starts. In the same benchmark, a narrow MCP setup cost about 2,000 tokens per turn; the DX MCP Server with every toolset enabled cost about 27,000. Salesforce's own README for that server warns that its 60-plus tools "can overwhelm the LLM context."

Anthropic's engineering team reported a more extreme case: presenting MCP tools to the agent as code it could explore on demand cut a Google Drive to Salesforce workflow from 150,000 tokens to 2,000.

Each tool now has its own answer to this:

Pros and cons

Part 2: Skills vs Agents

These two get confused because both "add capability" to an assistant. They do different jobs, and so does MCP:

In short: MCP reaches systems, skills carry procedures, and agents take on work in a separate context. In Salesforce terms:

• MCP: the assistant can read your org's users, permission sets and limits.
• Skill: your team's permission set naming and review checklist, applied whenever someone asks for a new permission set.
• Agent: "go through all 300 profiles, find the ones that grant Modify All Data, and report back", done in its own context so the main conversation only sees the findings.

Can agents use skills?

Yes, in the tools that document both:

• Claude Code: a subagent's definition has a skills field that preloads named skills into it. Subagents do not inherit the main session's skills automatically, so you choose what each one gets. It also works the other way: a skill with context: fork runs inside its own subagent.
• GitHub Copilot: skills work across the Copilot cloud agent, code review, Copilot CLI and agent mode in VS Code and JetBrains, and custom agents can use MCP tools and run as subagents with handoffs. The documentation I checked does not say whether a custom agent can be limited to specific skills.
• Copilot Studio: agents built on the new GitHub Copilot harness have skills (up to 100 per agent), tools including MCP servers, and connected agents.
• Agentforce Vibes: skills load on demand and MCP tools are selected automatically, and Plan Mode lets you approve a plan before anything changes. Its listing and changelog do not document user-defined agents or subagents.

Who triggers a skill

In Claude Code, Claude can invoke a skill automatically when its description matches the task, or you can run it as /skill-name. Either can be switched off per skill: disable-model-invocation keeps a skill for manual use (useful for anything with side effects), and user-invocable: false makes it background knowledge only Claude uses. Custom slash commands have been merged into skills.

Plugins bundle all three

A Claude Code plugin can package skills, subagents, hooks and MCP servers together and install them as one unit. That is the practical way to share a team's whole setup.

Part 3: How Claude Code, Copilot and Agentforce Vibes Compare

Where they align

• MCP is universal. All four can connect to MCP servers, so one well-designed server serves every assistant your team uses.
• Skills are portable. Anthropic published Agent Skills as an open standard in December 2025. GitHub Copilot, Copilot Studio's GitHub Copilot harness and Agentforce Vibes all use it, as do OpenAI Codex, Cursor and Gemini CLI. Copilot even reads skills from .claude/skills.
• Everyone loads on demand now. Skills load their full content only when used, and each tool has a way to avoid sending every MCP tool definition every turn.
• Instruction files are shared. Copilot and Vibes both read AGENTS.md, and Copilot reads CLAUDE.md as well.

Where they differ

• Where work runs. Claude Code and Copilot CLI run on your machine; the Copilot cloud agent and Copilot Studio run in the vendor's cloud. That changes what credentials the agent can reach and what it can break.
• Approvals. The Copilot cloud agent uses its MCP tools "autonomously, and will not ask for your approval." Claude Code, Copilot CLI and Vibes ask by default, with allowlists and modes to reduce prompts. Know which mode each surface is in before connecting a server that can write.
• Terminal access. Copilot Studio has none; the other three can run commands.
• Audience. Copilot Studio's Agent Builder lets business users build agents from SharePoint and connectors, but it cannot author actions that call external services; those agents have to move to Copilot Studio.
• Billing. GitHub Copilot moved from premium requests to token-based AI Credits on 1 June 2026 (annual Pro plans keep premium requests until they expire). Under the old model tool calls did not count; under credits, long agent sessions cost more. Copilot Studio bills Copilot Credits, and Agentforce Vibes bills usage to the org.
• "Skills" means two things in Copilot Studio. On the GitHub Copilot harness it means Agent Skills. On the standard harness it means Azure Bot Service skills, an unrelated feature.

For Salesforce Admins

You do not need a terminal for most of this.

• No-terminal options: Agentforce Vibes is included in Salesforce orgs and has Plan Mode, so you approve a plan before anything changes. Copilot Studio, Microsoft's agent builder, connects to MCP servers without any command line. Ask your Salesforce account team what Vibes usage your org includes; I could not find published limits.
• Start in a sandbox. Connect any assistant or MCP server to a sandbox first, never straight to production.
• Never give an agent write access to production. Use a read-only integration user where you can. Remember that the Copilot cloud agent uses its MCP tools without asking for approval.
• Write your checklists as skills. A skill is just a folder with a written instruction file. Your team's naming conventions, a permission set review checklist or a release runbook make good first skills, and they work across Claude Code, Copilot and Vibes.

Does the DX MCP end of life affect me?

• Find out whether you use it. In VS Code, look for @salesforce/mcp in .vscode/mcp.json or .mcp.json in your project. In Claude Code, run claude mcp list. If none of this sounds familiar, ask whoever set up your AI tools.
• If you do: npx skills add forcedotcom/sf-skills installs Salesforce's skills into a project. It needs Node.js installed.
• If you only use Agentforce Vibes: Vibes ships its own built-in DX MCP server. Salesforce's end-of-life notice does not say whether that is affected, and I found no official statement either way. Check the Vibes release notes before 2 November.

For Salesforce Teams: The DX MCP Server Is Going Away

The local Salesforce DX MCP server, @salesforce/mcp, reaches end of life on 2 November 2026, according to its README. In the project's issue tracker, a Salesforce maintainer wrote on 5 October 2026: "Salesforce tooling is now delivered as skills," pointing to forcedotcom/sf-skills. Those skills follow the Agent Skills specification, are built for Agentforce Vibes, and can be added to Claude Code, Cursor, Codex and other tools with npx skills add forcedotcom/sf-skills.

Here a vendor is moving its own developer tooling from a large MCP tool list to on-demand skills. If your team's Claude Code or Copilot setup relies on @salesforce/mcp, plan the move before November.

Whatever you use, govern what can reach your orgs: which MCP servers are allowed (third-party MCP server governance), and how the assistant handles untrusted content it reads (prompt injection hardening).

Frequently Asked Questions

Q: Is MCP being replaced by skills?

A: No. MCP is still how an assistant reaches a system it cannot reach otherwise, and all four tools support it. What is changing is how much of the know-how sits in tool definitions. Skills carry procedures cheaply, tools load on demand, and Salesforce's own developer tooling is moving from a local MCP server to skills.

Q: Can an agent use a skill?

A: Yes. In Claude Code you list the skills in the subagent's skills field; subagents do not inherit the main session's skills on their own. Copilot Studio agents on the GitHub Copilot harness have skills directly. GitHub Copilot supports both skills and custom agents across its surfaces, though its documentation does not say whether a custom agent can be limited to specific skills.

Q: Will a skill I write for Claude Code work in Copilot or Agentforce Vibes?

A: Usually, because all three use the Agent Skills format. GitHub Copilot reads skills from .claude/skills, and Vibes uses .vibes/skills. Test it, though: a skill that names tools or commands specific to one assistant will need those parts adjusted.

Q: Which route is cheapest?

A: For repeated questions in one domain, a purpose-built tool: in my benchmark it cost 35 to 41% less than a general MCP server or the CLI. For open-ended developer work, the CLI or a narrow MCP setup on a strong model. The most expensive setup is a broad MCP server with every tool enabled and no on-demand loading.

Key Takeaways

• The tool's design mattered more than the protocol. A purpose-built tool over MCP beat both a general MCP server and the CLI on cost and accuracy.
• Watch the tool list. Enable only the MCP tools you need, or use each assistant's on-demand loading.
• MCP reaches systems, skills carry procedures, agents work in a separate context. Use each for its own job, and give agents the skills they need explicitly.
• The ecosystem is converging on MCP and Agent Skills. Invest in skills and narrow servers once, and they work across Claude Code, Copilot and Agentforce Vibes.

What's Next?

Recommended Reading:

• Salesforce in Claude: Token Cost of OrgPulse vs DX MCP vs the sf CLI, the benchmark behind Part 1
• Third-party MCP server governance for Salesforce, deciding which servers can reach your orgs
• Post-ForcedLeak: Hardening Agentforce Against Prompt Injection, the agent as an attack surface

Action Items:

1. List the MCP servers each assistant on your team connects to, and switch off the toolsets nobody uses.
2. Turn one procedure your team repeats into a skill, and try it in two different assistants.
3. If you use @salesforce/mcp, plan the move to sf-skills before 2 November 2026.

Resources & References

• Claude Code: Skills
• Claude Code: Subagents
• Claude Code: Plugins
• Anthropic: Introducing Agent Skills, and the open standard update
• Agent Skills specification
• Anthropic Engineering: Code execution with MCP
• GitHub Docs: About Agent Skills
• GitHub Docs: About custom agents
• GitHub Docs: Extend the coding agent with MCP
• VS Code: Tools in agent mode
• GitHub Changelog: Copilot is moving to usage-based billing
• Microsoft Learn: Copilot Studio harnesses
• Microsoft Learn: Copilot Studio skills
• Microsoft Learn: Agent Builder
• Agentforce Vibes on the VS Code Marketplace
• Salesforce DX MCP Server (end-of-life notice)
• forcedotcom/sf-skills