Engram: Codebase Intelligence Platform

Know why it exists - and what breaks next.

Engram is the structural understanding and change-intelligence layer for complex software estates.

It connects code with tickets, reviews, decision history, ownership, call paths, and cross-repository dependencies. Developers and AI tools can answer not only “where is it?” but “why is it this way, who understands it, and what could break if we change it?” Self-hosted inside your perimeter and available over MCP.

Safer change

See execution paths, upstream callers, contracts, regression history, and likely blast radius before work begins.

Faster understanding

Orient developers quickly with repository briefings, architecture views, decision context, and implementation lineage.

Better-grounded AI

Give coding agents current, permission-aware organisational context instead of a handful of open files.

What it does

Deep Semantic Search

Understand intent across languages with hybrid structural and semantic retrieval. Pluggable embedding providers include Azure OpenAI, Gemini, Voyage, and Ollama.

Codebase Knowledge Graph

Connect tickets, commits, PR reviews, code reviews, compiled artifacts, deployments, call graphs, import graphs, and type hierarchies into a single, queryable knowledge graph with temporal scoring.

Cross-Repository Context

Materialised contract maps surface producers and consumers across HTTP APIs, queues, and internal NuGet/npm packages. One question, every caller. No per-repo blind spots.

Call Graph & Impact Analysis

Static call-site extraction with multi-pass name resolution across 14 languages. Trace forward execution from any HTTP route or entry point. Reverse BFS finds all upstream callers with log-scaled risk scoring. Know the blast radius before you touch a line.

Native MCP Integration

35+ MCP tools plus a first-party CLI and transparent, secure API proxy for AI assistants. Search, trace, impact, contract, history, and administration tools share one permission-aware context layer.

Architectural Community Detection

Louvain clustering over call graph edges discovers architectural modules, tracks their split/merge lineage, identifies entry points, and generates architecture documentation without LLM cost.

Implementation lineage

Code rarely explains why it exists. Engram reconnects implementation with the evidence behind it.

Decision history

Trace a subsystem through work items, commits, reviews, and retained historical evidence to understand how it reached its current shape.

Source-authored rationale

Index ADR and RFC citations, comments, and authored rationale as evidence attached to the symbols and files they describe.

Time-aware context

Ask what was known at a point in time, identify stale knowledge during rewrites, and distinguish current architecture from historical residue.

Engineering intelligence

Explainable signals for leaders and engineers - not another opaque code-quality score.

Engineering health

Executive and technical snapshots surface fragility, test reachability, regression history, semantic anomalies, and architecture drift.

Ownership & key-person risk

Map recent domain knowledge, ownership concentration, and places where the code's practical ownership no longer matches the organisation chart.

Cross-repo duplication

Convergent-Evolution Radar identifies semantically similar implementations that evolved independently across repositories.

Rewrite Radar

Flag actively rewritten subsystems where cached documentation and historical assumptions are becoming stale.

Regression provenance

Add defect-density and change-history evidence to impact analysis so risky areas receive proportionate review.

Human-gated action

Turn validated evidence into deterministic technical-debt candidates while keeping filing and prioritisation under human control.

Where engineering work happens

Engram brings evidence into existing tools instead of demanding another destination.

MCP, CLI & Explore

Use 35+ MCP tools from AI coding clients, the first-party engram CLI in a terminal, or Explore for interactive search and graph navigation.

Pull-request context

Annotate GitHub pull requests with impact, dependency, and historical context so reviewers see risk at the decision point.

Reports & team access

Export self-contained interactive HTML graphs and optionally expose ask-the-codebase workflows through Teams or Slack.

Pre-Compiled Knowledge

Module Briefings & Scope Packs

Per-community architecture overviews with entry points, and per-directory API surface bundles with import graphs. Compiled at index time.

Symbol Contexts & Contract Maps

Per-symbol bundles with callers, callees, tickets, review context, commits, and release signals. Plus materialized cross-repo contract topology. Zero LLM cost at query time.

