Phase 3 is live · docs that stay in sync with your map

Your whole system, as one living map.

DocLoom keeps your architecture in step with how it's really built. Draw it, scan it from your repo, or let your AI build it over MCP. Every change lands live, versioned and explained.

Start mapping free →See how it works
  • ER diagrams from SQL or GitHub
  • MCP server for Claude
  • Every change versioned, with undo
Checkout service · Map
v14Live
Web appui.render
Orders APIGET /orders/:id1
Postgresorders · users
Paymentsadded by Claude
500 · GET /orders/42
LiveClaude (MCP) · added Payments

Animation: three nodes are drawn and connected, an AI adds a Payments service over MCP which appears live, then a failing request marks the Orders API node with an error.

How it works

Start anywhere. End with one map.

Three ways in, one source of truth. Mix them freely: they all edit the same versioned graph.

Untitled project · Map

Built for AI

Give your AI a map it can actually edit.

DocLoom is an MCP server. Connect Claude Code, Claude Desktop or any MCP client with one line. Your AI reads the map, adds and connects components, and applies schemas through the same versioned path as the canvas.

Terminal

$ claude mcp add --transport http docloom https://<your-docloom>/mcp --header "Authorization: Bearer dl_…"

✓ Added MCP server docloom (18 tools)

  • list_projects
  • create_project
  • get_graph
  • add_nodes
  • connect_nodes
  • update_node
  • delete_nodes
  • delete_edges
  • apply_er_schema
  • list_node_kinds
  • get_history
  • list_errors
  • list_tasks
  • create_task
  • update_task
  • get_docs
  • write_doc_section
  • get_doc_changes
What happens on every call
v14

What you get

Everything your architecture needs to stay true.

Live today: a versioned map, ER diagrams from real code, errors pinned to where they happen, tasks synced with GitHub issues, and docs that never drift from the map.

History you can trust, with undo

Every change from you, a repo scan or your AI is saved as a new version with who made it and why. Undo any version in one click, and nothing is ever silently overwritten.

Errors, pinned to the map

Your apps send errors with a project key. DocLoom matches the failing route or the table in the message and marks that node.

Real ER diagrams

Tables, columns, primary and foreign keys, linked column to column. Collapse a table or a whole schema into one node.

Scan a GitHub repo

SQL migrations and routes from Axum, Express, FastAPI, Flask and Next.js become a map. Re-scan anytime: your layout stays.

Docs and map, live together

A section per component, a chapter per repo. Type / to create a task, @ to assign a real teammate, # to link the map. Every edit syncs to every screen.

Tasks that are your GitHub issues

Plan on a board, assign real repo collaborators, pin each task to the part of the map it touches. Edits flow to GitHub and back, live.

Roadmap

One map today. Your whole workflow next.

DocLoom grows in four phases, each built on the same living graph, so nothing you map today is thrown away.

  1. Phase 1Live now

    Architecture maps

    • Versioned map with history and undo
    • ER diagrams from SQL and GitHub
    • MCP server for your AI
    • Errors mapped to nodes
  2. Phase 2Live now

    GitHub project management

    • Tasks two-way synced with GitHub issues
    • Assign real repo collaborators
    • Tasks pinned to the map
    • Shared projects and My tasks
  3. Phase 3Live now

    Living documentation

    • Org → repo → chapter → section
    • / create · @ assign · # link
    • Docs and map stay in sync
  4. Phase 4Next

    Game asset editor

    • Sprite and vector editing
    • 2D animation
    • Unity and Unreal export

Free during early access

Map your system in minutes, not meetings.

Paste a schema, scan a repo or connect your AI, and see your architecture take shape live.

Create your first map →Log in