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.
No repo linked. Runs on your machine.
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.
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 --workspaceCatch 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 --mergedHold 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 --strictExplain 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 OrderServiceGround your AI agents
Claude Code, Cursor and Windsurf ask ArchSync over MCP before they write, and get real entities instead of inventing them.
archsync mcpKeep 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 · watchClick 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.
Screens → logic → API calls on the client; routes → middleware → controllers → services → data on the server. Big areas fold into groups.
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.
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.
Three commands. Nothing leaves your laptop until you say so.
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
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
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
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.
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)
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.
OrdersController but not the payment partOrderService in orders-service, then a function charges the card. oh, and the cache… let’s do a KT call tomorrowrefundOrder() to PaymentController and wired it to /v1/refunds.PaymentController. or /v1/refunds.What goes into the map.
| entry points | HTTP routes and their prefixes, and the middleware that guards them — plus OpenAPI and GraphQL definitions you import |
| logic | Controllers, handlers, services, repositories, serverless functions, triggers and workers |
| data | Models and their fields — Mongoose, Prisma, Sequelize, TypeScript types and classes, Firestore collections |
| clients | Screens, pages, components, and every HTTP call they make — matched to the route that answers it, across repos |
| languages | JavaScript / TypeScript, Python, Go, Java, Kotlin, Dart, Swift, C#, PHP, Ruby, Rust |
| gaps | When a link can’t be seen in the code, it’s shown as a gap — never guessed |
Every command, and what it sends.
| command | what leaves your machine | where to |
|---|---|---|
| archsync scan | Nothing. It reads files and writes .archsync-schema.json next to them. | nowhere |
| archsync serve | Lines 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 push | The schema: names, routes, file paths, line numbers, short snippets. Never whole files. | your Supabase |
| archsync embed | Short text cards about each entity, for meaning-based search — with your own key. | Voyage AI · optional |
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.
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.