Introducing Infinite Docs

The False Choice

Existing tools force a choice no one should have to make. You can have the picture or you can have the detail, but not both — and neither talks to an LLM.

Infinite Docs collapses that choice. The spatial graph and the written detail live in the same artifact, and that artifact is built from the ground up to be read — and written — by AI agents.

The Core Model: Components, Connections, and Descent

You work on a Canvas. You add Components from a searchable, affinity-ranked palette of 26 kinds — everything from a generic box down to a host, a database, a service, a function, or a single table. You drag them around, rename them inline, and draw Connections between them. Every Component carries its own markdown documentation, edited in a WYSIWYG editor that autosaves as you type.

That last point is the quiet superpower. When the only durable thing is the graph itself, “the diagram is out of date” stops being a category of problem.

Descend to Any Depth — Without Losing Context

Double-click a Component and you descend into its interior Canvas. The breadcrumb trail tracks exactly where you are, and you can keep going — infrastructure, to the app inside it, to the modules inside that, to a single table — as deep as the system goes.

The hard part of nested diagrams has always been context loss: the moment you drill into a box, you lose sight of what it talks to on the outside. Infinite Docs solves this with boundary proxies. When a Connection crosses the edge of the Canvas you're looking at, the far end follows you inward as a read-only stand-in, so a dependency's other side stays visible without you ever leaving the scope you're documenting.

Here we've descended into Vercel Edge. The breadcrumb shows the path; the solid Next.js App node has its own interior (note the descent badge); and Neon Postgres appears as a dashed, read-only boundary proxy— it lives a level up, but because the interior connects out to it, its far end rides along so you never lose the thread.

Built for Agents, Not Just People

This is where Infinite Docs stops being “a nicer diagram tool” and becomes something new. The entire graph serializes to deterministic markdown— byte-stable output with stable {#nodeId} anchors — so an LLM can read your architecture as text and an agent can reference any Component by anchor. There's a “Copy as markdown” button right on the toolbar.

Better still, an authenticated MCP server lets AI agents read and maintain the architecture as they work on the actual system it describes. You mint an API token on the Connect an agent page, paste one snippet, and your agent of choice — Claude Code, Codex, Cursor, and friends — is pointed at your graph.

Over that connection, agents get read resources and write tools over the same graph you edit by hand:

# Read resources
architecture://index/{projectId}      # structural map: titles, kinds, anchors
architecture://project/{projectId}    # full graph with markdown docs
architecture://subtree/{projectId}/{nodeId}
architecture://trace/{traceId}

# Write tools
create_component / move_component / update_component_docs
create_connection / update_edge_interaction / delete_connection
apply_graph   # batch create/update components + connections in one call
apply_spec    # parse an OpenAPI or SQL-DDL spec and sync the graph

Spec Import & Traces

Under the Hood

Two front doors — a web app for people and an MCP server for agents — sound like two codebases worth of authorization bugs. They're not, because both are thin adapters over a single service layer with one signature:

// Every piece of business logic lives here, and nowhere else:
(db, actor, input) => result

// tRPC adapter (web)        MCP adapter (agents)
//   resolve actor              resolve actor from API token
//   call the service     -->   call the SAME service
//   map errors to tRPC         map errors to MCP

// One authorization seam. A human and an agent that act
// as the same owner get identical reads, writes, and refusals.

Three levels into the dogfood graph above, you can see the shape of it: the tRPC API and the MCP Server sit side by side as front doors, with llms.txt and auth beside them, all resolving down to the same database. The picture the tool draws of itself is its architecture.

What Works Today

Infinite Docs shipped its full initial roadmap — six milestones from the data model and service layer through nested canvases, markdown export, boundary proxies, the MCP server, and typed cross-scope connections — and has grown well past it since.

Every edit is optimistic: it appears instantly and persists in the background, with rollback and a toast if anything fails. And the whole time, an agent can be reading and maintaining the same graph over MCP.