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.

Andrej Karpathy @karpathy
“Instead of writing, ask your LLM to create a diagram. These can be a lot easier to process, parse, and understand…”
View original post ↗
Grady Booch @Grady_Booch Reply
“Hm, there's this thing called the UML…”
See the thread ↗

Your coding agent, inside DrawMode.

  • Claude CodeCodexDeepSeek HarnessPiOpenCode 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.
The DrawMode desktop app: a proposed MVVM refactor on the canvas, with DeepSeek Harness open in a tab beside it, connected to the project and explaining the proposal with a ports-and-adapters figure from a book
DrawMode itself, drawn by Claude Code over MCP when asked for a C4 component diagram of DrawMode with its UML domain model: the composition root, widgets and controllers, the canvas and its live sync, persistence, the domain classes, and the AI assistant and MCP door

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: Project, Diagram, Snapshot, Message and their association classes, with Container, Shape, Node and Link beneath — drawn in DrawMode first, then built

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

A sequence diagram from an ordering system, drawn by Claude Code when asked to explain it: the controller calls the send-money service, which loads the source and target accounts through a port, withdraws, deposits and updates the account state

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 drawn in DrawMode: the View's widgets, the ViewModels that hold presentation state and orchestrate, and the pure Model with its persistence — what exists today in solid lines, each box opening its code, and what is proposed dotted — then a table weighing it against the current layering, its net effect and its trade-off

A proposed MVVM refactor and the case for it.

Claude Code
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.yml
Pi
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

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 building a class diagram from a prompt and explaining the model
Asked what books he has, Orville lists his vectorized references — then builds a clean-architecture elevator control class diagram grounded in them

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.

AI-generated diagram with rich Markdown notes and KaTeX equations on the canvas
The pure model viewer — a typed, visual-free projection of the diagram

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.

Draw in an exceptional editor, working with agents to define, refine and explain your architecture.

Try DrawMode Desktop for free No credit card required