A retail barcode terminal and its desktop exchange server, explained from a
bin/Release folder alone — no source, no docs. Twelve compiled .NET assemblies
in, a full picture out: the daily file-exchange cycle, seven handheld workflows, the
document-driven action engine, and the dead code only a call graph can see.
Full 18-section documentation →
A real question against a real accounting ERP: when a payment’s status changes, which code did it? Traced to one column and one function, with every claim linked to a file and a line — including the hop no schema diagram can show, what EKOS could not do, and a step-by-step runbook for repeating it on your own repository.
The startup pitch: why enterprise AI needs a compiler, not another RAG index — proven cold against real repos, and audited live by Claude Code using EKOS's own MCP server on itself.
Pentaho jobs, SQL, and stored procedures compiled into one evidence-backed Transformation IR — explain what a legacy pipeline does, and prove a migration didn't change its meaning.
Issues, PRs, files, and their real relationships compiled into an append-only, evidence-backed ledger any MCP-speaking agent can query.
The connector's first live run — 1,600 real issues/PRs from a real repo, not a mock. Two known gaps fixed before the run; a third, far more severe one (96% of real items collapsing into one identity) found only once it was running at real scale, and fixed the same session. Real docs, real code, and real GitHub items surfaced together by one query — plus the honest, still-open residual limitation.
EKOS's Pentaho and SQL recovery analyzers run against two real GitHub ETL projects — terminal output, MCP query/answer transcripts, and the honest gaps a data engineer would want to see before trusting it.
The honest gaps the previous deck surfaced became GitHub issues #2 and #3 — this deck reruns the exact repro shapes against the fixed pipeline, live, with the before/after coverage numbers.
How Claude Code searches and analyzes a codebase through EKOS's MCP server
instead of raw grep/Read — a measured, honest with-vs-without comparison, the real
/context token footprint, real 24-hour usage logs, and gaps stated plainly.
Markdown, self-contained HTML, and Mermaid diagrams rendered straight from the compiled ledger — including a real cloned Pentaho ETL repo compiled cold, join and Unmapped steps included. Zero LLM by default; an opt-in prose tier verified against a real local LLM. Every example is real output, unedited.
The same doc-generation loop run cold against three real, unrelated codebases — EKOS itself, a Databricks Asset Bundle repo, and an Azure Data Factory repo — including the honest "no ADF connector yet" gap, stated plainly rather than hidden.
Real Pentaho ETL steps compiled into real dbt SQL models — ref()/source() chained via the Transformation IR, honest passthrough for Filter/Calculate/Unmapped, and the two real bugs a real 198-object Pentaho repo found and got fixed.
The one explicit, audited exception to "AI never touches raw enterprise systems directly" — an LLM-built, SELECT-only, redacted, ledger-audited live query, verified against a real ClickHouse container, honest failures included.
Pointed at a real, unmodified open-source repo it had never seen, EKOS compiled its git/CI/dependency knowledge cleanly and found its own gap: sqlparser's ClickHouseDialect can't parse ClickHouse's own CODEC(...) column clause. Documented anyway, gap named plainly.
The same repo, re-analyzed after RFC 0057/0058 closed the parser gap: all 15 real ClickHouse tables now structurally recover with zero warnings — and re-analyzing surfaced a second, unrelated finding in a different pipeline stage, identity resolution over-merging 6 of those 15 tables into one. Reported the same way the first gap was.
The same repo, the whole thing this time: a genuinely cold observe → compile
→ ledger → MCP query run over all 2,022 files, timed stage by stage, plus a real
ekos ask + MCP Q&A set graded against ground truth. Surfaced three new,
honestly-reported gaps — a Postgres parser failure, identity over-merging real people and
documents (not just ClickHouse tables), and a retrieval-brittleness bug in
ekos ask itself — all fixed the same day (RFC 0059/0060/0061,
devlog_61).
Every tool in this space leads with a metric; EKOS never had one published.
A real repo, two real questions, raw grep vs the compiled ledger, both sides counted with the
same standard tokenizer (tiktoken). 67-93% fewer tokens for the realistic case —
and the one case grep wins is on the page too, not edited out.
Real per-language AST decomposition (Elixir, JS/TS), a real System Decomposition view tying Backend/Frontend/Database together, readable diagrams, and real Backend-to-Database edges — six increments, each live-verified against the same real 2,000+ file codebase. Honest about what's still deferred.
Every entity page gets a real, evidence-grounded LLM overview — persisted to the ledger at commit time, never fabricated, flagged when a human comment goes stale. Verified end-to-end at zero real cost against a local model; two real bugs the live run found, fixed the same session.
The whole loop run cold against a project EKOS had never scanned before — real module and symbol AI overviews, a real Purpose grounded in the real README, a real gap found and fixed the same session. The same compiled properties that make the generated pages precise are exactly what MCP tools read live.
Multi-hop blast-radius tracing and point-in-time reconstruction over the compiled ledger — what breaks if a table changes, and what a system looked like at an earlier commit, each answer carrying its evidence.
Two autonomous end-to-end test runs of EKOS's object-storage-backed, horizontally-distributed knowledge ledger — fault injection at the coordinator, the compile worker, and the query gateway. Run 1 found four defects; Run 2, against a real S3 endpoint and a 95-partition workspace, found four more. All eight fixed with regression tests, every metric traced to a log file.
An autonomous 22-act pass over the distributed storage stack, the compiled-knowledge query engine, and the MCP protocol — coordinator fencing, gateway failover, RRF fusion, REASON citation checks, the vector arm on a real embedding model, and the write-vs-read-only-gateway safety assertion. Three partitioned-store bugs it surfaced, fixed and re-verified in the same run.
Shipped increments take EKOS from a terminal-and-MCP-only compiler to
a running browser console — workspace supervision, a statistics dashboard, an
ekos.toml editor, an allowlisted job runner with live logs, cron/interval
scheduling, and an interactive evidence graph with time-travel, neighbourhood isolation,
and impact-mode tracing. Architecture diagrams, real screenshots, the read/write auth
split, and the bugs each phase surfaced.
The compiler compiled itself — EKOS's own ~50-crate workspace run through
the full pipeline with real timing, CPU, memory, and storage numbers from
/usr/bin/time -v and its own RFC 0114 query log, three real bugs found live
along the way.
RFC 0138's eval harness flagged weak agent answer quality. Chasing it found four contamination sources — ending with the discovery that 94% of the observed corpus was not our code at all — plus three bugs that let fixes ship and silently do nothing while every stage exited 0. Full 101-scenario before/after at each stage, with the superseded numbers left visible as corrections and the open regressions named plainly — including a round where the headline scores landed bit-identical and a "regression" turned out to be a metric finally telling the truth about one scenario, and a later round that found a bigger, cheaper fix than the one it went looking for: 42/101 → 53/101, with the side effects it introduced reported alongside the gain.
EKOS moved its answering model from a local 8B llama3 on Ollama to DeepSeek V4 Flash via OpenCode Zen, then fixed document decomposition and query planning. Same 101-scenario suite: 53 → 70 from the model alone, → 79 with heading-aware documents and doc links, → 87 with planner routing and entity-resolution fixes. Why EKOS uses an LLM and where, why the cloud model wins, what it means for closed environments (compile anywhere, answer well only on real GPU servers), and the 14 scenarios that still fail, by cause.
Why the EKOS token's relevance is designed to grow as a consequence of platform adoption, not a promise of price — the phased ecosystem roadmap from contributor rewards to plugin, agent, and knowledge marketplaces.