One durable workspace for plans, reports, pages, decks, and sites. Keep the latest version at the same URL, work on it with people or agents, and use formal approval only when you need it. Hosted, or one self-hosted container.
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 workspaceGive your agent a durable place to publish, find, and improve work:
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 MCPOr paste this into a compatible coding agent and let it set itself up:
I'd like you to set up Derive — where the work we make gets kept, shared, and improved.
Install the skill if I have npm: npx skills add derive-to/derive --skill derive
Otherwise, read https://derive.to/skill.md and follow it (MCP server: https://derive.to/mcp).
Then pick something real we've worked on recently — a plan, a report, a designed page — and publish it. If I'm not connected to Derive, use the anonymous draft flow: no account needed, and it returns a live URL plus a claim link. Send me both so I can see it and claim it.
Derive is a workspace for agent-made artifacts. Give an HTML page, a Markdown document, a deck, or a whole built site a durable URL with its complete version history. Publish from the CLI, HTTP API, browser, or a compatible agent over MCP. Keep work private, share it, comment on it, edit it directly, or ask an agent to publish the next version.
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 to the same library. 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.
|
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. |
|
Share an artifact and @mention the people or agents who should weigh in. Comments pin to the exact text, direct edits create new versions, and connected agents can read feedback and publish focused revisions. When a decision truly needs sign-off, request a formal review of that version. |
|
|
|
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, optional 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 a compatible agent with one command.
- ✅ Visibility controls. Private, org, or public, with an optional password to lock public links.
The roadmap is a living Derive artifact — updated at the same URL and versioned on every revision — at derive.to/roadmap. 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.
|
The fastest path. No install.
You get a library, in-browser publishing, version history, and comments in about a minute. |
One container is the whole product: API, web, sign-in, publishing, comments, and the sandboxed viewer, with SQLite and blobs in one volume. Follow the self-hosting quick start to install a digest-pinned release or build the current checkout. It includes secure first-user bootstrap, readiness checks, and a verified first backup. See the deployment guide for Postgres, S3/R2, and cloud hosts. |
Want a complete artifact rather than a blank starter? Open or publish one of the official examples: a designed launch page, a research brief, or a living status report, each showing a different useful way to keep work in Derive and no invented customer claims.
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
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/mcpThe agent acts at the role you grant: publish access publishes directly; a lower scope reads and proposes. Full guidance is in packages/mcp/SKILL.md.
Derive gives compatible agents a shared place to publish, find, read, comment on, and update work.
Give your agent the skill — works with Claude Code, Codex, Cursor, and any agent that reads skills:
npx skills add derive-to/derive --skill deriveOr 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 workspacederive 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.
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 the artifact authoring standard for authoring and embed details.
The single-container image runs on any host with a persistent volume.
For a fresh installation, start with the self-hosting quickstart. The full deployment reference below covers managed hosts, external storage, scaling, and optional services.
- Railway: New Project → Deploy from GitHub repo → this repo. Add a Volume mounted at
/dataso SQLite and blobs persist, or attach Railway Postgres and setDATABASE_URL. - Fly.io:
fly launch --config deploy/fly.toml --dockerfile deploy/Dockerfile, thenfly deploy.
Both auto-detect their assigned URL for auth cookies and share links; set BASE_URL only for a
custom domain. See the
full deployment guide.
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. See the plain-English licensing guide.