Doop: The Open AI Design Canvas You Own

Every AI design tool asks you the same three questions without saying them out loud: whose agent runs the work, whose servers hold the memory of your project, and whose meter runs while tokens flow. Most closed tools answer all three in their own favor. Doop, which launched publicly on September 2, 2026, answers all three in yours. It is an open-source, multiplayer, MCP-native design canvas where humans and AI agents work on the same infinite board, you bring your own model subscription, and the record of what was decided lives in files you can read. That single set of choices reframes what an AI design tool is: not a prompt box that rents you intelligence, but a shared surface you own outright.

Background

Doop is an infinite design canvas where humans and one or more AI agents work at the same time, in real time. Instead of typing into a prompt box and waiting for a black box to return a result, you connect an agent you already run, such as Claude, Codex, or Cursor, over the Model Context Protocol, and watch it place, edit, and critique layouts directly on the board while you steer. Because any MCP-compatible client can join, multiple agents can operate on one canvas, review each other's contributions, and stream designs frame by frame. You can run two models against the same brief and compare their output side by side on the same surface.

The project is free, fully open-source, and self-hostable from its GitHub repository. The defining commercial choice is bring-your-own subscription: there are no platform tokens and no markup layered on top of model usage, so your cost is whatever you already pay your model provider. Design decisions are stored two ways at once, an editable Markdown file in the spirit of a DESIGN.md, plus a knowledge-graph database powered by Cognee that gives agents richer context across turns. Those three properties, open agents, local memory, and no token markup, are what separate Doop from the prompt-box design tools it is positioned against.

Deep Analysis

MCP-native and bring-your-own subscription

Most AI design products bundle the model, the interface, and the billing into one account. You sign in, you prompt, you are charged through the vendor's credits, and the intelligence doing the work is whatever the vendor chose and marked up. Doop unbundles that stack. The interface is the canvas; the model is any MCP client you already run; the billing is your existing provider relationship. MCP is the connective tissue that makes this possible, because it standardizes how an external agent reads and writes to the board without Doop having to build a bespoke integration for each model.

The practical effect is portability. If a better coding or reasoning agent ships next month, you point it at the same board and keep working, because the canvas does not care which model is on the other end of the protocol. This is the same build-with-agents pattern we covered in making your site agent-ready with WebMCP, now extended from websites to a visual design surface. For anyone already running Claude Code or Cursor daily, Doop is less a new tool to learn than a shared, visual workspace for agents they already trust.

Open vs closed design canvases

The clearest way to see what Doop changes is to line it up against the two families it competes with: other open agent-driven canvases such as Wonder, and closed prompt-box design tools such as Figma AI and Google's image tools. The three axes that matter are ownership of the agent, ownership of the memory, and who pays the token markup. Self-hosting is the fourth column because it determines whether any of the first three can be fully yours.

Read across the rows and a pattern appears. Closed tools optimize for a frictionless first session and keep the agent, the memory, and the meter on their side of the wall. Wonder-style hosted canvases open up the interaction model, agents visibly doing design work, but still run the agent and store the context for you. Doop is the only one of the three that hands you all four columns. That does not make it strictly better for everyone; it makes it a different trade, convenience for control, which is exactly the trade a growing set of builders now want.

Memory: DESIGN.md + Cognee vs vendor cloud

Memory is where the ownership question gets concrete. In a closed tool, the reasoning behind your design, why a layout changed, which direction the team rejected, what the agent was told about brand, lives in the vendor's cloud in a form you cannot easily read or move. Doop stores that reasoning in two layers you control. The first is a plain, editable Markdown file in the spirit of a DESIGN.md: a human-readable record of the project's direction that you can open in any editor, diff in git, and hand to the next agent as context. The second is a Cognee knowledge graph, which turns scattered decisions into structured, queryable context so agents keep continuity across turns rather than re-learning the brief every session.

The difference is not just philosophical. A local DESIGN.md means your design intent is version-controllable alongside code, portable between agents, and legible to a human without the tool running. A vendor cloud means your intent is a feature of someone else's product, available while you pay and while they keep the lights on. For a solo creator that may not matter on day one. For a studio building a body of work over years, owning the memory is the difference between an asset and a rental.

Self-hosting Doop

Self-hosting is what makes the ownership real rather than nominal. Because the full source is on GitHub, you can clone the repo, run the canvas on your own infrastructure, point it at your own model subscriptions, and keep both the Markdown memory and the Cognee graph on hardware you control. Nothing about the board, the decisions, or the token spend has to touch a third-party server you do not administer. That puts Doop in the same self-hostable open-canvas category as HyCanvas, with the added twist that the intelligence is agents you already pay for rather than a bundled model.

Self-hosting has a cost, of course. You take on setup, updates, and the operational care that a hosted vendor otherwise handles. But the payoff is a design environment with no external dependency for its core loop: your canvas, your agents, your memory, your bill. For teams with a privacy requirement, a data-residency rule, or simply a preference not to route client work through someone else's servers, that self-host path is the whole point.

Impact on Creators

For a creator or builder, Doop changes the economics and the ergonomics of AI-assisted design at the same time. On economics, removing the token markup means the marginal cost of an agent doing design work drops to raw provider API pricing, so heavy iteration stops being a metered anxiety and becomes just usage you already understand. On ergonomics, the multiplayer canvas turns design from a request-and-wait loop into a live collaboration: you can watch an agent lay out a screen, correct it in place, and let a second agent critique the result, all on one board.

The workflow fit is strongest for people already living in agent tooling. If you run Claude Code or Cursor to write software, Doop gives those same agents a visual surface and a shared memory, so the jump from a canvas layout to a running interface is short. Pair it with code-first visual pipeline ideas like Gradio workflows and the path from design decision to working app stays inside tools you own. The catch is that this is a builder's tool first. It rewards people comfortable connecting an MCP client and, if they self-host, running their own stack. A designer who wants a polished prompt box and nothing to configure will find a closed tool gentler on day one. Doop is aimed at the person who has decided that owning the agent, the memory, and the meter is worth a little setup.

Key Takeaways

• Doop launched publicly on September 2, 2026 as an open-source, MCP-native, multiplayer AI design canvas where humans and agents work on one board in real time.
• Ownership on three axes: you run the agent (any MCP client), you hold the memory (local DESIGN.md plus a Cognee knowledge graph), and you pay no token markup (direct provider API cost via your own subscription).
• Bring-your-own subscription replaces platform credits, so heavy iteration costs raw API pricing rather than a marked-up vendor meter.
• It is fully self-hostable from GitHub, putting it alongside open canvases like HyCanvas, with the twist that the intelligence is agents you already pay for.
• The trade against closed prompt-box tools is convenience for control; Doop is a builder-first tool that rewards comfort with MCP clients.

What to Watch

The open question is whether the ownership pitch converts into a durable ecosystem or stays a niche for the agent-native crowd. The three-axis argument, own the agent, own the memory, pay no markup, is compelling precisely for the people already running Claude Code and Cursor, but that is a narrower audience than the one closed prompt-box tools court with zero-setup polish. Watch two signals. First, whether the DESIGN.md-plus-Cognee memory model proves portable enough that decisions genuinely travel between agents and projects, because portable memory is the claim that most distinguishes Doop from a vendor cloud. Second, whether self-hosting stays approachable as the project grows, since the ownership story collapses if running your own stack becomes a specialist job. If both hold, Doop is an early template for what an open, agent-native design tool looks like when the creator, not the vendor, owns the agent, the memory, and the meter.