The Cursor architecture stack: Graphify and Archify

Use this stack as a page: the Cursor architecture stack.

A coding agent that can edit files still greps. That is fine for a 400-line module. It is how you get a “looks fine” patch that never saw the caller three packages away. The missing piece is not a smarter model. It is a map.

The stack that stuck for mapping a repo in Cursor is three tools with three jobs:

1. Cursor — the editor you live in.
2. Graphify — the graph you ask before the agent greps blindly.
3. Archify — the diagram that survives a PR review.

One chatbot drawing boxes in Markdown is how you get a picture nobody trusts. This post is the walkthrough we actually use: one change, one map, three handoffs.

Why a chat window is not a map

Cursor indexes the project and edits in place. That is the inner loop. It does not, by itself, tell you what still depends on the symbol you are about to rename.

You paste a stack trace. The agent rewrites a function. The types match in that file. A worker in another package still calls the old shape. You find out in CI.

What changed is that the surface for “what is this system?” moved onto the repo:

• Graphify builds a queryable graph of the code you have, not a slide of the code you wish you had.
• Archify takes typed JSON from the agent and compiles it to HTML/SVG with fail-closed validation — a picture that is allowed to refuse a bad IR.

The model is still whatever Cursor is running. The stack is what stops you from treating the model like a whiteboard generator.

The three roles (and what each must not do)

Cursor owns the inner loop

Cursor is the host. Open the ticket, stay on one branch, accept or reject hunks while you can still see the surrounding code. Do not ask Cursor to be the diagramming tool.

Graphify owns “what calls this”

Graphify is the code graph. Ask it what depends on the module you are about to change before the agent starts rewriting. Do not ask Graphify to draw the company org chart. Do not skip it because the agent “already indexed” the repo — indexing is not a blast-radius query.

Archify owns the map you can paste

Archify is an agent skill. The agent writes a small typed JSON IR; Archify compiles it. Use it for the path you just changed, not the whole company. Paste the HTML/SVG on the PR. Compare it with Napkin if you need a marketing visual — that is a different job. See Archify vs Napkin.

One change, four steps

1. Open the repo in Cursor. Stay on one branch.
2. Index with Graphify and ask what calls the module you are about to change.
3. Ask Archify for a high-level runtime map of that path.
4. Paste the map on the PR. Keep Cursor as the editor.

If you want the install lines and host list, they live on the Archify and Graphify tool pages, and on the Cursor add-ons hub.

What this stack is not

It is not “Cursor can do architecture now.” Cursor writes. Graphify answers. Archify ships the map. If you collapse those jobs into one chat, you are back to a picture nobody will merge.