Built for production

Engram runs against working codebases that change all day. The worker pipeline is designed for that.

Production reference

Running at House of Travel

Engram is in production at House of Travel, indexing more than 150 repositories across 14 languages with Git and TFVC running side by side.

150+ repositories 14 languages Git + TFVC source control

Multi-pod safe

Workers heartbeat into the queue. If a pod disappears mid-job, another picks the work up from where it stopped. No silent stalls, no duplicate runs.

Deploy-resilient

Jobs interrupted by a rolling deploy are auto-restarted at the front of the queue. Canary deploys ship with telemetry baselines, dev environments serialise to keep things sane.

Priority-aware queue

Priority-weighted dequeue and dynamic per-job timeouts. A 30-minute mono-repo full reindex won't starve the canary checking a five-file change.

Built under production pressure

Hardened where real systems fail

Recent work strengthened index integrity across interruptions, stale source revisions, provider pagination, webhook replay, rate limits, drift signals, alert delivery, retrieval security, and rolling deployments.

Durable indexing Permission-aware retrieval Recoverable operations

Setup

1

Connect Your Tools

Azure DevOps
GitHub
GitLab
Bitbucket
Source control (Git & TFVC) + ticket tracking
2

Automatic Indexing

Three modes, pick per repo or per run:

  • FullRe-parse, re-embed, re-compile artifacts from scratch.
  • IncrementalOnly touched files since the last indexed commit.
  • RecompileKeep the index, rebuild the artifacts. Fast.
3

Activate MCP Server

Add your Engram MCP configuration to an AI tool.

{
  "mcpServers": {
    "engram": {
      "url": "https://..."
    }
  }
}

Operate it

A dashboard for the people who run Engram, not just the people who query it.

Stats illustrative preview
Repos150+
Indexlive
Driftcurrent
Contextlinked
Health illustrative preview
Worker pod heartbeat 4s
Embedding pipeline 14 / min
worker stale 2d
Artifact freshness 98%
Job Queue illustrative preview
running core-api Incremental
running web-app Full
pending worker Recompile
done shared-lib Incremental
done admin-ui Full

Enterprise control

Keep source, context, access decisions, and operating evidence inside your environment.

Permission-aware retrieval

Repository-level authorization applies across MCP, search, and Explore so users and AI tools retrieve only repositories they are entitled to access.

Self-hosted releases

Deploy versioned releases through an official OCI Helm chart or generic Docker Compose package, with build information and offline license verification.

Operate and recover

Monitor drift, failures, readiness, rate limits, and queue health. Supported backup, export, and restore workflows provide a practical disaster-recovery path.

Works with

Source Control
Azure DevOps
GitHub
GitLab
Bitbucket
AI Tools
Claude Code
Pi
Codex
OpenCode
Cursor
GitHub Copilot
Windsurf
Continue
JetBrains AI
Antigravity CLI
Languages
C# TS JS PY JAVA GO RUST RUBY PHP KOTLIN SWIFT C C++ SQL
Ticket Tracking
Azure DevOps
Jira
Linear
GitHub Issues
GitLab
ClickUp
Asana
Monday
Shortcut

Pricing

Annual self-hosted licensing. Every tier includes the full platform, unlimited repositories, and unlimited agent or MCP queries.

Team

Up to 25 developers

US$15k/year

For engineering teams bringing codebase intelligence into daily AI-assisted development.

Enterprise

Unlimited developers

From US$75k/year

For organisation-wide deployments, complex environments, and rollout support.

Paid pilot

Run Engram for 60 days against your own codebase for US$3k. The pilot fee is credited if you convert to an annual license.

Request pilot

Deployment

Tailored Installations on Your Infrastructure

Versioned Docker Compose and OCI Helm deployments, installed remotely or in person, with backup and restore support.

Contact Mitch at: mitch@pragmaticcoder.com

Request Info →