# Why I Built the "Infrastructure Layer" Under Every AI Coding Agents

> Source: <https://dev.to/rakshit_a1b3556ad931a31ee/why-i-built-the-infrastructure-layer-under-every-ai-coding-agents-2kci>
> Published: 2026-05-27 07:11:38+00:00

AI coding agents are getting very good at editing files, running tests, and opening PRs.

After heavily using tools like Cursor, Claude Code, and GitHub Copilot, I noticed they all share the same core limitation:

They have no persistent understanding of your system.

Ask the same question next week and they:

So instead of building another coding agent, I built the layer underneath them.

ASIL (**Engineering Intelligence Infrastructure**) is a persistent, temporal, causal knowledge graph for software systems.

It connects:

into one queryable system that any AI agent can access through MCP.

The goal is simple:

Stop making AI agents rediscover the same engineering knowledge over and over again.

Most coding agents understand:

ASIL understands:

Instead of:

“GPT thinks this caused the outage”

ASIL derives causal chains from observable system state:

Every conclusion includes:

No black-box “AI intuition.”

```
uv run asil ask "How does auth work in this repo?"
```

ASIL combines:

to return:

```
uv run asil replay INC-2026-04-12
```

ASIL reconstructs:

as a dependency-aware replay graph.

Think:

Time-travel debugging for distributed systems.

```
uv run asil drift report
```

ASIL learns expected dependency boundaries and flags:

before the PR merges.

ASIL exposes 13 MCP tools usable from:

The agents become clients of the intelligence layer.

ASIL stores every verified engineering conclusion in persistent memory.

When someone asks a semantically similar question later, ASIL can reuse the prior verified reasoning instead of re-running the full LLM pipeline.

On cache hits, the cost drops close to:

just the embedding lookup

Repeated engineering queries become dramatically cheaper over time — especially across teams.

ASIL does **not** let the LLM invent causality.

That rule shapes the entire architecture.

Causal links come from deterministic signals:

The LLM consumes evidence.

It does not fabricate it.

That distinction matters once AI systems start participating in production engineering workflows.

Everything runs locally:

No central server.

No telemetry.

Your graph stays yours.

The only optional network dependency is the reasoning LLM.

Most AI tooling is racing toward:

“make the agent better at editing code”

I think the more important problem is:

“give agents persistent engineering intelligence”

That means:

That’s the layer ASIL is trying to build.

Built solo over 6 months with:

Python, FastAPI, Neo4j, Qdrant, Postgres, Tree-sitter, Next.js, Tailwind, ReactFlow, and MCP tooling.