Architecture is the first decision. Everything else follows from it.
The best engineering teams think in systems before they think in code. They design the relationships between things — the data flows, the ownership boundaries, the failure surfaces — before a single line is written. Architecture first.
Software tooling has never reflected this. It was built to manage code after it exists, not to reason about structure while it's being designed. AI made this worse: models that infer architecture from raw files, agents that guess at dependencies, tools that treat your system as text to be processed rather than a structure to be understood.
NEAT starts from the architecture. A live semantic graph of your whole stack — code, infrastructure, runtime — that your tools and agents operate against directly. Not a diagram. Not a dashboard. A queryable model of how your system actually works.
What this
looks like
Before NEAT generates a single line of IaC, it models the node. What does this service own. What does it call. What calls it. What breaks if it fails. The architecture is the spec — code and infrastructure emit from it, not the other way around.
Most systems only understand failure after it happens. NEAT makes blast radius queryable at design time. Before a deploy, before a refactor, before a dependency is added — get_blast_radius() runs against the live graph and tells you exactly what's at risk.
Infrastructure as Code drifts because it lives outside the system it describes. NEAT generates IaC from the graph and detects drift bidirectionally. If Terraform is edited outside NEAT, the graph flags it. The architecture is always the source of truth.
An agent that infers architecture from raw files is guessing. An agent running against a live semantic graph knows. NEAT gives agents structural tools over a model that updates on every file save — so autonomous remediation, policy enforcement, and code generation work from ground truth, not inference.
What we're
building
Built from static code analysis and live runtime telemetry. Not a diagram. Not a dashboard. Every service, database, data flow, and dependency — updated on every file save, queryable at any point in time.
A language built specifically for the graph. Query it, assert policies against it, script traversals across it. Feels like TypeScript. Thinks like Cypher. Runs in Rust. Scripts live in your repo alongside your code.
Every production error is linked to the graph node that caused it, with the full execution history attached. Replay any failure in isolation. Test a fix against the original trace before it ships. No more root-causing from log lines.
The CLI exposes the graph as an MCP server. Agents get real structural tools: get_blast_radius(), get_dependencies(), query_graph(), get_incident_history(). No more asking a model to infer your architecture from raw files.
neat-lang and neat-core are open. The graph engine and NeatScript runtime are the foundation. Built in Rust. Extend them, embed them, build on top of them.