architecture, read from the code

Your whole system.One living map.

See what a change breaks in your other repos, before you push. ArchSync reads every repo — apps, APIs, microservices, functions, databases, caches — and keeps one map of how they really connect, so you can hold the architecture to its rules, onboard people in minutes, and give your AI agents facts instead of guesses.

Open the canvas $ npx archsync scan

No repo linked. Runs on your machine.

drag to rotate · double-click to reset
11
languages read
JS/TS, Python, Go, Java, Kotlin, Dart, Swift, C#, PHP, Ruby, Rust
37,825
files benchmarked, 0 crashes
39 open-source and sample repos
280 / 313
cross-repo calls matched
to the backend route that answers them, in two production products
24
real breaks caught
e.g. an admin panel sending PATCH where the backend expects PUT
01 one map, many jobs

Architecture you can see, check and hand over.

Diagrams go stale the week they’re drawn. ArchSync rebuilds the map from the code on every scan, so everything built on it — reviews, onboarding, agents — works from what’s actually there.

01

Map the whole system

Every repo as a frame, every call between them as a line — from screen to route to controller to service to table.

archsync scan --workspace
02

Catch breaking changes

Rename a route, drop a field, move an endpoint: see every caller in every other repo it breaks, before the push.

archsync diff --merged
03

Hold the line on design

Circular dependencies and contract violations fail the build, so the architecture doesn’t drift one PR at a time.

archsync validate --strict
04

Explain any part

What a service does, who calls it, what it touches and what breaks if it changes — in plain English, with file and line.

archsync explain OrderService
05

Ground your AI agents

Claude Code, Cursor and Windsurf ask ArchSync over MCP before they write, and get real entities instead of inventing them.

archsync mcp
06

Keep the team in sync

Push the map to your own database; the whole team sees the same live canvas, and watch mode keeps it current as you code.

archsync push · watch
02 try the canvas

Click around. It’s the real interaction.

A small made-up shop: a web app, a mobile app, an API and an orders service. Click a row to read its code; every line that calls into another file or repo has a link, and the arrow leaves from that exact line. Search, pan, zoom, switch the theme.

shop · 4 repos
web-appReact
pages
api calls
mobile-appFlutter
screens
api calls
apiExpress
routes
middleware
controllers
orders-serviceGo
services
functions
data
Click any row to open its code. Drag to pan · Ctrl/⌘ + scroll to zoomTap a row to open its code · + / − to zoom
60%
Repos as frames

Screens → logic → API calls on the client; routes → middleware → controllers → services → data on the server. Big areas fold into groups.

Code where you clicked

On your own project, the code card reads the file live from your disk with archsync serve, or shows the snippet from the last scan.

Line-level arrows

A call on line 10 of the mobile app points at the API route that answers it — and from there to the service, the database and the cache.

03 how it works

Three commands. Nothing leaves your laptop until you say so.

scan

Read every repo

Routes, screens, controllers, services, models, middleware and the calls between them — JS/TS, Python, Go, Java, Kotlin, Dart and more. No annotations.

$ archsync scan --workspace
  📁 api          express  → system backend
  📁 mobile-app   flutter  → system mobile-app
  📁 web-app      react    → system web-app

  Cross-system:       10
  mobile-app:GET /v1/orders/${id}
    → backend:GET /v1/orders/:id
check

See what a change touches

Move /v1/orders to /v2/orders in the API and scan again. This is the real output:

$ archsync scan --workspace

─── Broken cross-system calls (6) ───
  ✖ mobile-app: GET /v1/orders/${id}
  ✖ mobile-app: POST /v1/orders
  ✖ web-app: GET /v1/orders
  ✖ web-app: GET /v1/orders/${id}
  … 2 more
push

Share it with the team

Push the schema — metadata, never source — to your own Supabase. Everyone gets the same live canvas, and so do your coding agents.

