The Artifact

Your agent writes the page. You send the link.

Self-hosted hosting for the HTML pages coding agents build: reports, dashboards, prototypes, one-off tools. Claude Code, Cursor, Codex or any MCP client publishes a page and gets a link back. You choose who can open it.

Try it in the cloud · Quick start · Documentation · Self-hosting · Kubernetes · Roadmap · Contributing

Why

Agents are good at making a page that explains something: a chart from a CSV, a report after an incident, a clickable prototype. Getting that page to someone else is the awkward part. You end up with an HTML file in a chat, a screenshot, or a one-off deploy.

The Artifact gives every page a link. The agent publishes over MCP, the page runs in a sandbox, and you decide who can open it: specific people, your organization, or anyone with the link. Ask for a change and the agent publishes a new version to the same link.

Related MCP server: wovo-mcp

How it works

sequenceDiagram
    actor You
    participant Agent as Your agent
    participant Artifact as The Artifact
    actor Team as Your team
    You->>Agent: "Turn this CSV into a chart I can send to the team"
    Agent->>Artifact: publish_artifact (HTML, over MCP)
    Artifact-->>Agent: https://artifact.example.com/a/k3x9…
    Agent-->>You: Here's the link
    You->>Team: Send the link
    Team->>Artifact: Open it (if they have access)

1. Connect your agent once. Add The Artifact as an MCP server. The first time it publishes, your browser opens so you can sign in and pick a workspace.

2. Ask for a page in plain words. The agent writes the HTML and calls publish_artifact.

3. Send the link. Change requests publish new versions to the same address; the old ones stay in the history.

Examples

Pages an agent wrote and published on the hosted service, shared by link:

• Support report, Q3: numbers, a weekly chart and a table

• Release checklist: an interactive list with progress and filters

• How an agent signs in with PKCE: a diagram you step through

Their sources are in examples/.

Features

Publishing

• One link per page, every version kept. Republishing keeps the address; restore any older version, or compare two side by side or as a line diff.

• Single files or small sites. A page can bring its own CSS, JavaScript, images, fonts and data, loaded by relative paths. Update just one file, like a dashboard's data.json, without sending the rest.

• Agents can check their own work. inspect_artifact returns a screenshot, console errors, broken links and accessibility problems before the page is shared.

• Works with any MCP client. Streamable HTTP with OAuth 2.1 sign-in (PKCE, dynamic registration); setup for Claude Code, Claude Desktop, Cursor, VS Code, Codex and Windsurf is in the docs.

• Publishing from CI or a terminal, without an agent. Access tokens, POST /api/publish, and a CLI: npx @the-artifact/cli publish ./dist, with --watch to republish on every save while an open page updates itself (see Command line).

Sharing and feedback

• Private until you share it. Restricted, organization-wide, or anyone with the link, plus people added by email. Links can expire, need a password, or be reset.

• Comments, on the whole page or pinned to an element, which agents read over MCP to know exactly what to change.

• Views: how often a page and each version were opened, and who opened a shared page.

• Webhooks to Slack, Discord or any URL when a page is published, commented on or opened.

• Embeds in Notion, Confluence and anything that speaks oEmbed, with link previews.

Organizing

• A gallery with real thumbnails, rendered in headless Chromium that has no network of its own, with folders, tags and search that looks inside pages' text.

• Organizations with owners, admins and members, invitations, and a shared gallery. Duplicate a page or move it between workspaces.

• Export everything: a zip of your pages, versions and comments, or a whole organization's.

Running it

• Small footprint. One Docker image (amd64 and arm64), Postgres and any S3-compatible storage; one worker process per CPU. Docker Compose, Kubernetes manifests and a Helm chart.

• Isolated pages. Every page runs in a sandbox, optionally from a separate domain, so a page can never reach your session.

• Runs with or without email. Without SMTP, people sign in with a password and admins pass sign-up links on by hand.

• Passkeys and two-factor sign-in. Sign in with a passkey, or add one or an authenticator app as a second factor, with recovery codes; organizations can require it.

• Server admin area: people, organizations, suspensions, the sign-up policy, and a notice when a new release is out.

• Enterprise features with a license key: single sign-on (OpenID Connect and SAML), SCIM provisioning, an audit log and version retention. Everything else is free under AGPL-3.0.

Quick start

You need Docker with Docker Compose.

git clone https://github.com/andidev30/the-artifact
cd the-artifact/deploy/docker-compose
cp app.env.example app.env   # set APP_URL to the address people will use
cp .env.example .env         # passwords for the bundled Postgres and MinIO, the version to run
docker compose up -d         # pulls ghcr.io/andidev30/the-artifact at that version

Open http://localhost:8080 on the same machine and create the first account with the setup code from docker compose logs app; it becomes the admin of the server. The port is only published on 127.0.0.1 until you set ARTIFACT_BIND in .env or put a reverse proxy in front. Then connect your agent:

claude mcp add --transport http --scope user the-artifact http://localhost:8080/mcp

Other clients, HTTPS, email and backups are covered in Self-hosting. To build the image from the checkout instead, see Building the image yourself. For a cluster, see Kubernetes, which uses the same published image. Before updating, read the changelog and Upgrading.

MCP tools

Arguments and limits are in Publishing pages.

Documentation

The same pages are built into every install at /docs.

Development

Node 26 and pnpm 11, plus Docker for the services.

pnpm install
pnpm services        # Postgres, MinIO (console http://localhost:9001) and Mailpit (http://localhost:8025)
cp apps/api/.env.example apps/api/.env
pnpm db:migrate
pnpm dev             # API on :3000, web on :5173

pnpm lint runs Biome and the type checks, pnpm format formats, pnpm test runs the unit and integration tests, and pnpm test:e2e the browser tests; see TESTING.md. CLAUDE.md files describe the conventions for people and coding agents alike, and .claude/ holds shared Claude Code settings and project skills.

Contributions are welcome: what's planned is on the project board; read CONTRIBUTING.md first, and report security issues privately as described in SECURITY.md.

License

The Artifact is free software under the GNU Affero General Public License v3.0: self-host it, change it and share it. If you run a modified version as a service, share your changes too.

The code in ee/ folders (apps/api/src/ee, apps/web/src/ee) is under the separate Enterprise License. It holds what only the hosted service runs (its marketing site, contact form, onboarding welcome, plan limits and issuing license keys) and enterprise features, which a self-hosted install turns on with a license key. Without a key, a self-hosted install does everything described in the docs; the key is checked offline and nothing phones home. See Licenses.