Publish, review, and own your AI artifacts.

Permanent versioned URLs and a review loop your team and its agents share, on infrastructure you control. Hosted, or one self-hosted container.

Try free  ·  Self-host  ·  Docs

Try it in ten seconds

No account, no install — one request publishes a live page:

curl -F file=@page.html https://derive.to/v1/drafts   # or a .zip of a whole site
# → a live URL in about a second, plus a claim link that turns the
#   draft into a permanent, versioned artifact in your workspace

Give your agent the whole loop — publish, read comments back, revise:

npx skills add derive-to/derive --skill derive        # any agent that reads skills
claude mcp add --transport http derive https://derive.to/mcp   # or connect over MCP

Or paste this into any agent and let it set itself up:

I'd like you to set up Derive: the home for the work my agents and I make — published pages with versions and review.

Install the skill if I have npm: npx skills add derive-to/derive --skill derive

Otherwise connect over MCP: the server is https://derive.to/mcp (Claude Code: claude mcp add --transport http derive https://derive.to/mcp)

After setup, review https://derive.to/skill.md and ask me what I'd like to publish first.

What is Derive

Derive gives any static artifact, an HTML page, a Markdown doc, or a whole built site, a permanent URL with version history. Publish it from the CLI, the HTTP API, or an agent over MCP. View it rendered inside a sandboxed iframe. Share it with your team, gather comments pinned to the exact text, and approve revisions in a review loop that people and agents run together.

And the context travels with the work. Every artifact carries its content, its versions, and every review comment, so the context stays alive as it moves between people and tools. That kept context is what makes Derive model-agnostic: keep collaborating by hand or with your model of choice, and hand off without losing the thread, because the source of truth lives with the document, not inside any one AI chat.

Artifacts don't have to be static. A workspace can run contexts: agents with access to your data that answer questions and publish documents through the same review loop. Ask the analytics context a question, get a cited answer. Everything a context produces is a normal artifact — versioned, commentable, at a permanent URL.

The point is ownership. Unlike hosted-only tools for sharing AI output, Derive is fair source and self-hostable: run the whole product as one container on your own infrastructure, or use the hosted app. Your artifacts, your data, your URL.

Features

Publish anything, get a permanent URL HTML, Markdown, or a whole built site. Every revision is a new version at the same URL, so a link you shared last week still resolves, and still shows its history.

A review loop your team and its agents share Share an artifact and @mention the people who should weigh in. Comments pin to the exact text; approve a version or request changes. Agents drive the same loop over MCP: publish a draft, read the feedback, revise, resolve.

One library for everything you've shipped Every artifact you publish lands in one library with a live preview, sorted the way you work: favorites, shared with you, and collections. It lives on your own infrastructure or the hosted app, so the work you own stays in one place, not scattered across chat threads.

Also included:

• ✅ Kept context, model-agnostic. Content, versions, and feedback travel with the artifact (not locked in one AI chat), so any teammate or model can pick the work up.
• ✅ Contexts. Run an agent against your data. Teammates ask it questions; answers come back cited, under the same permissions as everything else.
• ✅ Checkpoints. Save working state as a one-page artifact. Any later session — yours or a teammate's — picks the work up from it.
• ✅ Sandboxed viewer. Every artifact runs on an opaque origin, isolated from cookies and other artifacts.
• ✅ Self-host your way. SQLite and local disk by default, or Postgres and S3/R2 at scale.
• ✅ Real-time collaboration. Comments, approvals, and who-else-is-here presence stream live over Server-Sent Events.
• ✅ Rich share unfurls. Every share link unfurls as a card in Slack, Discord, X, and Notion, showing the artifact itself, not a generic placeholder.
• ✅ CLI-first. Scaffold and publish from the terminal.
• ✅ Remote MCP server. Connect any agent with one command.
• ✅ Visibility controls. Private, org, or public, with an optional password to lock public links.

Roadmap

The roadmap is a living Derive artifact — maintained through its own review loop, versioned on every revision — at derive.to/roadmap (themes snapshot in ROADMAP.md). The direction in one line: pages you ask for and never maintain.

