Which agents support MCP?

Claude Desktop and Claude Code natively. Cursor has MCP support via settings. Codex supports MCP. Any agent that implements the MCP specification can invoke display.dev's tools.

Can agents update an artifact after publishing?

Yes. Invoke the `publish` tool with the artifact's `short_id` and the current `base_version`. The URL stays the same. Viewers who previously accessed it see the updated content on their next visit.

Are there limits on MCP publishing?

Rate limits are sized for agent-scale workloads, and Enterprise is configurable if you need more headroom.

Are there costs beyond the monthly subscription for MCP usage?

No. MCP publishes count against your organization storage limit, not against a per-publish fee. Pro plan: 25GB. Enterprise: configurable.

MCP Tools for Publishing: How AI Agents Share Their Own Output

The MCP moment

Model Context Protocol (MCP) emerged in late 2024 as the standard for giving AI agents access to external tools. By 2026, MCP is the plumbing of the agentic web: Claude Code, Cursor, Codex, and most AI coding tools support it. The number of published MCP servers has grown from dozens to thousands.

MCP matters for publishing because it closes the loop on the agent workflow. Before MCP, the workflow was: agent produces output → human manually publishes it → viewers access it. With MCP: agent produces output → agent calls publish tool → viewers access it. The human is removed from the distribution step.

What the display.dev MCP server does

The display.dev MCP server exposes seven tools. The names match the dsp CLI subcommands exactly; there's no translation layer between the two surfaces:

publish: create or update an artifact. Arguments: content or file_path, name, optional short_id to update, base_version when updating, format, visibility, share, theme.
share: change an artifact's visibility or add/remove shared-with emails without republishing.
rename: rename an artifact. The URL slug updates; existing URLs continue to resolve via short_id.
find: search artifacts. Argument: query.
get_metadata: fetch metadata, retained versions, the heading outline, and open comment threads. Argument: short_id.
export: return the artifact's original source bytes.
delete: delete an artifact.

When an agent invokes the publish tool, display.dev stores the content in the caller's organization and returns a URL that's restricted to the organization's configured email domains. The URL never changes and works immediately.

How it works in practice

In Claude Desktop:

User says: "Research our top 5 competitors and publish a comparison to my team."

Claude does the research, generates an interactive HTML comparison table, invokes the publish tool, and responds:

"Done. I've published the competitive analysis to your team: https://acme.dsp.so/0kzNYG7O-competitive-analysis-q2"

No terminal, no file management, and no human publishing step.

In an autonomous agent workflow:

async def run_weekly_report():
    data = await fetch_metrics()
    html = generate_report_html(data)
    
    # Agent publishes its own output
    result = await mcp_client.call_tool("publish", {
        "content": html,
        "name": f"weekly-report-{current_week()}",
        "visibility": "company",
    })
    
    await slack_client.post_message(
        channel="#metrics",
        text=f"📊 Weekly report: {result['url']}"
    )

Returned URLs live under the organization's subdomain on dsp.so, e.g., https://yourco.dsp.so/8f3kx9-weekly-report-2026-w15.

The agent runs on a schedule, publishes the report, and notifies the team, with no human involvement after the initial setup.

Setup

For Claude Desktop: the fastest path is a custom connector – Settings → Connectors → Add custom connector, paste https://api.display.dev/v1/mcp, and sign in with your work email. For a headless setup, use mcp-remote with an API key (keys start with sk_live_…):

{
  "mcpServers": {
    "display": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.display.dev/v1/mcp",
        "--header",
        "Authorization: Bearer sk_live_..."
      ]
    }
  }
}

Restart Claude Desktop. The tools are available in every conversation.

For Claude Code CLI:

Add to .mcp.json (project scope) or ~/.claude.json (user scope):

{
  "mcpServers": {
    "display": {
      "type": "http",
      "url": "https://api.display.dev/v1/mcp",
      "headers": {
        "Authorization": "Bearer sk_live_..."
      }
    }
  }
}

For custom agents (REST API):

curl -X POST https://api.display.dev/v1/artifacts \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{"content": "<html>...", "name": "report-name"}'

Why this matters for agent workforces

As teams build agent pipelines (research agents, analysis agents, documentation agents, monitoring agents), the output accumulates. Each agent produces content that humans need to read.

Without a publishing primitive, the workflow breaks down. Agents write to files on disk, to databases, or to Slack messages. None of these are the right format for the work product a human needs to review.

A publishing tool as an MCP primitive means every agent in a workflow can produce output that's immediately accessible to the right people, at a stable URL, behind company auth. The agent workforce produces content and humans consume it, and the distribution layer doesn't require human intervention at each step.

The MCP moment

What the display.dev MCP server does

How it works in practice

Setup

Why this matters for agent workforces

FAQ