Difference between an MCP server and an AI agent
An MCP server exposes tools; an agent is the program where a model decides which tools to call. How the work splits, with Sume's server and agent.
An MCP server exposes tools; an agent is the program in which a language model decides which of those tools to call, with what arguments, and in what order, to finish a task. The server doesn't choose when it is called: it lists its tools and answers the calls it receives. In MCP's architecture, the host application, such as a chat app or an IDE, coordinates the model and keeps the conversation, and it reaches each server through its own client.
The definitions follow the Model Context Protocol specification, version 2025-11-25 (Tools and Architecture), read on 2026-09-27. The examples come from Sume's MCP overview, Agent Completions, and Format run errors pages, because Sume offers both sides: a hosted MCP server and an agent of its own.
What does an MCP server do?
It exposes capabilities. The spec says MCP lets servers expose tools that language models can invoke to interact with external systems, such as querying databases, calling APIs, or performing computations. Each tool has a unique name and metadata describing its schema, including an inputSchema for its parameters. A client discovers tools with a tools/list request and runs one with tools/call. Servers can be local processes or remote services, and they are isolated by design: a server should receive only the context it needs, not the whole conversation, and should not be able to see into other servers.
Sume's hosted server at https://mcp.sume.com/mcp is one example. It lets agents call Sume account, catalog, job, asset, and generation tools, such as generate_video and jobs_wait, without wrapping the HTTP API themselves.
What does the agent do that the server doesn't?
It decides. The spec calls MCP tools model-controlled: the language model discovers and invokes them based on its understanding of the context and the user's prompts. The host coordinates the model, enforces security policies and consent requirements, and handles user authorization decisions. The spec also says there SHOULD always be a human in the loop who can deny a tool invocation.
| Responsibility | Whose job in the spec |
|---|---|
| Expose tools, each with a name and an input schema | Server |
| Discover and invoke tools from context and the user's prompts | The model: tools are model-controlled |
| Keep the full conversation history | Host |
| Enforce security policies and consent; handle user authorization decisions | Host |
| Validate inputs, control access, rate-limit invocations, sanitize outputs | Server (MUST) |
| Confirm sensitive operations with the user; time out tool calls | Client (SHOULD) |
What does the difference look like in practice?
Sume offers both sides, which makes the split concrete:
- Server side: connect your own agent, such as Claude Code or Cursor, to Sume's hosted MCP server. Your agent reads the tool list and decides when to call
generate_videoorjobs_wait. Sume checks each call: paid tools need anidempotency_key, and an OAuth session without Write getsinsufficient_scopeon them. - Agent side: send a task to
POST /v1/agent/completions, and Sume's own agent decides. It runs with a full sandbox, tools, an MCP bridge, and media generation, and the call returns a run receipt that you poll; Run the Sume video agent from your backend with Agent Completions covers the endpoint.
Who approves spending when the agent decides?
When your agent calls a server, approval belongs to your agent's client, which the spec says SHOULD prompt for confirmation on sensitive operations; Sume's gates apply on top. When Sume's own agent decides, nobody watches each call, so every Agent Completion must carry a spend cap, generation_spend_cap_usd. Sume's docs call the cap the substitute for the spend-approval prompt that protects you in the chat UI.
Can an agent also be an MCP client?
Yes. In MCP's architecture the host runs one client per server, so an agent that calls MCP tools does so through MCP clients. Sume's agent works this way: its runtime includes an MCP bridge, and one of Sume's Format run errors, mcp_unavailable, means the per-turn Sume MCP tools a run needed did not attach, so the run failed before the model ran. The agent supplies the decisions; the MCP tools supply the actions.
Do I need an MCP server, an agent, or both?
To use MCP tools, you need both: an agent decides and a server acts. The practical choice is which side you run. If you already have an agent, connect an MCP server to give it tools; you keep the decisions and the approvals. If you'd rather hand over the whole task, call an agent that already has the tools, such as Sume's Agent Completions. Sume's basics page names Formats, saved recipes the agent runs, as the surface most partners should integrate, and says hosted MCP still works but is not the primary path today. MCP vs CLI vs API for AI agents compares the interfaces, and MCP vs agent skills covers skills.
Sources
Related posts
More in Agents
- Summarize a video with an API: transcript, stills, then JSON
Summarize a Sume-hosted video: pull stills and a transcript with POST /v1/video-inspect, then send both to Agent Completions with an output_schema.
- Transcribe audio to text with Claude using an MCP tool
To transcribe audio to text with Claude, give it a speech-to-text tool over MCP and a public audio URL, then read the transcript and word timings.
- Video generation MCP server: how Sume's generate_video works
Sume's hosted MCP server has a paid generate_video tool: a prompt or image in, a job id back, then jobs_wait and jobs_result for the clip.
- What is Sume? A video agent platform, its API, and billing
Sume is a video agent platform: brief an agent in chat, save the recipe as a Format, and call it from your backend over one API. Surfaces and billing.
Written by Sume