What are MCP prompts?
MCP prompts are reusable message templates an MCP server offers to the client. The person picks one, often as a slash command, fills in its arguments, and the server returns ready-made messages for the model, with text, images, audio or linked resources inside. The server writes the words; the user decides when they are used.
Part of Glossary: the terms behind MCP, coding agents and shared pages, defined plainly.
The server declares the prompts capability and answers prompts/list with each prompt's name, title, description and arguments, flagging the required ones.
The client shows them where a person can choose, typically as slash commands. The model does not pick a prompt; a person does.
You choose one and supply its arguments. The client may ask the server to autocomplete values through the completion API.
The client sends prompts/get with the name and arguments. The server returns messages, each with a role and content: text, image, audio or a resource.
{ "method": "prompts/get", "params": { "name": "code_review", "arguments": { "code": "..." } } }The client adds those messages to the conversation and the model answers. If the list changes, a subscriptions/listen stream carries prompts/list_changed.
Source: MCP specification: prompts
Prompts versus tools and instruction files
The three things an MCP server can publish differ by who triggers them. A tool runs when the model decides to call it. A resource is read when the application decides to. A prompt runs when a person asks for it. The 2026-07-28 revision spells out a detail people get wrong: "user-controlled" is about who decides when the prompt is used, not who writes it. The server authors the content; you only choose the moment.
That makes a prompt a different animal from a CLAUDE.md, AGENTS.md or Cursor rules file. Those sit in your repository, apply to one agent, and shape everything it does. A prompt lives with the server, follows the server into every client that connects, takes arguments, and does nothing until invoked. It is closer to a slash command whose text is maintained by someone else.
Example: a code review prompt
The spec's own example is a prompt named code_review with a title, a description, and one required argument, code. In a client that supports prompts, it shows up as /code_review. You pick it, paste the code, and the client sends prompts/get with {"name": "code_review", "arguments": {"code": "..."}}.
The server replies with a description and a messages array. Here it is a single user message: "Please review this Python code:" followed by the code. A richer prompt could return two messages, a user turn and a pre-written assistant turn that sets the tone, or include a resource_link to the team's style guide so the client can fetch it, or embed a resource outright with its text or base64 blob inline. Every content block can carry annotations for audience and priority, the same ones resources use.
Since 2026-07-28, prompts/get may also come back as an InputRequiredResult. That is how a server asks for something it still needs, for instance through an elicitation form, before it can render the messages; the client gathers the input and retries the request. And prompts/list now returns ttlMs and cacheScope, so a client can cache the menu instead of asking on every keystroke.
When to use a prompt
Reach for a prompt when a workflow has a fixed shape and a person should start it on purpose: "summarise this ticket", "draft release notes for this tag", "explain this query plan". Reach for a tool when the model must decide, mid-task, that it needs the action. If the text should always be present, put it in a system prompt or an instruction file instead; a prompt the user has to remember to pick is the wrong place for a standing rule.
Keep the argument list short and mark only what is truly required. The spec says servers should validate arguments and return -32602 for a bad name or a missing required argument, so a long required list turns into a long list of ways to fail.
Common mistakes
- Expecting the model to discover prompts. It does not browse
prompts/list. If your client never shows a prompt menu, the prompt is invisible. - Using a prompt as a disguised tool. A prompt returns messages, not results. If the server has to look something up or change something, that is a tool.
- Skipping validation. The spec's security section is one line and it is blunt: validate all prompt inputs and outputs to prevent injection or unauthorised access to resources. Argument values end up in the model's context; treat them like user input.
- Polling for changes. A server that declares
listChangedwill sendnotifications/prompts/list_changed, but in 2026-07-28 only to clients that opened asubscriptions/listenstream withpromptsListChangedset to true.
FAQ
- Can the model call MCP prompts on its own?
- Not by design. The spec describes prompts as user-controlled: the server exposes them so a person can select them explicitly, which is why clients tend to show them as slash commands. A client is free to surface them differently, but the model has no prompts/get tool of its own.
- What can an MCP prompt contain besides text?
- Each message has a role, user or assistant, and content that can be text, a base64 image, base64 audio, a resource link the client can fetch, or an embedded resource with its contents inline. So one prompt can bring a code sample or a document along with the instructions.
- How are MCP prompts different from a CLAUDE.md or AGENTS.md file?
- An instruction file is read by one agent from your repository and applies to everything it does there. An MCP prompt lives on a server, works in any client connected to that server, takes arguments, and is used only when someone picks it.
Stop sending HTMLover Slack.
Create an account in a minute, connect your coding agent, and make your first board.