$ archsync push
  ✓ backend     pushed
  ✓ mobile-app  pushed
  ✓ web-app     pushed
  → your-project.supabase.co
04 for coding agents

Context your agent can’t make up.

Claude Code, Cursor and Windsurf connect to ArchSync over MCP. Before writing code, the agent asks which repos a task touches and gets back real entities with file and line. When the map has a gap, it says so — and the agent asks you instead of inventing.

No more pasting ten files into a prompt. The MCP server runs in your own Supabase, and agents see only the projects you can see.

agent·web-appexample session
add discount codes to checkout
⏺ archsync · prepare_task
web-app CheckoutPage — src/pages/CheckoutPage.jsx:12
api POST /v1/orders — src/routes/orders.js:7
api OrdersController.create — src/controllers/orders.js:14
orders-service OrderService.total — internal/order/service.go:58
orders-service orders table · total, status
also affects: mobile-app CartScreen (posts to /v1/orders)
The total is computed in OrderService and cached for 5 minutes. Should a discount clear that cache?
05 where it started

Every new codebase starts with the same three weeks.

You open the repo: hundreds of files, a few services, a queue nobody mentioned. The person who knows how it fits together is busy. So you wait for a KT session, take notes, and still miss the cache that gets cleared somewhere else.

Now every team has a second newcomer: the AI agent. It reads the files you paste and confidently fills in the rest — a controller that doesn’t exist, an endpoint from the wrong repo.

ArchSync closes that gap with one honest map of how the code connects — for people who are new to it, and for agents, which are always new to it.

#onboarding
S
Samjoined Monday · 10:12
where does an order actually get charged? I can see OrdersController but not the payment part
P
Priyatech lead · 13:40
it’s split — controller → OrderService in orders-service, then a function charges the card. oh, and the cache… let’s do a KT call tomorrow
AI
agentin Sam’s editor · 14:05
Added refundOrder() to PaymentController and wired it to /v1/refunds.
S
Samjoined Monday · 14:06
…there is no PaymentController. or /v1/refunds.
06 what it reads

What goes into the map.

entry pointsHTTP routes and their prefixes, and the middleware that guards them — plus OpenAPI and GraphQL definitions you import
logicControllers, handlers, services, repositories, serverless functions, triggers and workers
dataModels and their fields — Mongoose, Prisma, Sequelize, TypeScript types and classes, Firestore collections
clientsScreens, pages, components, and every HTTP call they make — matched to the route that answers it, across repos
languagesJavaScript / TypeScript, Python, Go, Java, Kotlin, Dart, Swift, C#, PHP, Ruby, Rust
gapsWhen a link can’t be seen in the code, it’s shown as a gap — never guessed
07 where your data goes

Every command, and what it sends.

commandwhat leaves your machinewhere to
archsync scanNothing. It reads files and writes .archsync-schema.json next to them.nowhere
archsync serveLines of a scanned file, only to a canvas on your own machine. Bound to 127.0.0.1, read-only, scanned files only.localhost
archsync pushThe schema: names, routes, file paths, line numbers, short snippets. Never whole files.your Supabase
archsync embedShort text cards about each entity, for meaning-based search — with your own key.Voyage AI · optional
08 why this exists

For years, the slowest part of my work wasn’t writing code. It was understanding code someone else had written. Every new codebase meant weeks of reading, guessing which module talked to which, and waiting for someone to find time for a proper KT.

Then AI agents arrived, and the same problem came back in a new form: unless I gave them exactly the right context, they hallucinated — or quietly missed the one service that mattered.

ArchSync is the tool I wanted on day one: it reads the code, draws how everything connects across repos, and hands the same map to the people and the agents who need it. When it doesn’t know something, it says so.

Vivekbuilding ArchSync

Know your system before you change it.

Five minutes from install to your first cross-repo map — for you, your team and your agents. No account needed to scan.

$ npx archsync scanOpen the canvas Read the docs