Live semantic architecture

Architecture is
all you need.

The deterministic source of truth for your code, infrastructure, and runtime. Query it, assert policies against it, and give your AI agents grounded context instead of guesses.

Open source · Apache 2.0 · brings in your OpenTelemetry
api-gateway service-a service-b redis payments-db
Compatibility

It speaks your stack.

npx neat.is wires deterministic instrumentation for the frameworks and stores you already run. Anything else can point an OpenTelemetry exporter at NEAT and land in the same graph. Here are a few:

JavaScript
Next.js Node.js NestJS Express SvelteKit Astro
Databases
PostgreSQL MySQL Redis Cassandra
Python
FastAPI
Cloud
AWS

Static extraction reads JavaScript, TypeScript, and Python via tree-sitter. Runtime ingest is plain OTLP (HTTP on :4318, gRPC on :4317), so any service with an OpenTelemetry SDK lands in the same graph.

Why NEAT

Every tool you have describes the system after it breaks: logs, dashboards, alerts. None of them hold a model of how the whole thing actually fits together. NEAT keeps that model live, fused from your code and your runtime at once, so your agents work from grounded truth and the answer is there before the incident is.

The graph

Architect the system you have, before you change it.

Most tools start with the change. NEAT starts with the architecture. One command builds a live, deterministic model of your code, your infrastructure, and your runtime: what every service owns, what it calls, what calls it, and what breaks when it fails.

view on GitHub
api-gateway service-a service-b redis payments-db
Blast radius

Blast radius as a first-class query.

Most systems only see failure after it happens. NEAT makes blast radius a question the architecture answers. get_blast_radius() walks the live edges and returns everything downstream, scored by cascaded confidence. Run it before a deploy, an upgrade, or an agent.

Provenance

Declared intent and observed reality, side by side.

Code says one thing, production does another, and NEAT models both. Every edge is tagged extracted, observed, inferred, or stale. When the two streams disagree, that's a divergence, ranked by impact.

api-gateway service-a service-b redis payments-db
extracted observed divergence
Agents

Agents that know, not guess.

An agent reading raw files is guessing. An agent against a live architecture knows. NEAT exposes the whole model over sixteen MCP tools, from root cause and blast radius to dependencies, divergences, incidents, policies, and semantic search, all refreshed on every save and every span. An agent can check a change against your policies before it writes the code.

see the MCP tools
How it works

One command. Three layers of truth.

NEAT builds the model from what you wrote and keeps it honest with what's running. The gap between the two is the finding.

01

Extract

Tree-sitter reads your JavaScript, TypeScript, and Python, pulling out services, calls, schemas, config, and IaC, then lays down the declared graph.

provenance: extracted
02

Observe

OpenTelemetry spans stream in over OTLP. NEAT matches live traffic to the graph and marks what it actually sees running.

provenance: observed
03

Query

Ask the graph anything over MCP or HTTP: blast radius, dependencies, divergences, root cause. It refreshes on every save and every span.

provenance: inferred · stale
GitHub stars
40+
integrations instrumented
3
languages statically extracted
Apache 2.0
open source
Design partners

Get early access to hosted NEAT.

NEAT runs single-tenant today: npx neat.is on your machine or your own box. Hosted, multi-tenant NEAT is coming. Design partners get it first, and shape what it becomes.

No spam. We'll only reach out about your early access.

Thanks, you're on the list. We'll be in touch from deniz@neat.is.

Architecture is
all you need.