Let your AI agents draw like an expert.
Think together, visually.
Your agents work directly on the same diagrams you do—building, reading, explaining, and refactoring real models on a shared visual canvas.
“Instead of writing, ask your LLM to create a diagram. These can be a lot easier to process, parse, and understand…”View original post ↗
“Hm, there's this thing called the UML…”See the thread ↗
Your coding agent, inside DrawMode.
- Claude Code, Codex, DeepSeek Harness, Pi and OpenCode each sit as a window inside DrawMode Desktop — a tab beside your diagrams, connected to the project you have open.
- Any other agent that speaks MCP connects from its own terminal or app.
- Agents can access your vectorized docs and books, to instantly become an expert in any domain.
- Usage and files — see what a session cost is in realtime, and open code files created inside a pane in DrawMode.


DrawMode drawn by Claude Code — asked over MCP for a C4 component diagram of DrawMode with its UML domain model.
Analyze your systems with a prompt.
Connect Claude Code, Codex, DeepSeek Harness, Pi or OpenCode over MCP and your coding agent works on the same diagrams you do. It reads the model, not a picture: every element, relationship and constraint, typed. It draws new diagrams, edits yours by id, renders them to check its own work and asks what changed since it last looked.
- Point it at a codebase and get its architecture back — packages, layers, classes, sequences
- Ask it to explain what it is building, and get a diagram rather than a wall of text
- Its edits land live on your canvas, each stretch as one undoable step beside your own
Direct the agent.
It works the other way round, too. Draw the model you mean to build — the classes, the relationships, the constraints — and ask the agent to implement it. As you build together it keeps the diagram current with what it wrote, and you keep it current with what you want next. The model is the brief, and it stays the brief.
- A diagram precise enough to build from, and plain enough to argue over first
- Change the model and ask the agent to follow — or ask it to redraw the model from the code
- Every change, yours or the agent's, is in the register

The domain model we told Claude Code to use — drawn first, then built.

From an ordering system: asked to explain how money is sent, Claude Code drew the sequence — each step linked to its source.
Behaviour, not just structure.
Ask how something complex actually happens and the agent walks the code and draws the sequence: the lifelines, the calls in order, the optional and alternative paths. Each step it draws can carry a link to the source file and line it came from, so the diagram opens the code.
- Sequence, state and flow diagrams as readily as structure
- Source links on the shapes — click a message and land on the line that sends it
- Explain, then refine: ask why a step happens and the answer lands on the diagram
Refactor your architecture together.
Ask the agent to refactor and it maps a proposal onto the architecture that exists today. It shows you the design changes in context and explains the reasoning behind them. Debate the design, not a diff—move components around, rename a layer, or ask why. When the design is right, tell it to refactor the code to match.
- Proposals drawn over the real structure, never a blank page
- Today and tomorrow on one canvas
- Agree on the target first, then ask the agent to build to it

A proposed MVVM refactor and the case for it.
claude mcp add drawmode 'https://app.drawmode.ai/mcp?project=…' \ --transport http --header "Authorization: Bearer dmk_…"Codex
[mcp_servers.drawmode] url = "https://app.drawmode.ai/mcp?project=…" bearer_token_env_var = "DRAWMODE_MCP_KEY"DeepSeek Harness
npx @deepseek-ai/dsh web --patch .dsh/drawmode.cordis.ymlPi
pi mcp add drawmode --url 'https://app.drawmode.ai/mcp?project=…' \ --exposure direct --header 'Authorization=Bearer dmk_…'OpenCode
"mcp": { "servers": { "drawmode": { "type": "remote",
"url": "https://app.drawmode.ai/mcp?project=…", "oauth": false,
"codemode": false, "headers": { "Authorization": "Bearer dmk_…" } } } }
Connected in a minute.
In the app, MCP ▸ Connect a coding agent… gives each project a URL and a key, and writes out the exact line for your agent: one command for Claude Code or Pi, a few lines of config for Codex or OpenCode, a small file for DeepSeek Harness, and the plain facts for anything else that speaks MCP — on the desktop, one click writes the file into your repository. The agent then works from its own terminal or app while you watch the canvas.
On DrawMode Desktop the door is local to your machine, with nothing to key. MCP is part of the Professional plan, and every new account's 14-day trial includes it.
Everyone's work on the record
The register files every stretch of work by who did it and why — Claude Code, Codex, DeepSeek Harness, Pi, OpenCode, Orville and you alike. Click an entry to see the shapes it touched; ask the agent what changed since.
Code and model, linked
An agent can pin a shape to the file and line it came from, so a class in the diagram opens the class in your editor — and the next question starts from the code.
Your library, its library
Vectorize your standards and design notes and the agent searches them through the same door, so what it draws is grounded in what your documents actually say.
Orville the Owl is DrawMode's built-in AI assistant. He collaborates on your diagrams as another team member — with his own edits, his own undo and his own place in the register.
He's fast, too. Orville is built around DrawMode's deltas: he reads what changed since his last turn rather than the whole diagram again, and he's extremely capable — he can access the web, your personal library and images. And he's not alone — start up to four owls working at the same time, Orville, Wilbur, Katharine and Violeta, each on a task of their own.
You describe it. Orville draws it.
Ask for a diagram and the owls lay out a real, editable model — then keep working on it with you: extend it, restructure it, question it. Sketch the rough shape by hand and hand it over for the rigour, or start from a prompt and refine by dragging.
- Create a mind map, class model or state machine from a sentence
- Reverse-engineer a class model from code you paste in
- Ask "what's missing?" — it reasons about the design, not the pixels


Orville is super smart
Vectorize your own documents — specs, standards, design notes, papers — and the owls read them the way they read your diagrams. Ask a question and they answer from your material, not from the internet's average opinion; ask for a diagram and they draw one grounded in what your documents actually say.
On the web with Professional, and unlimited on DrawMode Desktop, where your library never leaves your machine.
Orville creates more than diagrams
The owls don't stop at boxes and lines. Ask for the reasoning behind a design — a specification, a worked example, a derivation — and they write rich Markdown notes, KaTeX equations included, straight onto the canvas beside the model they explain.
The diagram and its thinking live on one page.


A model tools can read
Everything the owls see, you can export: the pure model — every type, relationship and constraint, with the cosmetic layer of coordinates and colour stripped away. A clean, typed structure for code generators and downstream AI.
Diagrams also round-trip as plain text — Mermaid, PlantUML and OPML — so models move cleanly between your repo, your docs and other tools.
