Source, history, documents, schema, live data, servers, logs, metrics, traces and tickets, pulled without asking the customer to prepare anything.
History is evidence, not just code. Documentation is treated as a claim, never as a fact. The database tells you more about meaning than any wiki ever will.
| Source | What is read | Notes |
|---|---|---|
| Source control | Full history, branches, commit messages, authorship, ticket links | Git, SVN, TFS, Perforce |
| Build system | Dependency manifests, build configuration, artifact layout | Maven, Gradle, MSBuild, Ant, make, npm, pip |
| Documentation | Wikis, SharePoint, loose Word and PDF, README files, comments | Recorded as claims, never as facts |
| Database schema | Tables, columns, constraints, indexes, views, triggers, stored procedures, jobs | Oracle, SQL Server, DB2, Postgres, MySQL, generic JDBC and ODBC |
| Database behaviour | Slow query logs, statement statistics, execution plans, real value profiles | This is what reveals actual meaning |
| Production servers | Process inventory, configuration files, environment variables, scheduler entries, deployed versions | Read-only agent or a supplied snapshot |
| Logs | Application, server and batch job output | Parsed for failure paths and silent errors |
| Metrics | Request rates, latency, error rates, resource use | Prometheus, Datadog, Dynatrace, CloudWatch, AppDynamics |
| Traces | Distributed traces, method-level sampling | OpenTelemetry preferred, vendor APIs supported |
| Ticketing | Defect history, change history, who fixed what | Jira, ServiceNow, Azure DevOps |
The platform must produce value from source control alone, and then say precisely what each missing source costs. Missing runtime evidence visibly caps the achievable evidence depth rather than quietly lowering the bar.
For customers who will not grant live access at all, offline exports and snapshots run through the same pipeline. Slower to refresh, identical in structure, and labelled as such throughout the model.
Node kinds run from file and symbol through table, procedure and job to rule, assertion, decision and task. Every node and every edge carries where it came from and how sure the platform is.
evidence: stratum: runtime # surface | structure | semantics | runtime sources: [trace:otel, vcs:commit:a4f2e91] confidence: 0.94 observed_window: 14d last_confirmed: 2026-07-24
Old documents describe intent, not behaviour. Where sources conflict, the more direct observation wins and the conflict itself is recorded as a fact about the system rather than discarded.
Because provenance travels with the data, any claim the platform makes can be traversed back to the trace, the commit or the named person it rests on. A number without a source cannot exist in Core.
Static call graph intersected with trace coverage gives what is live, what is dormant and what is dead. Nothing is marked dead on a window shorter than its natural cycle. Annual, quarter-end and disaster-recovery paths become questions instead.
Request volume is propagated through the call graph, so every symbol carries what it actually costs and how often it matters. Effort estimates stop being guesses about size and start being statements about traffic.
Declared schema intersected with actual value distributions and query logs shows which columns are used, what they really contain, and which constraints are fiction the database stopped enforcing a decade ago.
Log patterns intersected with the job graph surface silent failures, swallowed exceptions and partial completions. These are the behaviours a rewrite reproduces by accident or destroys by accident.
Each analyzer implements the same five steps: parse, symbols, call edges, data access edges, confidence. Nothing above the model layer knows what language it is looking at.
The platform names the tier a given codebase received and caps claimed confidence to match. A structural read of COBOL is useful. Pretending it is a semantic read is how these projects fail.
Analyzers extract candidate business rules in plain language, each linked to the code, commits, tickets and runtime evidence supporting it. A rule is never recorded as established from code alone. It stays a candidate until a named person confirms it.
Evidence depth stated per module, so you can see which parts of the picture are observed and which are merely parsed.
Dependency queries that answer what breaks if this changes, weighted by real traffic rather than by file count.
Dormant and dead code separated, each with its confidence and the observation window it rests on.
Where a value originates and every service and job it passes through before it reaches a customer.
Untested hot paths, silent failures and undocumented triggers, ranked rather than listed.
Business rules in plain language, each awaiting confirmation from someone who can actually rule on it.
Open the system map in the prototype and read depth per stratum, module by module.