Doop Is a Free AI Design Canvas Where Your Coding Agent Designs Live Next to You

Doop shipped v0.6.0 this morning alongside a desktop build, and it answers a question a lot of us have been circling: what does it look like when an AI agent designs with you instead of handing you a finished file? Doop is a free AI design canvas — an infinite multiplayer board where frames render real HTML, and where Claude Code, Codex or any MCP client joins as a participant with a cursor, a name tag and a task list.

The hook for a working creator: if you already pay for a coding agent, the design side costs nothing and is never metered. Self-host in one command, connect your agent over MCP, and watch it stream a layout onto the canvas while you move things around underneath. Here’s the exact path, and where the “free” carries an asterisk.

At a Glance

• What it is: an open-source multiplayer design canvas with an MCP server built in, so AI agents edit the same board as humans, live.
• What’s free: the whole app. AGPL-3.0 source on GitHub, self-host with bun run dev, and the hosted doop.design Personal plan is $0 (currently “free in beta”).
• What it costs: nothing solo. Shared team workspaces on the hosted version are $20/seat/month or $192/seat/year.
• The hardware: no GPU. A Node server with embedded Postgres — any laptop works. You do need a local Chrome or Chromium for agent screenshots.
• The one catch: the built-in Doop Agent is off by default (RESIDENT_TASK_LIMIT ships at 0). The genuinely free path is bringing your own agent over MCP.

How the Canvas Actually Works

Every design lives at a URL like /c/<id> and holds Frames — artboards rendering real HTML inside sandboxed iframes. That one decision shapes everything: because a frame is HTML, an agent needs no proprietary file format and no plugin API, it just writes markup with inline CSS. And because the iframe is sandboxed with allow-scripts and no same-origin access, a frame can run JavaScript without reaching into the app around it.

Agents stream designs in with append_frame_html in 300–500 character chunks, and the server re-broadcasts at roughly 500 characters per second, so everyone sees a typewriter reveal rather than a design popping into existence. The MCP surface is broad: 20 tools covering canvas and frame edits, import_webpage, set_status for live narration, comment threads the agent can read and resolve, and get_frame_screenshot so it can review its own work and fix it.

What’s New in v0.6.0

Today’s release is small but pointed. The agent layer gained Claude CLI and API-key providers, and GPT-6 Astra joined the OpenAI model menu. On the canvas, you can now locate and follow a collaborator from a task row or avatar, and frame titles stopped stealing clicks at low zoom — which anyone who has tried to grab a background at 20% will appreciate. A desktop-v0.4.0 build landed the same day: 5.8 MB for macOS, 2.3 MB for Windows — a thin wrapper, not a bundled runtime.

Doop vs the Obvious Alternatives

Paper.design is the comparison that matters, since Doop names it as the thing it replaces. Paper’s free plan is generous on seats — unlimited viewers and editors — but meters the part you care about at 100 MCP tool calls per week. A single agent design pass can burn a dozen calls between creating a frame, streaming it, screenshotting and fixing, so that ceiling arrives faster than it sounds.

Try It Free: The Exact Path

Fastest route — hosted, nothing installed. Sign up at doop.design, create a canvas, then point your agent at the hosted MCP endpoint:

claude mcp add --transport http doop https://doop.design/mcp

That triggers a standard MCP OAuth flow — a browser tab opens, you approve, and the agent acts as you with your canvas permissions. Dynamic client registration is on, so there’s no manual setup. The docs carry equivalent snippets for Codex, Cursor and OpenClaw.

Self-host route — your machine, your data. Three lines, zero configuration:

git clone https://github.com/kgoedecke/doop && cd doop
bun install
bun run dev

The web app comes up on http://localhost:4300, the API, WebSocket and MCP server on :4400. Data persists to an embedded Postgres (PGlite) in data/pg — no external database, no Docker, no API key needed to get a canvas on screen. bun.lock is the only lockfile, so you need bun installed even though the server runs on Node. Connect locally with the same command pointed at http://localhost:4300/mcp. For production, BETTER_AUTH_SECRET=$(openssl rand -hex 32) docker compose up -d brings up the app plus Postgres on :4400. Desktop builds are on the releases page.

The Honest Trade-Offs

