Which agents support MCP?

Claude and Claude Code natively. Cursor has MCP support via settings. Windsurf supports MCP. Any agent built on the Claude API or supporting the MCP specification can call Display's tools.

Can agents update an artifact after publishing?

Yes. `display_publish()` with the same name overwrites the existing artifact. 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?

Teams 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 workspace storage limit, not against a per-publish fee. Teams 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, Cursor, Windsurf, 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 MCP server does

The Display MCP server exposes four tools:

display_publish(content, name, title?, visibility?)
  → Returns a permanent URL

display_find(query)
  → Search previously published artifacts

display_get(name)
  → Get content and metadata for a named artifact

display_delete(name)
  → Delete a published artifact

When an agent calls display_publish(), Display stores the content in the caller's workspace and returns a URL that's restricted to the workspace's configured email domains. The URL is permanent. It 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, calls display_publish(), and responds:

"Done. I've published the competitive analysis to your team: https://yourco.display.dev/competitive-analysis-q2"

No terminal. No file management. 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("display_publish", {
        "content": html,
        "name": f"weekly-report-{current_week()}",
        "title": f"Weekly Metrics — {current_week()}"
    })
    
    await slack_client.post_message(
        channel="#metrics",
        text=f"📊 Weekly report: {result['url']}"
    )

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, 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. Humans consume it. The distribution layer doesn't require human intervention at each step.

The MCP moment

What the Display MCP server does

How it works in practice

Setup

Why this matters for agent workforces

FAQ