VisionLayer

AI coding agents now write most of our code, and they write it well. Reading every line is no longer the job. Understanding the system is. VisionLayer reads your repository, without any language model, and shows the system as it actually runs: who can call what, who writes which table, what starts at 3 a.m. Every fact cites its file and line. Then it keeps what your agents knew while they wrote it, and lets you test yourself against the real problems they hit.

The problem

When agents write the code, four things quietly get lost.

Related MCP server: codegraph-ai

What VisionLayer does

Zoom from the whole system down to a single line. Start with what runs and what calls what. Go down level by level, and open the exact code at the end.

Read the algorithm when it matters. A feature is traced in the order the code runs it: the route, the guard, the database read, the write, the message put on a queue. Every step opens its line.

Decide on facts. VisionLayer points to what deserves a look, and says how it found it. What it cannot read is marked not read, never safe.

Keep what agents know. Agents get a short contract: read the map before a task, declare what the code does not say in the pull request. Each note is anchored to the function it explains and re-checked against the code on every change: verified, stale or contradicted. Notes appear right where they explain something, not in a separate wiki.

Give agents the map instead of letting them reread. The same model is served to coding agents over MCP. A feature's full flow costs about 1,250 tokens instead of 6,600 to read the file, and comes with what earlier agents declared.

What it found in a real app

atelier-api is a real Express, Postgres and Stripe application we use as a test bed. VisionLayer reported all of this by reading the code, with no language model involved:

Built with Meta

The map never comes from a model. It comes from technology packs that read the code deterministically, or from what agents declared. Meta's models do what models are good at, inside those limits.

Replays: stay sharp on your own system

The real problems agents ran into in your project become optional, playable challenges. You get the code as it was before the fix, with the failing test. You dig in. Bolt, Vigie's robot face, coaches you with questions and three graded hints, from vague to precise, without ever giving the answer. Once your tests pass, you compare your fix with the agent's, side by side, with no winner: each one shows what the other saw or missed. If yours catches a case the agent's missed, propose it to the project.

These are not made-up exercises. On atelier-api, the first Replay is a race between a scheduled job and a Stripe webhook: a booking paid for, then cancelled by the job that ran a moment before.

Status

VisionLayer is being built in the open during the hackathon. This section says what runs today and what does not yet.

Screenshots will be added once each part runs for real.

How it works

flowchart LR
  A[Your repository] -->|tree-sitter| B[Fact base]
  P[Technology packs<br/>Express, Drizzle, BullMQ,<br/>node-cron, Stripe, Fly...] --> C
  B --> C[Rule engine]
  C --> D[Neutral system model]
  K[Notes declared by agents<br/>in their pull requests] --> D
  D --> E[Screens]
  D --> F[MCP server<br/>for coding agents]
  D --> G[Vigie<br/>Meta Muse]
  M[Pack writer<br/>Meta Muse] -.->|validated, then hot-loaded| P

• Facts, not guesses. tree-sitter parses TypeScript and JavaScript into facts. Packs, written in YAML, encode the documented behaviour of one technology each, and are tested form by form.

• One model for every stack. The rules assemble a stack-neutral model: deployable blocks, entry points, flows across functions, access guards, data reads and writes, findings and coverage.

• Honest about gaps. Anything not read is shown as not read. A technology without a pack is shown as no pack, which is exactly what the pack writer fixes.

• Local first. Nothing leaves your machine, except a question to Vigie and the excerpts it cites. With an open model, nothing leaves at all.

Quick start

git clone https://github.com/mouhamedsylla/visionlayer && cd visionlayer
pnpm install

Read the bundled example, then your own project:

pnpm facts tests/corpus/atelier-api

pnpm ui /path/to/your/project

pnpm ui serves the map API on http://127.0.0.1:4173; the new interface is being built. Run the tests with pnpm test.

Connect your coding agents

Give them the map over MCP, by adding this server to your agent's configuration:

{ "mcpServers": { "visionlayer": { "command": "pnpm", "args": ["--dir", "/path/to/visionlayer", "mcp"] } } }

The tools are vision_summary, vision_slice, vision_reach and vision_source.

Built before and during the hackathon

VisionLayer is built for the Meta AI Developer Hackathon, Startup track, on top of an engine that existed before it. The first commit of this repository is that engine, as it stood on October 26, 2026. Everything after it was built during the hackathon.

What it is not

• Not an agent. It never writes your code, never launches an agent, never merges anything.

• Not a line-by-line reviewer. It shows where to look; review stays yours.

• Not generated documentation. Generated docs go stale and can lie. Here, everything is read or declared, then checked.

Limits, honestly

• One stack covered, not every stack. TypeScript and JavaScript; Express, Drizzle and Postgres, BullMQ, node-cron, Stripe, Docker, Fly. Elsewhere VisionLayer says no pack.

• The code, not production. It reads what code and configuration declare. What actually ran is not read.

Repository

cli/            command-line entry points: ui, scan, inspect, context, knowledge, hook, mcp
vision/         the engine: parsers, fact base, packs, rules, neutral model, knowledge, web server
integrations/   the MCP server for coding agents
tests/          tests, fixtures, and atelier-api, the example application
docs/           how VisionLayer works, decisions (ADRs), how to read each view (in French)

License

Apache 2.0. Built in Dakar by RYPHA.