# Entelligence Documentation

> Entelligence builds a living engineering wiki from your codebase, incidents, and agent sessions: architecture docs and runbooks with zero manual writing.

Source: https://entelligence.ai/documentation

## A codebase wiki that writes itself.

Entelligence indexes your repos, incidents, and coding sessions to build a comprehensive engineering wiki for your org. Architecture docs, runbooks, error pattern guides, and skill insights: always current, never manual.

- **100%** of docs generated automatically from your real codebase
- **0 hrs** of manual documentation required from your team
- **Always** in sync, wiki updates when your code and incidents do

## Your codebase is undocumented. Your agents pay for it every day.

Architecture decisions live in Slack threads. Runbooks go stale. New engineers spend weeks asking questions no one has written down.

- Searching for docs that don’t exist: 4.2 hrs/wk
- Onboarding takes weeks, not days: 3–6 wks
- Runbooks written once, never maintained: +40 min/incident
- Same incidents, rediscovered from scratch: recurring
- Tribal knowledge walks out the door: irreversible

- **72%** of engineering docs are stale within 6 months
- **3–6 wks** average onboarding without a living wiki
- **4.2 hrs** lost per engineer per week to missing docs
- **0 hrs** of manual writing required with Entelligence

## The right knowledge injected at every stage of the pipeline.

Coding agents are only as good as the context they have. The wiki feeds generation, review, and incident response with exactly what’s needed at each stage.

- **Code Generation: Fewer tokens. Better first drafts.** The wiki feeds existing patterns and module context to your agent upfront, so it generates closer to correct without wasting tokens reinventing what already exists. (46% fewer tokens per generation session)
- **Code Review: Catches issues that have happened before.** The wiki surfaces matching incident patterns for the code being reviewed. Known failure modes get flagged before they merge, not after they page someone. (3x faster review cycles on high-risk changes)
- **Incident Mitigation: Root cause in seconds, not hours.** When an incident fires, the runbook and past root causes are already in context. Your agent starts from a known baseline instead of blank, cutting MTTR from hours to minutes. (68% faster mean time to resolution)

## Four layers of knowledge, built automatically.

From architecture docs to runbooks to skill insights, Entelligence builds and maintains the full knowledge stack your engineering org needs.

### Codebase Documentation: Architecture docs that stay current with every PR.

Entelligence reads your repositories and generates structured documentation for modules, services, and key patterns. Every merged PR triggers an update, so the wiki reflects your code, not a snapshot from six months ago.

- Indexes all repos and maps service dependencies
- Auto-generates module docs from code structure and PR diffs
- Links related files, patterns, and prior incidents

### Incident Pattern Library: Error patterns documented the moment they’re resolved.

When incidents are triaged and closed, Entelligence captures the root cause, affected files, and fix approach into your wiki’s error pattern library. The next engineer who hits the same issue finds the answer in seconds.

- Root cause, affected code, and fix documented per incident
- Error patterns grouped by type and frequency
- Linked to runbooks for immediate response guidance

### Automated Runbooks: Step-by-step response guides built from real incidents.

Entelligence synthesizes resolution steps from closed incidents and structures them into actionable runbooks. When the same issue recurs, your team knows exactly what to do. No war room needed.

- Generated from resolved incident timelines, not templates
- Includes root cause, diagnostic steps, and fix commands
- Updated automatically when a pattern recurs with new context

### Coding Skill Insights: Team-wide skill gaps surfaced from real session data.

Entelligence indexes coding sessions across Claude Code, Codex, and Cursor to surface where your team is losing time. Skill gaps, low-efficiency patterns, and personalized recommendations, all in one place.

- Per-engineer skill profile built from session history
- Team-wide gap analysis with specific improvement areas
- Recommendations updated as sessions and patterns change

## Connect once. The wiki builds itself.

Entelligence pulls from your existing tools. No manual entry, no templates to fill out. The wiki grows as your codebase evolves and your team ships.

- **Connect your repos and tools.** Link your GitHub repositories, incident data, and coding agent sessions. Entelligence indexes everything without storing your code.
- **Entelligence builds the knowledge base.** Architecture docs are generated from code structure and PR diffs. Incident patterns, runbooks, and skill insights are synthesized automatically.
- **The wiki stays current as you ship.** Every merged PR, closed incident, and new coding session updates the wiki in real time. Your documentation is always a reflection of your actual system.

**Time saved per engineer: 4.2h/wk.** Engineers spend an average of 4+ hours per week searching for documentation that doesn’t exist or is out of date. Entelligence eliminates that entirely by keeping the wiki current automatically.

## Stop documenting by hand.

Connect your repos and tools once. Entelligence builds and maintains the engineering wiki your agents and team actually use.

Pricing: [Pricing](https://entelligence.ai/pricing.md).
