For

Publishing as an agent primitive

Q: Can an agent update an existing artifact?

Yes. Invoke the `publish` tool with the artifact's `short_id` and current `base_version`. The URL stays the same. Viewers who bookmarked it see the updated content.

AI agents produce content at scale – reports, analyses, dashboards, documentation. They need a publishing primitive that's programmatic, durable across model rotation, and flat-priced. display.dev is that primitive: the home for everything your agents make. Any agent – Claude Code, Cursor, Codex, OpenCode, CI, or your own private agent – invokes the `publish` tool and gets back a permanent URL. When you switch to a better agent next quarter, the URLs, versions, and comments stay exactly where they are. Gate output behind company SSO when you need to. No human publishing step. No per-seat pricing. No infrastructure to maintain.

Get your API key free →See pricing

Works with your agents

terminal

$ display publish ./report.html

Uploading 47kb

Auth Google Workspace ✓

✓ Published

→ https://view.display.dev/p/f474hfd/8f3kx9

Viewers anyone at acme.com

Expires never

Version 1

The agentic publishing problem

In Linear's March 2026 announcement, Karri Saarinen reported that agents now author nearly 25% of new issues, and that the total volume of agent-completed work grew 5× in three months. AI agents don't just write code anymore. They write reports, produce analyses, generate dashboards, and output HTML documentation at a scale no human team could match.

That content needs to go somewhere. Specifically: it needs to be accessible to the right people, at a stable URL, without requiring a publishing step from the engineer who ran the agent.

Every existing solution fails this:

Email/Slack: No stable URL, no interactivity, per-message sharing
GitHub Pages: Requires a git push step, excludes non-engineers without Enterprise Cloud
Confluence/Notion: Can't render the HTML agents produce
Vercel/Netlify: Requires a deployment project, $320/month for SSO

display.dev was designed from the start to be callable. The publish action is a function, not a workflow.

How agents publish with display.dev

Via MCP (recommended for Claude, Claude Code, and MCP-compatible agents):

{
  "name": "publish",
  "arguments": {
    "content": "<html>...",
    "name": "weekly-analysis-2026-w15",
    "visibility": "company"
  }
}
// → returns: { "url": "https://acme.dsp.so/0kzNYG7O-weekly-analysis-2026-w15" }

Via REST API (any agent, any language):

curl -X POST https://api.display.dev/v1/publish \
  -H "Authorization: Bearer $DISPLAY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "<html>...",
    "name": "weekly-analysis-2026-w15",
    "org": "yourco"
  }'

Via CLI in a shell pipeline:

agent run analysis.py --output ./report.html
dsp publish ./report.html --name "analysis-$(date +%Y-%m-%d)"

The returned URL is permanent and authenticated. Anyone with a @yourco.com Google or Microsoft email can view it. Everyone else is blocked.

The right pricing model for agent-scale publishing

Per-seat pricing breaks at agent scale. If your agent publishes 50 reports a week to an audience of 200 colleagues, per-seat pricing charges you for each viewer regardless of how many reports they actually read. The 201st colleague triggers a pricing jump. display.dev charges per organization, not per viewer. One flat price. Unlimited content. Unlimited viewers.

	Per-seat pricing	display.dev
100 viewers, 10 artifacts/week	~$700/mo (Cloudflare)	$49/mo
200 viewers, 50 artifacts/week	~$1,400/mo	$49/mo
500 viewers, 200 artifacts/week	~$3,500/mo	$49/mo
Scale to zero (no views this week)	Still charging per seat	$49/mo

What agents publish

Recurring analysis agents: – Weekly competitive reports, market monitoring dashboards, financial summaries. The agent runs on a schedule, fetches the current version, and republishes to a known URL with short_id and base_version. Stakeholders bookmark the stable URL.
Scheduled-build agents: – Nightly research summaries, weekly competitive landscape regenerations, scheduled market-map updates. The agent fetches the current version and publishes after every run with short_id and base_version, pinned to the same URL. The Slack notification links to an authenticated URL.
Research agents: – Deep research outputs, synthesis reports, literature reviews. Produced programmatically and published to a team-accessible URL without a human copying the content.
Tool-building agents: – Cursor, Codex, and Claude Code agents that scaffold internal tools. The agent builds, then publishes the output. Non-engineers get a usable URL without touching a terminal.

Add display.dev to your agent stack

For Claude and Claude-compatible agents: ``json { "mcpServers": { "display-dev": { "url": "https://mcp.display.dev", "apiKey": "your-api-key" } } } ``
Available MCP tools: - publish(content, name, visibility?) → create artifact, returns URL - publish(content, short_id, base_version) → update artifact, returns same URL at a new version - find(query) → search published artifacts - get(short_id) → get artifact content and metadata - delete(short_id) → delete a published artifact - share, rename, export for additional lifecycle operations
For custom agents (REST API): REST endpoints with the same verbs. API documentation ships with the CLI.

Flat pricing. Agent-scale economics.

Pro ($49/month) – Google + Microsoft SSO, unlimited viewers, unlimited artifacts, 25GB storage.
Enterprise – SAML, audit logs, SLA, custom data residency.

No per-API-call charges. No per-publish charges. No per-viewer charges. Flat.

See all pricing →

Get your API key free →

Features

Authentication

Viewers click a link and sign in with their Google or Microsoft account, or a one-time password. No app to install. No account to create. No IT ticket.

Comments

Inline comments on every artifact. Your agent reads them via MCP, fetches the current version, republishes with short_id and base_version, and resolves the thread. The artifact stays a living document, not a one-shot screenshot.

Publish in 15 seconds

dsp publish ./file.html from your terminal, or one sentence in Claude Desktop. No git repo, no deploy pipeline, no project to configure.

Permanent URLs

Every artifact gets a URL that keeps working. Share in Slack, link in Notion, paste in email. It still works six months later.

Unlimited viewers

No per-seat pricing at any tier. Share with your PM, exec, legal team, or designer for the same flat price.

Any agent

Claude Code, Codex, and Cursor all work, along with anything else that creates HTML or Markdown output.

FAQ

Common questions.

What agents does display.dev work with?+

Any agent that can make an HTTP request or call an MCP tool. Natively supported via MCP: Claude, Claude Code, Claude Desktop, Cursor, and any MCP-compatible client. Via REST API: any agent in any language.

Is there a rate limit on programmatic publishing?+

Pro plan: 500 publishes/day. Enterprise: configurable. Contact us for agent-scale workloads.

Can an agent update an existing artifact?+

Yes. Invoke the publish tool with the artifact's short_id and current base_version. The URL stays the same. Viewers who bookmarked it see the updated content.

What happens if a viewer's company email isn't on the allow-list?+

They're shown an authentication error and cannot view the content. You can add additional allowed domains (for contractors, partners) or grant access to specific individual emails.

Can agents publish to a custom domain?+

Yes. Pro plan supports custom domains. Configure your domain in organization settings, and published artifacts appear at docs.yourco.com/[artifact-name] rather than acme.dsp.so/[artifact-name].

How are an agent's actions attributed?+

Every comment and version an agent publishes is signed with the agent and the human it acted for, like codex on behalf of Carl. See how identity works.

Publish your first artifact in 15 seconds.

Free tier. No credit card. One-time password auth on free, Google + Microsoft SSO on Teams ($49/month flat).

Get started free →See pricing