Architecture that stays in sync with your code
Describe a system in plain English and refine it on a live canvas. Your coding agent keeps the diagram in sync through MCP. Export a spec you'd commit to the repo.
Free plan, no card required — starts with 14 days of full Pro.
The canvas, exactly as you'll use it
Teammates, the AI agent, and your coding agent over MCP — all editing the same graph.
Two engineers on one canvas — live cursors, presence, and autosave.
Collaborate. Two engineers on one canvas — live cursors, presence, and autosave.
From plain English to a diagram your agent maintains
Generate a diagram from a description, refine it with your team, and give your coding agent a scoped token to keep it current.
Your coding agent edits the diagram
Claude Code, Cursor, or any client that speaks the Model Context Protocol reads your architecture and writes changes back to it — so the diagram is a thing you maintain by working, rather than a wiki page that goes stale. Access is a scoped token you mint, and revoke.
10 tools in all — read on every plan, write on Pro, or $4/mo on its own. Tokens scope to chosen projects and carry an expiry.
See how to connectDescribe it; the agent draws it
Describe your system in plain English, and cancel a run whenever you like. The agent decides the components and how they connect; a deterministic layout engine places them — so you get a readable diagram, not a tangle.
Two architects, one board
Live cursors, presence, and shared undo — plus a distinct cursor for the AI so you can watch it build. Invite teammates by email: 3 per project on Free, 9 on Pro.
Canvas out as Markdown
Generate a Markdown spec from the canvas — overview, architecture, components, data flow, technology stack, design decisions — then download it into the repo.
Drag it; everyone sees it
Drag nodes, draw edges, reroute connections — every change lands for everyone in the room, undo and redo included, and the whole board autosaves as you work.
Start from a working diagram
Open a working microservices, CI/CD pipeline, or event-driven diagram and edit from there instead of from an empty canvas.
Six shapes, eight identities, real containers
Six shapes and eight color identities, plus containers that group a subsystem — so the diagram encodes structure rather than just boxes.
One canvas, from the first sentence you type to the spec you commit.
Start for freeConnect your coding agent
Loftline runs a Model Context Protocol (MCP) server. Claude Code, Cursor, or any MCP client reads the live graph, then writes changes back. The server reaches your diagram and never your repository; your agent is the only thing that sees both.
Every token
- Read-only, or read and write — you choose per token
- Scoped to the projects you choose
- Expiry from 30 days or never, revocable at any time
- 60 requests a minute
Your codebase
where the agent works
Claude Code / Cursor
any MCP client
Solid is a sync call. Dotted is a logical relationship, not an MCP link.
- 01
Mint a scoped token
In the editor, open Settings → MCP. Choose which projects the token can reach, how long it lasts, and whether it may write. Copy it once — tokens are stored hashed and never shown again.
- 02
Add the server
Run the connect command. Any client that speaks Streamable HTTP with a bearer header works — Claude Code, Cursor, or your own. Configuring one by hand takes three values: the endpoint https://loftline.dev/api/mcp, transport http, and the header Authorization: Bearer YOUR_TOKEN.
claude mcp add --transport http loftline https://loftline.dev/ api/ mcp --header "Authorization: Bearer YOUR_TOKEN" Replace the marked YOUR_TOKEN with the token from step 1. If a call comes back 401, that placeholder is still in place: run
claude mcp remove loftlineand add it again. - 03
Your agent reads and writes
It calls get_architecture to see the live graph, then add_node and add_edge to change it. You never send coordinates: Loftline computes the layout, so a diagram an agent wrote is still one a person can read.
Read — every plan
list_projectsList the projects this token can reach, and your role on each.
get_architectureRead a project's live nodes, containers, and edges.
Write — Pro, or $4/mo on its own
A write token reaches only the projects you scoped it to, and you can revoke it at any time — those two are the controls. Within that scope an agent can delete nodes, edges and containers as well as add them. Its edit lands live for everyone in the room, and unlike a person's it is not in anyone's undo stack.
8 tools over nodes, edges and containers
nodes
add_nodeAdd a node. Logical fields only — position is computed for you.
update_nodeChange a node's label, shape, color, or container membership.
delete_nodeDelete a node, and any edges connected to it.
edges
add_edgeConnect two nodes or containers — solid, dashed, or dotted.
delete_edgeDelete an edge by id.
containers
add_containerGroup a logical module into a labeled container.
update_containerChange a container's label or color.
delete_containerUngroup a container — its nodes survive as top-level nodes.
Start with a read-only token. No JSON config, no OAuth.
A diagram that survives the next hundred commits
Describe a system once. After that your coding agent writes changes back through the Model Context Protocol, so the diagram and the spec keep describing what you actually shipped.
Describe the system
Type your architecture in plain English — services, databases, and how they connect.
Checkout service with Stripe and Postgres
It arrives as a real graph
Nodes and edges land on the canvas as the agent maps your system, placed by a deterministic layout engine.
The spec falls out of the graph
A Markdown technical specification, generated from the canvas and ready for the repo — regenerated whenever the graph changes, not exported once.
## Overview
## Architecture
## Components
## Data Flow
## Technology Stack
## Design Decisions
Your agent keeps it true
As you ship, your coding agent writes the change back through MCP — the Model Context Protocol — using a token you scope and can revoke. The graph above updates itself and the spec regenerates from it. Nothing gets re-typed.
A hundred commits later, the diagram still describes the system you actually shipped.
Free to design. Paid to stay in sync.
Every plan starts on the same canvas. Pro is the one your coding agent can write back to.
Annual billing. Free: $0 per month. Includes 14 days of full Pro, no card required. Pro: $9.58 per month. Billed annually at $115 — save 20%.
Free
Design a system and try living sync — free forever.
Includes 14 days of full Pro, no card required
No card required.
MCP read access
Your agent can read the canvas, but not change it. How MCP write access works
- Projects
- 15
- Canvas storageacross all projects
- 10 MB
- AI tokensper month
- 50,000
- Collaboratorsper project
- 3
- Included:All 3 starter templates
- Included:Real-time collaboration
Pro
Living architectureLet your coding agent keep every diagram in sync — living architecture.
Billed annually at $115 — save 20%.
14-day free trial. No card required. Cancel anytime.
MCP read and write access
Claude Code and Cursor edit the canvas as the code changes. How MCP write access works
- Projects
- 50
- Canvas storageacross all projects
- 40 MB
- AI tokensper month
- 500,000
- Collaboratorsper project
- 9
- Included:All 3 starter templates
- Included:Real-time collaboration
Every figure above comes from the same limits the app enforces.
What happens when I hit a limit?Questions, answered
Everything a technical evaluation usually has to email someone to find out.
Start with 14 days of ProHow it works
A collaborative workspace for system design. You describe a system in plain English, an AI agent maps it onto a shared canvas, your team refines it together in real time, and you export a technical specification as Markdown. Your coding agent can then keep the diagram in step with the code through MCP.
Loftline exposes your architecture as a structured graph through an MCP server. You mint a personal access token — scopeable to chosen projects, and set to expire in 90 days unless you change it — and connect Claude Code, Cursor, or any MCP client to it. The agent then calls tools to read the graph and add or update nodes, edges, and containers, so the diagram reflects what you are actually building. Read access is on every plan; write access is included in Pro, or $4/mo on its own.
Describe your system — services, databases, connections — and Loftline runs it as a background job you can watch and cancel at any point. The model decides the components and how they connect; a deterministic layout engine then positions everything, so you get a readable diagram rather than a tangle. You can also expand any single node into its own subsystem.
A Markdown document generated from your canvas with six sections: Overview, Architecture, Components, Data Flow, Technology Stack, and Design Decisions. Generation runs in the background; when it finishes you can read it in the app and download the .md file straight into your repo.
Yes. Live cursors, presence, and shared undo and redo, with every change syncing to everyone in the room and autosaving as you work. You invite teammates by email. Free projects support up to 3 collaborators; Pro supports up to 9.
Your work & your data
The people you invite to a project, and any MCP token you mint. A new token defaults to read-only access across all your projects and expires in 90 days — you can narrow it to specific projects when you create it, and revoke it at any time from the editor's settings. Write access is a separate entitlement a token only gets if your plan includes it.
Yes. The technical specification downloads as a plain Markdown file you can commit straight to your repo, and the same MCP server your agent reads the graph through is available to you — nodes, edges, and containers as structured data, not a proprietary export. Nothing about leaving requires asking us first.
Plans & limits
Yes. The Free plan is $0/month with 15 projects, 10 MB of canvas storage, 50,000 AI tokens a month, 3 collaborators per project, and MCP read access. Pro is $12/month or $115/year and adds MCP write access, 50 projects, 40 MB of storage, 500,000 AI tokens a month, and 9 collaborators. Every new account starts with 14 days of full Pro, and no card is required to sign up.
Nothing is deleted and nothing breaks — the action that would exceed the limit is blocked and tells you which limit you reached. You can upgrade to Pro, buy just the capability you need à la carte, or top up AI tokens and canvas storage with one-off packs.
They stay exactly where they are. Dropping to Free lowers the caps, it does not delete anything you already made — if you finished the trial with more than 15 projects, all of them keep opening, and it is creating the next one that is blocked until you are back under the limit. The same applies to canvas storage and collaborators.