EKOS — Enterprise Knowledge Operating System

One compiler.
Three real, unrelated codebases.

Same pipeline, same command, no per-project flags: ekos build && ekos recover && ekos compile && ekos commit, then ekos docs generate --layout curated. Pointed at EKOS's own ~50-crate Rust workspace, a real Databricks Asset Bundle repo, and a real Azure Data Factory pipeline repo — in the same session, back to back. Every number on this page is real output, unedited.

Real repo→ Compiled ledger→ README / Architecture / API / SequenceDiagrams
RFC 0035/0037/0042/0043 — ekos docs generate --layout curated
§ 01 / dogfood — EKOS on itself
The same product, pointed at its own source tree

2,192 files. 39 real crates. 749 real function-call edges.

terminal — real, unedited (RFC 0042 self-run)
Build complete.
  Files observed (new): 2192

Recover complete.
  Git commits analysed: 105
  Local documents analysed: 1995
  Rust files analysed: 132
  Rust symbols recovered: 1324 total, 749 Calls edges
  crate-topology-analyzer: crates=39 technologies=41 edges=368
  cicd-analyzer: pipelines=2

Documentation generated.
  Entity detail pages written: 1855

A real crate/workspace dependency graph parsed straight from every Cargo.toml (RFC 0042) — no more guessing at the architecture by hand. Two real CI/CD pipelines parsed from .github/workflows/*.yml. 749 real RelationshipKind::Calls edges (RFC 0041). Test/demo fixtures (tests/fixtures/*.sql, presentation-deck example data) are explicitly excluded from this self-run — a real bug found live: they were rendering as if they were EKOS's own production schema.

Open the real generated docs: README · Architecture · API · SequenceDiagrams
§ 02 / a real Databricks Asset Bundle repo
Not a fixture — the same repo RFC 0040's Python analyzer was verified against

263 files, 83 real PySpark files, 57 Transformation IR nodes at 60% mapped.

terminal — real, unedited
Recover complete.
  SQL files analysed: 43
  Git commits analysed: 117
  Local documents analysed: 27
  Python files analysed: 83
  Transformation IR nodes (Python): 57 total, 60% mapped (non-Unmapped)

Compile complete.
  Objects:       538
  Relationships: 842

252 real PythonSymbol objects, 45 real PythonModule import edges, real DataFrame method chains recovered from the shared src/dp/ library — not the notebooks, which mostly delegate by function call (RFC 0040's own real-data finding, reproduced here on a second, independent run). 297 individual entity detail pages (RFC 0042) — every function/class in API.md links to its own page with real relationships, evidence, and a 1-hop diagram, generated from this exact run, not a separate command.

Open the real generated docs: README · Architecture · API · SequenceDiagrams
§ 03 / a real recovered chain
doc/databricks/SequenceDiagrams.md — real, unedited

Three real .withColumn(...) calls, in source order.

generated page — real Mermaid source
## src/dp/quality/reconciliation.py#0

```mermaid
sequenceDiagram
    participant n2f4...f6 as ".../reconciliation.py#0:0"
    participant n7e8...95 as ".../reconciliation.py#0:1"
    participant na94...91 as ".../reconciliation.py#0:2"
    n2f4...f6->>n7e8...95: Calculate
    n7e8...95->>na94...91: Calculate

A real 3-step Calculate chain from src/dp/quality/reconciliation.py — recognized by real AST parsing (rustpython-parser), not a regex scan, and rendered through the exact same TransformNode/FeedsInto diagram renderer Pentaho and SQL already use (RFC 0027's format-agnostic design, paying off a third time).

§ 04 / a real Azure Data Factory pipeline repo
Real ADF exports — pipeline/dataset/linkedService JSON, a metadata-driven control table

38 files, 95 compiled objects — and an honest gap.

terminal — real, unedited
Recover complete.
  Git commits analysed: 43
  Source files scanned for dependencies: 1
  Local documents analysed: 11
  Python files analysed: 1

Compile complete.
  Objects:       95
  Relationships: 158

No SQL files, no dedicated ADF-pipeline recovery — because there isn't one yet. RFC 0038's roadmap scopes an Azure Data Factory connector as a future phase (real local pipeline/dataset JSON scan, plus the parameter/variable IR this repo's own real Lookup+ForEach control-table pattern would finally justify designing). Today, this repo's real pipeline//dataset// linkedService//metadata/ JSON exports are captured as plain File facts — discoverable, but not yet parsed into structured knowledge. Stated as a limit, not hidden by only showing the projects that look good.

Open the real generated docs: README · Architecture · API · SequenceDiagrams
§ 05 / what did get recovered
doc/adf-pipelines/Architecture.md — real, unedited

The one Python utility script in the repo, real imports and all.

generated page — real Mermaid source
### DependsOn

```mermaid
graph TD
    n_db["unknown"]
    n_97["PostgreSQL"]
    n_db -->|DependsOn| n_97
    n_edb["scripts/pg_inspect.py"]
    n_939["argparse"]
    n_edb -->|DependsOn| n_939
    n_1d4["csv"]
    n_edb -->|DependsOn| n_1d4
    n_433["json"]
    n_edb -->|DependsOn| n_433

Even with no ADF-specific connector, the generic pattern-matching dependency scanner and the Python analyzer both still ran, finding what they're actually scoped to find: one real scripts/pg_inspect.py utility and its real standard-library imports. Every recovery pass degrades independently — a missing connector for one source format never blocks what the others can already see.

§ 06 / honest limits
What this deck won't overclaim

Real, disclosed gaps — not smoothed over.

The previous gap this deck disclosed here — API.md using a legacy text-scan instead of real RustSymbol/PythonSymbol objects — is fixed as of RFC 0042: every API.md above now links real program entities, not scanned identifier strings.

Try it

Point it at anything EKOS has already compiled.

terminal
# compile once
$ ekos build && ekos recover && ekos compile && ekos commit

# deterministic, zero LLM, zero cost
$ ekos docs generate --layout curated
EKOS · RFC 0035/0037/0040/0041/0042/0043 · every example on this page is real output, unedited · github.com/alexeyban/EKOS