Turn documents and live systems into one governed, explainable AI layer
eli.ai grounds chat, agents, and APIs in a knowledge graph built from your markdown — then binds entities to scoped, read-only data. Every claim carries a citation: S for document sources, D for live data calls. Traceable, replayable, and verified after the fact.
Yes — 14 orders are stuck totaling $8,120 Data, all older than 24 hours. Per the incident runbook, requeue them via the fulfillment console Source.
Product tour
The actual product, not a mockup
Live screens from a real workspace: thirteen markdown documents in, and the graph, ledger, grounded answers, and deliverables they became.
The WebGL graph explorer — entities and relations extracted from your markdown, with persisted layouts and strength-weighted edges.
The entity ledger — mentions, degree, and PageRank per entity, straight out of the extraction pipeline.
Grounded chat — a multi-source answer where every claim carries a citation you can open.
A reproducible engagement report — KPIs, the coverage matrix, gap ranking, and a frozen graph map, rendered to PDF.
Capability map
The whole platform, in eight modules
Eight composable slices carry a document from raw source to a governed, cited answer — and expose every step to your agents and APIs.
Browse the full capability map- INTAKEIngest
- ATLASModel
- WARRANTGovern
- LINEAGETrace
- CONDUITBind
- LENSAnswer
- CRUCIBLEMeasure
- PORTSExpose
INTAKE
Every source becomes one clean, deduplicated corpus.
- ACL-aware, read-only connectors for Confluence, SharePoint, Slack, and markdown vaults — plus bulk zip/JSON import
- Resumable sync checkpoints; content-hash upserts re-process only what actually changed
- Cross-source normalization and dedup, with per-run provenance on every document
- Heading-aware chunking that preserves document structure for retrieval
Enterprise — Point it at the wikis your teams already live in — no migration.
ATLAS
A canonical, typed knowledge graph you curate and evolve.
- LLM extraction with provenance on every entity and relation — and a deterministic wikilink fallback that needs no LLM
- Editable ontology with domain/range-checked relation types
- Entity review, merge, and relation explainability keep extraction honest
- Community detection and persisted WebGL layouts for exploring large graphs
Enterprise — The shared vocabulary every answer and report is built on.
WARRANT
Authority, lifecycle, and gated change on every fact.
- Authority tiers on every fact: machine-extracted → asserted → curated → certified
- Lifecycle with gated change requests: draft → published → deprecated → superseded
- Owners, stewards, review SLAs, and document verification workflows
- Versioned concept manifest with SKOS export for downstream systems
Enterprise — Certified answers your compliance team can stand behind.
LINEAGENew
Per-document provenance and downstream impact in one trail.
- Append-only PROV-O revision trail plus a full workspace audit log
- One read per document: upstream origin → derived knowledge → downstream impact
- Impact before change: “N answers cited this” · “N entities affected if deprecated”
- Every answer traceable to the exact document revision it cited
Enterprise — Answer “where did this come from?” and “what breaks if we change it?”
CONDUIT
Governed live queries bound to graph entities.
- Parameterized, read-only SQL for Postgres, MySQL, and Snowflake — allow-listed components, never free-form queries
- Entity and type bindings resolve graph nodes to live rows at answer time
- Every call persisted with params, row count, duration, and status — replayable behind its Data Citation
- Fail-soft: a timed-out component never sinks the answer; the miss is recorded
Enterprise — Live warehouse numbers, cited like a source.
LENS
Retrieval and an answer policy that knows when to abstain.
- Hybrid retrieval: full-text + vector, graph fusion, reranking, token-budget assembly
- Answer policy decides per question: answer, clarify, surface the conflict, or abstain
- Dual citations on every claim, groundedness-verified after generation
- Tiered semantic cache with dependency invalidation and serve-time ACL re-check
Enterprise — Grounded answers with receipts — or an honest “I don’t know.”
CRUCIBLE
Golden sets, retrieval and abstention metrics, governed judges.
- Concept-anchored golden sets with graded relevance judgments
- recall@k, nDCG@10, MRR, RAGAS, and CRAG truthfulness per run — diffable across configs
- A/B comparisons gated by paired-bootstrap statistical significance
- Judges calibrated and shadow-governed before they gate anything; drift alerts to webhooks
Enterprise — Prove quality per task and model — not vibes.
PORTS
Every capability, exposed to your agents and tools.
- Durable agents: budgets, guardrails, step tracing, memory across restarts, write-via-approval
- Scoped workspace API keys over a versioned /api/v1 with OpenAPI spec and playground
- MCP in both directions: consume external tool servers, serve /api/mcp to any MCP client
- Headless JS + React SDK: typed contracts, hooks, and drop-in components
Enterprise — Wire eli.ai into the systems your org already runs.
See the eight modules chain end to end
From a connected source to a cited, governed answer you can trace all the way back.
Product
Everything between your documents and your systems
One platform: a markdown knowledge base, the graph extracted from it, the live data bound to it, and the agents and APIs that answer from all of it — with receipts.
Semantic ↔ data layer
Bind graph entities to scoped, read-only connectors — Postgres, MySQL, and Snowflake — through domain components: governed, parameterized SQL. Agents and APIs answer from documents and live systems in one pass, with Grounded Citations: Source Citations to document passages and Data Citations to data-call provenance rows. Traceable, explainable, replayable.
Knowledge graph with provenance
LLM-extracted entities and relations, each carrying provenance — plus a deterministic wikilink and co-occurrence fallback that works with no LLM at all. WebGL explorer with communities and persisted layouts; entity review, merge, and ontology authoring.
Grounded chat
Hybrid retrieval (full-text + vector) with a Source Citation on every claim and an async groundedness check that badges each answer — verified n/m, not vibes.
Durable agents with HITL
A provider-agnostic harness with budgets, guardrails, and tracing. Durable memory across runs, human-in-the-loop approvals, and write-via-approval: agents propose notes, humans approve.
MCP, both directions
Agents consume external MCP servers as tools — and eli.ai is an MCP server at /api/mcp, so Claude Code or any MCP client can query your knowledge natively.
Multi-provider, cost-accounted
Anthropic, OpenAI, Google, or any OpenAI-compatible endpoint. Per-workspace model slots, cost accounting on every call, and spend caps for unattended runs.
Measured quality
Golden-set evals, an LLM judge with calibration and shadow governance, drift detection with alerts and webhooks, and silent QA sampling — measured precision per task and model.
Consulting deliverables
Coverage and gap dashboards that show which business unit to interview next, plus reproducible as-of reports rendered to PDF on a schedule.
How it works
From markdown to a governed answer in four steps
- 01
Ingest
Write or bulk-import markdown. Wikilinks and heading-aware chunking keep the structure.
- 02
Graph
Entities and relations are extracted with provenance — deterministically from wikilinks even without an LLM — then reviewed, merged, and mapped to your ontology.
- 03
Bind data
Attach governed, parameterized read-only SQL — domain components — to the entities they describe.
- 04
Ask & automate
Chat, durable agents, /api/v1, and MCP answer from documents and live systems with dual citations.
Semantic ↔ data layer
Answers that cite your documents and your database
A knowledge graph is only half the truth — the rest lives in production systems. eli.ai binds graph entities to governed, read-only SQL so a single question consults both.
- Scoped, read-only connectors for Postgres, MySQL, and Snowflake; every query is a governed, parameterized domain component
- Grounded Citations on one answer: Source Citations to document chunks and Data Citations to data-call provenance rows — params used, row count, duration, status
- Every live lookup is persisted and replayable — explainability you can audit
- Fail-soft: if a component times out, the answer still returns and the provenance row records the miss
{
"answer": "14 orders are stuck totaling $8,120 [D1].
Requeue via the fulfillment console [S1].",
"claims": [
{ "text": "14 orders stuck, $8,120 total", "citations": ["D1"] },
{ "text": "Requeue via the fulfillment console", "citations": ["S1"] }
],
"sources": [{ "id": "S1", "docId": "01J…", "title": "Incident runbook" }],
"dataCalls": [{ "id": "D1", "querySlug": "order-backlog",
"paramsUsed": [7], "rowCount": 4,
"durationMs": 41, "status": "ok" }],
"groundedness": { "checked": true, "verdict": "grounded" },
"usage": { "tokensIn": 4210, "tokensOut": 380, "costUsd": "0.021840" }
}Durable agents
Agents that survive restarts — and ask before they write
A provider-agnostic harness for long-running work, with a human in the loop exactly where it matters.
- Budgets, guardrails, and step-by-step tracing on every run
- Durable memory that persists across runs and restarts
- Write-via-approval: agents propose notes, humans approve before anything lands
- MCP both ways: consume external tool servers, and expose /api/mcp to other agents
Q3 vendor consolidation — draft summary
Cites 6 sources · touches 2 entities
Quality governance
Not vibes — measured precision per task and model
Every quality signal is governed like production software: calibrated before promotion, shadowed in production, and watched for drift.
- Golden-set evals with diffable runs
- LLM judge with calibration and shadow governance before it gates anything
- Drift detection with alerts and webhooks
- Silent QA sampling of production answers — measured precision per (task, model)
Enterprise & self-hosting
Your infrastructure, your tenancy rules, your data
Built for teams and consulting engagements that can't ship their documents to someone else's cloud.
- FORCE row-level security on every tenant table — isolation Postgres enforces even if application code is wrong
- Multi-workspace namespaces: each client or team gets its own graph, connectors, model slots, and keys
- Per-workspace OIDC SSO with encrypted secrets, plus workspace API keys
- /api/v1 structured query API for third-party systems
- Export and offboarding with destruction records
Developers
Built for the tools you already use
Workspace API keys, structured JSON out, and MCP in both directions — external agents can use eli.ai natively.
curl -X POST https://your-host/api/v1/query \
-H "Authorization: Bearer eli_sk_..." \
-H "Content-Type: application/json" \
-d '{"question":"Is anything stuck right now?"}'claude mcp add --transport http eli \
https://your-host/api/mcp \
--header "Authorization: Bearer eli_sk_..."Grounded answers. Governed data. Durable agents.
Put your knowledge to work without losing control of it
Start in the app, or follow the quickstart to run eli.ai on infrastructure you control.