Before you change a line, you need to know what you are holding. Which programs everything else depends on. Where the data layer is. Which modules are still live and which are dead. Which era each part was written in. doloop reads all of that from the code itself, in one pass, with no model and nothing leaving your machine. The first scan is free, and it also tells you how much of this your particular system will give up.
Step one · see it
A legacy system carries its own structure whether or not anyone wrote it down. doloop reads that structure straight from the code, in a single pass, and hands you a map of the system you are about to change. No model runs and no source leaves your machine. The map shows you:
A system whose programs call each other has a rich call graph, and the map reads it deeply: the dependency hubs, the layers, the dead ends. A system whose programs are each launched on their own and do not call each other has little call graph to read, and the map falls back to navigating by module, by convention, and by copybook. You do not have to know in advance which kind you have. The first scan tells you, and learning that your system is one kind or the other is itself a fact about it you can use.
The map shows you where everything is and how it connects. It does not tell you what any program computes. It is an index, not a summary. Reading that one program is called by thirty others tells you it is load-bearing, not what it decides.
A legacy system is rarely written all at once. doloop reads each module on its own, so a system that grew over decades shows up as the layers it actually is. The old business ledgers hold the convention of their era, a later-migrated module sits between conventions, and where a module never settled on one way of doing things the gate stays silent rather than guess.
Step two · gate the change
Once the system is navigable, the modernization begins, and most of it will be written by an AI tool trained on modern code. It builds clean and the tests go green. It also writes the code the way modern systems do, not the way this one has always done it, and the people who would have caught that in review retired years ago. doloop reads the conventions the system already keeps, from its own code, and flags the change that breaks them, with the same verdict on every run and the line and the rule behind it.
A modernization that preserves behavior on every tested path can still violate a convention the system holds everywhere. The convention was never written in a rulebook. It lives only in the code, in how the system has always done a thing, which is the one place a fixed linter does not look and a generic model does not know to respect.
Each house's rule is inferred from its own code, never hardcoded. A modern AWS reference system (carddemo) ends an IF with the explicit END-IF keyword, on 98% of its IF statements, more than a thousand of them. A deep-legacy system ends it with a bare period, in the pre-1985 dialect. Drop one system's statement into the other and the verdict flips.
The legacy convention is not one cherry-picked system. Two independent 1980s corpora, a national-insurance government system and the United States NIST COBOL-85 conformance suite, hold the bare-period rule at near 100%, with no shared authorship. The same convention reproduces out of sample on two real, independently authored business systems we did not choose in advance, a Turkish accounting ERP and a Brazilian point-of-sale system, each holding the bare-period rule under leave-one-out. The split holds under leave-one-out on 525 of 525 held-out programs across seven houses, and the convention is verified three independent ways: a column-aware tokenizer, the GnuCOBOL compiler front-end, and a full ANTLR COBOL-85 syntax tree.
doloop is a deterministic gate on the AI's modernization. It reads how the system is written, its conventions, and flags an AI rewrite that breaks them. It runs on every change, returns the same verdict every run, and cites the rule, the line, and the rate behind every flag, so a verdict can be replayed and audited rather than taken on trust.
Stated plainly, so it can be trusted:
It checks conventions, not business rules. It catches when an AI rewrite breaks the system's own way of doing things. It does not extract what the code means or what a rule decides. Reading that this system ends IFs with periods tells you nothing about what the IF decides.
It is a coherence gate, not a comprehension tool. It tells you where the system is structured, which makes the legacy easier to navigate, but it does not claim to understand the logic.
The transplant above shows the engine can infer a system's conventions and gate an AI rewrite against them. The number it does not yet have on COBOL is the one only your codebase can produce: the false-block rate, the share of flags your own reviewers would overturn. That number has exactly one requirement, and we learned it by trying to measure it without you and failing. It needs accept and reject decisions made by reviewers other than the author, on the modules that have settled on a convention. A solo open-source project cannot provide that, because one person accepting their own drift is not a review, and the gate flagging that drift is arguably right, not wrong. Your codebase can provide it, because your changes are reviewed by someone other than the person who wrote them. That is the one input that produces the number, and it is the reason the number has to be measured on your system rather than ours.
That is what a design partnership is for. The demonstration is ready now. The precision number on your system is the first thing we measure together, on your code, on your machine, where your source never leaves it.
We are taking on a small number of teams modernizing their own legacy systems. It starts with the free first scan, the map of your system and how much call-graph structure it holds. From there, together we measure whether the gate catches the convention breaks your reviewers would reject, on your code, on your machine. Your source never leaves it. Bring your own model.