An MCP tools/call result comes back. Which content types could it contain?

MCQ·Easy·4.0 · 0·~1 min·Asked atBraintrust Scale Ai Vernacular Ai·Relevant atAnthropic

Attempt it

When an MCP server responds to a tools/call request, the result object has two fields: `content` (an array of typed blocks) and an optional `isError` boolean. The content array is how the tool delivers its output. The 2026 spec defines four valid **content types**. `text` is a plain string payload. Most tools that return descriptions, status messages, or query results use this type. It is the most common by far. `image` is a base64-encoded image with a mimeType field (e.g., image/png, image/jpeg). A tool that generates a chart, takes a screenshot, or produces a diagram uses this. Multimodal models read the image as visual input on the next turn. `audio` is a base64-encoded audio clip with a mimeType field (e.g., audio/wav). Added in the 2025 spec to support voice-capable agents. A tool that synthesizes speech or captures a recording uses this. `resource` is a reference by URI to an MCP resource the host can fetch separately via resources/read. Instead of inlining a large payload, the server returns a pointer, and the host retrieves the data only when the model actually needs it. A single tool result can mix types. A weather tool might return a text summary alongside an image of the radar map. The host receives the full array, decides which blocks to forward to the model, and includes them in the next inference request. The type set is closed. Servers cannot invent custom types. Hosts can expect that every content block will be one of these four.

A tools/call result in MCP returns `{content: ContentBlock[], isError?: boolean}`. The content array carries the tool's output as a sequence of typed blocks. The 2026 spec defines four **content types**, and the set is a closed enumeration. `text` is `{type: "text", text: "..."}`. A UTF-8 string payload used for descriptions, query results, code snippets, status messages, and anything else that fits as text. The most common type in production. `image` is `{type: "image", data: "<base64>", mimeType: "image/png"}`. Image bytes encoded as base64 with an explicit MIME type. The host forwards this to multimodal models as native image input. Tools that generate charts, take screenshots, or render diagrams use this. `audio` is `{type: "audio", data: "<base64>", mimeType: "audio/wav"}`. Audio bytes encoded as base64, added in the 2025 spec to support voice-capable agents. Tools that synthesize speech or return recordings use this. On text-only models, the host can transcribe or drop the block. `resource` is `{type: "resource", resource: {uri: "...", mimeType: "...", text?: "..."}}`. A reference by URI to an MCP resource the host can fetch via resources/read. Instead of inlining large or contingent data, the server returns a pointer; the host fetches only what the model actually reads. A search tool returning twenty matches as twenty resource pointers saves orders of magnitude in tokens compared to inlining all twenty documents. Mixed arrays are the norm, not an edge case. A browser navigation tool returns a text description of the page alongside a screenshot image. The host receives the array and forwards each block to the model in whatever format the provider expects. The closed type set means hosts only need to handle four shapes. Servers that need a new content type must wait for a spec revision rather than inventing one unilaterally.

TL;DR

The 2026 spec defines four tools/call content types: text, image (base64 plus mimeType), audio (base64 plus mimeType, added 2025), and resource (URI reference). Mixed arrays are allowed; the set is closed.

Memory aid

Easy to grasp

Think of a tool result as a small package that can hold different kinds of items. MCP gives tools four kinds of boxes to put things in. A text box holds written messages. An image box holds a picture encoded as data. An audio box holds a sound clip. A resource box holds a card that says 'the actual thing lives at this address, go fetch it when you need it.' A single package can contain several boxes at once, like a written summary next to a chart picture, and the host figures out how to show each piece to the model. Servers cannot invent new box types on their own.

Key concepts

Content Blocks tools/call Multimodal Results Resource Reference

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

A tools/call result in MCP carries the tool's output as a typed sequence of content blocks. The four valid types in the 2026 spec, the closed-set policy, and the lazy-fetch resource reference are all design decisions that shape how agents handle multimodal payloads.

This explanation enumerates the types, gives the shape of each, explains why mixed arrays are the normal pattern, walks through the resource type's lazy-fetch benefit, and closes with the distinction between in-result tool errors and JSON-RPC protocol errors.

The result shape and the four content types

A tools/call JSON-RPC response returns {content: ContentBlock[], isError?: boolean}. The content array can be empty, contain one block, or contain many. Each block is a JSON object with a type field as the discriminator.

text is {type: "text", text: string}. A UTF-8 string payload for natural language output, query results, code, status messages, or any other text. The most common type by a wide margin.

image is {type: "image", data: string, mimeType: string}. The data field holds image bytes encoded as base64. The mimeType specifies the format (image/png, image/jpeg, image/webp). Hosts forward this to multimodal models as native image input. Browser automation tools return screenshots this way. Charting tools return generated visualizations. OCR tools can return the original image alongside recognized text.

audio is {type: "audio", data: string, mimeType: string}. Added in the 2025 spec. Same shape as image but for audio bytes (audio/wav, audio/mpeg, audio/ogg). Hosts route this to voice-capable models. Tools that synthesize speech, capture recordings, or produce audio analysis use this type.

resource is {type: "resource", resource: {uri: string, mimeType?: string, text?: string, blob?: string}}. Instead of inlining payload data, the block carries a reference to an MCP resource the host can fetch via resources/read. The tool returns a pointer; the host decides whether and when to dereference it.

Why the resource type exists: lazy fetching

Mixed-type arrays as the default pattern

Tool errors versus protocol errors

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

A browser automation server returns a text description of the loaded page alongside an image screenshot; multimodal models read the screenshot as visual input to decide what to click next.
A speech synthesis server returns an audio block with a wav payload and a text block describing the utterance; voice-capable hosts route the audio to the user, text-only hosts display the description.

What an interviewer would ask next. Try answering before peeking at the approach.

QWhy does MCP define a resource content type instead of always inlining data in text or image blocks?

Inlining forces the tool to pay token and bandwidth cost on every result regardless of whether the model reads the data. A resource URI lets the host fetch lazily. A search returning twenty matches as pointers becomes twenty small blocks; the model picks the one it wants to inspect and only that one is fetched.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Assuming every tool result is plain text. MCP tools can return images, audio, and resource references in the same array, and a single call can mix types freely.

60 second bullets to scan on the way to the call.

Name all four content types: text, image, audio, resource.
State that the type set is closed and servers cannot define custom types.

Primary sources. Browse if you want the original framing.