An AI rewrites a PL/I module in your mainframe core. It assembles clean, the batch results match, and it writes the code in the modern idiom, not the codebase idiom this system has always used. Banking and insurance cores run on PL/I, and the convention that broke was never in a standard. It lives only in the code.
Step one · the map
doloop reads your PL/I call structure, the CALL statements, the external procedures, and the INCLUDE members, and makes the system navigable. You get the load-bearing procedures a change ripples out from, the data access layer, a triage list of programs the static call graph never reaches, and the convention strata across the system's vintages. It shows where the system is structured, not what it computes. The scan is free, and it reads none of your business logic.
A procedure reached only through a dynamic or table-driven call shows up as a lead to review, not as a verdict that the code is dead.
Step two · the gate
Once the system is navigable, doloop gates the changes. Where your PL/I keeps a convention, it infers that convention from your own code and flags an AI rewrite that breaks it, deterministically, with the rule, the line, and the rate behind every flag. The first scan measures, on your own code, where your conventions run tight enough for the gate to enforce, and runs the gate there.
The method reads a system's own conventions in any language. It works on code as different as modern Python and COBOL systems up to forty years old, where 525 of 525 held-out programs passed leave-one-out, verified three independent ways. Your PL/I core is next, read on your own code.
Your source never leaves your machine. Bring your own model. Request your first scan →
Routes you to a real doloop page, asks when your question is ambiguous, or tells you when there is no answer. No model runs on the answer path, so it cannot invent one.