Nicheloom

Market intelligence for builders — see what's gaining traction before it's crowded.

Enola-A deterministic architecture graph for developers and AI agents

Details

External ID
48762592
Source
HN
Company
—
Product
Enola-A deterministic architecture graph for developers and AI agents
Website domain
github.com
Launched
July 2, 2026
Cohort
—
Upvotes
10
Upvotes percentile
0.5418160095579451
Tags
—
Fetched at
Sept. 7, 2026, 9:26 p.m.
Updated at
Sept. 7, 2026, 9:26 p.m.

Description

Together with a friend, we were developing a golf application. Our codebase grew rapidly and became split between multiple repositories: the iOS app, Android app, backend, front-end, and extra tooling. Both of us also work in larger scale-ups, and we saw the same problem: understanding large distributed codebases becomes progressively harder. Yay for microservices.It takes time to understand and answer questions like: - What calls this function? - What is the impact of changing this interface? - Is this code actually reachable and used?Not a secret that both of us embrace the leverage AI coding agents bring. But … AI agents spend a surprising amount of time understanding and rediscovering architecture. For them, architecture is a result of greps and, at times, assuming dependencies. With a new session, they rediscover the architecture again. Yet, architecture is deterministic. To introduce any changes, you need to understand the architecture.Over months, we optimised and built Enola to manage that hurdle.Enola is an open-source architecture engine that exposes an MCP server. Index any codebase into a persistent knowledge graph. If needed, combine multiple repositories into a graph of graphs. While constructing the graph, Enola parses the repository without using an LLM. The graph is built deterministically from source code. Outcome: A structured, deterministic architectural model of your system (a collection of multiple repositories).Why open-source? Our goal is to provide engineering tools to manage the “code inflation”. There is a lot more code being produced, and codebases grow faster and faster. But the architectural integrity is still needed. Enola exists because software engineering still begins with understanding a system before changing it.Key Features (subset):1. Impact Analysis: Determine the "blast radius" of a change by querying the graph of relationships between symbols, modules, and API routes. Simply ask: “If I change this, what breaks?”2. Dead Code Discovery: Identify unused code paths and orphaned components that aren't reachable through your defined entry points.3. Dependency Analysis (We called it traverse, because why not): Trace the dependencies, both downstream and upstream. You can simply ask Enola: “What depends on X?”4. Multi-Repo Context: Enola supports a "graph of graphs," allowing you to index and query relationships across as many repositories as your architecture requires. So stack them up!5. Performance: Enola runs fast, given its architecture, naturally depending on your codebase. Give it a try! Curious.We are open-source, building in public. You can find the documentation and source in the link above.If you have a complex codebase and would be willing to test Enola, I’d appreciate the feedback. Tell us what works, what is missing.

Enrichment

Theme
AI agent frameworks and developer tools
Vertical
Horizontal
Function
Dev tools
Audience
Developer
AI stance
AI feature
Project type
Commercial product
Normalized one-liner
architecture graph for developers and ai agents
Manually corrected
False

Could you build this?

Partial Building a basic dependency visualization graph is straightforward, but deterministic multi-repo cross-language static analysis across mobile, web, and backend codebases requires sophisticated AST parsing and linking.

What it would actually take: A robust version requires tree-sitter or LSP-based AST parsers for multiple languages (Swift, Kotlin, TypeScript, etc.) to extract API contracts, schemas, and network call graphs deterministically. These nodes and edges must be normalized into a unified graph schema (e.g., using Neo4j or SQLite graph extensions) with deterministic hashing algorithms to detect drift across distributed repositories.

Discussion

6 comments analyzed.

Competitors mentioned: Enola, Determined

Concerns raised: Unclear what output/return data is sent to LLM, Building performant deterministic codebase model is challenging, AST tree-sitters alone are insufficient

Feature requests: Document what the agent returns to LLM more clearly, Clarify signal for when agent should stop gathering context and start making changes

Competitors

Other products that read as similar to this one — 144 launches clear the similarity bar, closest 8 shown.

Attention rank: #68 of 145 (itself plus its competitors, highest first — normalized so YC and Product Hunt are compared fairly).

Launched 241 days after the earliest competitor.

Other launches for this product

Same idea, different domain

Nobody's really built a dev tools tool for Sales yet.