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.

What's the rate limit for MCP publishing?

Pro plan: 500 publishes per day. Enterprise: configurable for agent-scale workloads.

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, show_branding.
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: fetch an artifact's content and metadata. 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 is permanent 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:

{
  "mcpServers": {
    "display-dev": {
      "url": "https://mcp.display.dev",
      "apiKey": "your-api-key"
    }
  }
}

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

For Claude Code CLI:

Add to ~/.claude/settings.json:

{
  "mcpServers": {
    "display-dev": {
      "url": "https://mcp.display.dev",
      "apiKey": "your-api-key"
    }
  }
}

For custom agents (REST API):

curl -X POST https://api.display.dev/v1/publish \
  -H "Authorization: Bearer $DISPLAY_TOKEN" \
  -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