Engineering intelligence layer

The bottleneck is understanding, not writing.

Enola. builds a deterministic map of your codebase so every developer and AI agent can answer architectural questions — not by searching, but by knowing.

View on GitHub

Protocol · MCP License · Apache 2.0

without enola.

~219K tokens · 68s

$ claude "Where is auth applied?"
→ list_files src/                  2.1K tokens
→ read src/middleware/auth.ts      4.7K tokens
→ read src/server/index.ts         6.2K tokens
→ grep -r "requireAuth" .          8.4K tokens
→ read src/routes/api/users.ts     5.1K tokens
→ read src/routes/api/billing.ts   6.8K tokens
→ … 64 more tool calls

with enola.

~5K tokens · 5s

$ claude "Where is auth applied?"
→ enola.snapshot(scope=auth)     ~5K tokens
✓ Auth applied at src/middleware/auth.ts
  mounted by src/server/index.ts:42
  wraps 47 routes across 6 modules
  bypassed by 3 public endpoints
→ 14 scoped lookups — all served from the map

14 languages Go· TypeScript· Python· Java· Kotlin· Swift· Ruby· Rust· C / C++· PHP· Vue· Svelte· OpenAPI

Every team raises these questions

01What else does this affect?
02Can we safely deploy this?
03Does our vulnerable code even get reached?
04Can we safely delete this module?
05What should we refactor next?
06Will this deployment introduce architectural drift?

Every feature, refactoring, dependency update, or security fix raises these questions. Neither developers of large codebases nor AI agents can answer them deterministically — so they assume. And assumptions at speed lead to regressions.

The faster code is produced, the more critical it becomes to have continuous, deterministic architectural guidance.

That's why we built enola.

Pick your path

Start free. Scale when the team does.

Every tier runs fully local — your code and graph never leave your infrastructure.

Open source

Free, forever

Self-hosted, Apache 2.0. No data leaves your machine.

Deterministic architecture graph, 14+ languages
MCP server for any agent — Claude Code, Cursor, Copilot
Snapshot and explore a repo down to the exact symbol, and how things connect
Pre-computed findings and change impact, instead of re-deriving them by hand
Pin a baseline, see exactly what changed, and know when your change is safe to merge
Community support on GitHub

Up in three steps. One binary, one config file, one prompt. Works with any MCP-compatible agent out of the box.

View on GitHub

Pro Coming soon

Per seat, more tools

Advanced analyzers for teams that need deeper risk signal before a change ships.

Everything in open source
package_metrics — spot fragile packages before a rewrite
find_orphans — delete dead code to keep codebase healthy
analyze_performance — catch slow code before it ships
validate_architecture_change — ensure that changes are safe and guide agents to refactor
Priority email support

Get notified

Enterprise

For larger teams

Multiple seats, starting from 10. Everything in Pro, plus what it takes to roll this out safely at scale.

Direct Slack access to the team building enola.
Hands-on onboarding and tuning for your codebase
Custom framework and language support

Book a 20-min call — pilot on your repo within a day.

The solution

A Staff Engineer alongside every developer and AI agent.

A parser can tell you a function exists and that one file imports another. It can't tell you what that relationship means. enola. builds the deterministic architecture graph underneath — typed, directional relationships, not just matching text.

What enola. does

Continuous architectural understanding across every change
Dead code identification and safe-deletion validation
Refactoring recommendations prioritised by impact
Vulnerable code reachability verification
Architectural drift detection before production

The outcome

Agents skip re-exploration — context is one snapshot away
Token spend is optimised
Fewer hallucinated architecture decisions
Risky changes caught before they ship

Under the hood

A syntax tree is not an architecture graph.

Symbol graph — what everyone else ships

AuthServiceconnects_toUserRepository

Routerconnects_toAuthHandler

PaymentClientconnects_toOrderService

Every relationship looks the same. Looks complete. Answers almost nothing about impact.

Architecture graph — what enola. builds

AuthServiceimplementsAuthProvider

Routerroutes toAuthHandler

PaymentClientcallsOrderService

Every edge is typed and directional. Impact analysis, dead-code checks, and drift detection can trust it.

Read the full post →