The built-in agent is not the free part. RESIDENT_TASK_LIMIT defaults to 0, so the server-side Doop Agent won’t run a single task until you set an ANTHROPIC_API_KEY or connect a model account. Self-hosting with your own key? Set that limit high — you’re paying Anthropic directly either way. The path that costs nothing extra is connecting Claude Code or Codex over MCP.

AGPL-3.0 is the strictest license in the table. Use it, self-host it, modify it freely — but offer a modified version as a service and you must publish your changes under the same license. A non-issue for internal use; read it properly if you planned to white-label a hosted design tool. The name and logo are trademarked separately, so rebrand anything you derive.

It is not a Figma replacement. Frames are HTML, not vector shapes: no pen tool, no boolean operations, no component library. This is a tool for web-shaped design — landing pages, app screens, pricing sections — and it is bad at anything wanting a real vector editor. For that, Penpot is the open-source answer.

The project is four weeks old. Created 22 August 2026, now at 715 stars, 12 contributors and 11 open issues. Fast-moving and promising, not settled — expect breaking changes between minor versions.

A warning the project prints about itself. Doop can drive its agent from a ChatGPT subscription via the Codex backend, and its own README states plainly that OpenAI’s terms do not sanction this and that heavy use can get an account rate-limited or suspended. The API-key path is the supported alternative. Credit to the maintainer for saying so out loud. Finally, agent screenshots render through your system Chrome via puppeteer-core — if it isn’t auto-detected, set CHROME_PATH, or get_frame_screenshot fails.

Five Workflow Tips Worth Stealing

• Make the agent screenshot itself, every time. Tell it: create the frame, stream it, call get_frame_screenshot, fix what looks wrong, re-check. Skipping the review loop is where agent design goes bad.
• Start from a real page, not a blank frame. import_webpage pulls a public URL in as an editable snapshot. Importing a competitor’s pricing page and asking for three alternatives beats describing one from scratch.
• Give every agent a fixed agent_name. It ties presence, the activity feed and task history together. Agents that rename themselves each session make the Tasks panel useless.
• Use the feedback key, not a new prompt. Hover a task and hit ↩ to leave a note like “make the accent warmer.” It becomes a claimable work item the next agent on the canvas picks up.
• Pin exemplars early. The design-memory distiller turns pinned frames into durable style rules every agent follows, which beats repeating brand notes in every prompt.

Where It Fits in a Free Stack

Doop covers layout and iteration. It doesn’t do diagrams — for that, Archify turns plain English into architecture diagrams, and AutoFigure outputs editable SVG and draw.io files. When the deliverable is a deck, Presenton generates presentations entirely on your own machine. All free, all self-hosting, none overlapping with Doop.

To see the “AI as design collaborator” idea before installing anything, we worked through it on the channel in How I Trained ChatGPT Image 2.0 to Be My Graphic Designer — with more on The Creative AI Show.

FAQ

Is Doop free?

Yes. The source is AGPL-3.0 and you can self-host the full app at no cost. The hosted doop.design has a free Personal plan, currently labelled “free in beta.” Only shared team workspaces are paid, at $20 per seat per month or $192 per seat per year.

Can I use Doop commercially?

Yes for client work and internal use — nothing in AGPL-3.0 restricts what you design or who you bill. The restriction is on the software: modify Doop and offer that version as a network service, and you must publish your changes under AGPL-3.0.

What are Doop’s system requirements?

No GPU and no model download. You need bun to install, Node to run, and a system Chrome or Chromium for frame screenshots. Dev uses an embedded Postgres; production should point DATABASE_URL at a real one. Desktop builds are 5.8 MB (macOS) and 2.3 MB (Windows).

Does Doop work with Claude Code?

Yes — it’s the primary supported client. One command adds the MCP server, an OAuth approval links it to your account, and the agent designs under your identity and permissions. Codex, Cursor and OpenClaw are documented too.

Is Doop a replacement for Figma?

No. Frames are HTML in sandboxed iframes, not vector artwork — no pen tool, no boolean shape operations, no Figma-style component library. Strong for web and app screens, weak for anything needing true vector editing.

Accurate as of September 19, 2026 — pricing and free-tier limits on beta projects move fast. Doop v0.6.0 and desktop-v0.4.0 both shipped today; check the releases page before relying on any version number here.