• Living pages. Describe a page in one sentence. A context builds it; a schedule keeps it current. Same URL, new version each run.
• Provenance. Every generated artifact names the context and brief that produced it. Feedback goes on the brief; the next run picks it up.
• Connections. Store a credential once, at the workspace level. Contexts reference it. It never appears in a brief, an artifact, or a repo.

Get started

docker compose -f deploy/compose.yml up -d
# → http://localhost:8080

From the terminal

npm i -g @derive-to/cli
derive init my-doc --template slides   # templates: md · html · slides
cd my-doc
derive publish                         # versioned URL; the id is saved to derive.json

Connect an agent (MCP)

 or one line for Claude Code: claude mcp add --transport http derive https://derive.to/mcp

# Derive is a remote MCP server (OAuth). Connect either client:
claude mcp add --transport http --scope project derive https://derive.to/mcp
codex mcp add derive --url https://derive.to/mcp

# or run a local stdio server (set DERIVE_SERVER; DERIVE_TOKEN for a static bearer):
npx -y @derive-to/mcp

The agent acts at the role you grant: publish access publishes directly; a lower scope reads and proposes. Full loop in packages/mcp/SKILL.md.

Agents: ship a page, get the review comments back

Derive is built for the loop where an agent publishes and a human (or another agent) reviews.

Give your agent the skill — works with Claude Code, Codex, Cursor, and any agent that reads skills:

npx skills add derive-to/derive --skill derive

Or skip installation entirely: the skill is served at derive.to/skill.md (paste the URL into a prompt), agents discover the surface via llms.txt and /.well-known/agent.json, and publishing needs no account at all:

curl -F file=@page.html https://derive.to/v1/drafts   # or a .zip of a whole site
# → a live URL in about a second, plus a claim link that turns the
#   draft into a permanent, versioned artifact in your workspace

derive init scaffolds one canonical derive skill into the native Codex and Claude locations (.agents/skills/derive and .claude/skills/derive) plus each client's project MCP config. For an existing repo, run derive agent setup; rerun with --update to refresh only the packaged Derive skill files while preserving MCP configs. The skill declares its MCP dependency for Codex and routes either client into the matching derive://skills/* workflow before it acts.

The core MCP tools: find (search + browse artifacts and contexts), read (content), catch_up (what changed, open feedback, version history, and — with no id — your work queue), comment (leave, reply, resolve), publish (save a revision), stage (upload out of band), use (ask a workspace context), and checkpoint (save resumable working state). For an image/font, stage mints a short-lived upload URL; the agent POSTs the local file's raw bytes, then uses the returned permanent URL or bundle ref in publish. Staging alone does not publish an artifact. publish goes live if your role can publish; otherwise, or with for_review: true, it files a proposal a human approves.

How it works

One Node container is the whole product; storage is pluggable behind interfaces. The same image self-hosts on SQLite and local disk, scales on Postgres and S3/R2, or runs on Cloudflare Workers.

apps/api          HTTP API, sandboxed artifact serving, viewer
apps/web          web UI (TanStack Start, SPA mode, static bundle)
packages/core     domain: ports, publish, markdown render, viewer shell
packages/db       MetaStore: sqlite (default) · postgres · d1
packages/storage  BlobStore: fs (default) · s3/r2
packages/cli      derive init (md/html/slides) · derive publish <file|dir> · derive runner serve (host a context)
packages/mcp      Local compatibility MCP: eight agent tools + derive://guide

Every artifact ships OG and Twitter meta plus an oEmbed document, serves a live Server-Sent Events stream, and renders under a strict sandbox CSP on an opaque origin. See STANDARD.md for the authoring and embed details.

Deploy

The single-container image runs on any host with a persistent volume.

• Railway: New Project → Deploy from GitHub repo → this repo. Add a Volume mounted at /data so SQLite and blobs persist, or attach Railway Postgres and set DATABASE_URL.
• Fly.io: fly launch --config deploy/fly.toml --dockerfile deploy/Dockerfile, then fly deploy.

Both auto-detect their assigned URL for auth cookies and share links; set BASE_URL only for a custom domain. Full guide: DEPLOY.md.

License

Functional Source License (FSL-1.1-ALv2), fair source. Run, modify, and self-host Derive freely for any purpose except offering it as a competing commercial product or service. Each release automatically converts to Apache-2.0 two years after it ships. The plain-English version: LICENSING.md.