8/11
Critical federal legacy systems in GAO’s 2025 review using outdated languages such as COBOL and assembly.
TECHNICAL KNOWLEDGE FOR CODING AGENTSTERMINAL / RUNTIME / EVIDENCE
THE GOVERNMENTRUNS ON CODEFEW CAN CHANGE.
Rosetta can edit across codebases with repository-provided references and project checks. Built-in interpreter proof of output and database state currently works only for MUMPS under YottaDB.
RUNTIME PROOF TODAYMUMPS / YOTTADB ONLY
MUMPSCOBOLJOVIALCMS-2
01 / THE RISK IS ALREADY HEREHEALTHCARE / TAX / INFRASTRUCTURE / DEFENSE
A bad patch doesn’t
break a demo. It breaks a mission.
Federal systems people cannot switch off still depend on languages most developers never learned. The maintainers are retiring. The software keeps running.
7/11
Critical systems in the same review operating with known cybersecurity vulnerabilities.
3/10
Systems flagged for modernization in 2019 that were complete by February 2025.
VETERANS’ HEALTH RECORDS ✳ TAX PROCESSING ✳ CRITICAL INFRASTRUCTURE ✳ NATIONAL SECURITY ✳
AI can help modernize this code. But it can also make mistakes, and do so confidently. A fluent explanation means nothing when one missing write can cause irreversible damage to federal infrastructure.
THE MISSING PIECEA check that runs on the system itself.SOURCE / GAO-25-107795 ↗
02 / THE ROSETTA LOOPUNDERSTAND → CHANGE → PROVE
Find the logic
people forgot.
Open Rosetta in the codebase. Trace routines, calls, globals, and the local conventions that never made it into documentation.
$ rosettaMake the change
in one place.
Work with your chosen model inside the terminal. The source, the request, and Rosetta’s language tools stay in the same loop.
YOUR MODEL + LANGUAGE TOOLS + YOUR CODEGive the runtime
the last word.
For MUMPS/YottaDB, run the baseline and candidate on identical cases. Rosetta compares program output and persistent database state, then restores a clean state. Other languages use their repository's own checks.
RUN → DIFF OUTPUT + STATE → RESTORETHE MODEL PROPOSES.
THE RUNTIME GETS THE LAST WORD.
03 / THE FAILURE HIDES IN PLAIN SIGHTINTERACTIVE ILLUSTRATION
This patch looks right.
It is wrong.
In MUMPS, persistent globals are the database. A routine can print the expected result while quietly dropping a critical write.
›/demo
◉ RECORDED AUDIT TRACE · LIVE YOTTADB CAPTURERUNTIME VERDICT
Guard the next-of-kin lookup in NOK^AJETIU2
− S MRK=0 I NOK="" S NOK="Not Entered",MRK=1+ S MRK=0 I $G(NA)="" S NOK="Not Entered",MRK=1
✕ NOT EQUIVALENT3 OF 4 CASES DIVERGED
DFN 4 · DFN 86 · DFN 88
EXPECTED "Not Entered"ACTUAL ""
runtime YottaDBobservables stdout · errors · persistent globalsclean_state ROLLBACK CONFIRMED
Make changes… “Understand unfamiliar code”
ROSETTA TUI / RECORDED AUDIT TRACEThe model said done.
The model said done.
The runtime found three failures.
This is Rosetta’s primary terminal workflow. Inside the TUI, /demo runs the proof flight: isolate state, execute the same cases, name the divergence, repair the candidate, and replay it.
WHY THIS MATTERS
The candidate sounded safe and failed three real cases. Rosetta returned the exact patients, output difference, and another move.
TUI transcript / committed AJETIU2 audit trace / synthetic patient fixture / no protected health information. The page replays saved evidence and never labels it live.
04 / THE REQUIRED TRUST LAYERVERIFICATION STAYS WITH THE CODE
The check has to live
where the code lives.
For MUMPS/YottaDB, Rosetta turns the real runtime into the reviewer. Every verdict comes from behavior the team can inspect.
Hold a clean state.
Start every case from a known system state.
Run the baseline.
Capture the behavior that already works.
Run the candidate.
Use the same inputs against the proposed change.
Name what moved.
Diff output and database state, then restore.
A repair loop with a next move.
Rosetta names the output, error, or database reference that diverged. The next edit starts with evidence.
A result you can challenge.
Saved cases and traces make the claim inspectable. Confidence no longer comes from the model’s own explanation.
Proof stays inside.
The verification loop runs beside the code and can operate in an air-gapped environment. Model routing remains the customer’s choice.
05 / THE WHOLE PLATFORMONE LOOP / FIVE CAPABILITIES
From first read
to proof receipt.
Rosetta is the working environment around the verifier. Developers can trace the code, make a change, run it, measure the result, and turn verified work into better tools.
Understand. Change. Prove.
Open Rosetta inside the project. One coding agent can inspect files, consult repository references, edit code, and run the project's checks. MUMPS projects can also use Rosetta's built-in verifier.
INSPECTEDITCHECK
The real system becomes the test.
For MUMPS/YottaDB, tools expose routines, call graphs, globals, execution, and verification through MCP. Every case starts clean and rolls back when it finishes.
Measure the lift.
Run the same held-out repairs with and without harness feedback. Rosetta keeps the traces and reports repair success, iterations, and false confidence.
Keep the evidence.
Each receipt records the runtime, cases, divergences, restored state, observables checked, and an artifact hash.
SHA256RUNTIME / CASES / STATE
Verified work becomes leverage.
Static analysis produces comprehension data. The verifier grades future model work and supplies the reward signal for specialist training.
CODE→LABELS→MODEL→VERIFIER
06 / SMALL LANGUAGES. LARGE CONSEQUENCES.DEPTH FIRST. THEN REACH.
Start with one real system.
Prove it there.
Editing and technical references work across repositories. Rosetta's built-in runtime verifier currently supports MUMPS/YottaDB only. Other languages can use their own project checks; additional Rosetta runtime adapters remain future work.
RUNTIME IMPLEMENTEDMUMPS / YOTTADB
Start where the code
meets the record.
MUMPS is Rosetta’s first executable language. Inspect routines, evaluate changes, and compare captured global state using YottaDB.
A PUBLIC WINDOW INTO HEALTHCARE
The VA publishes a FOIA version of VistA. It is an optional public corpus for exploration; Rosetta can work with a supplied MUMPS corpus.
VA / FOIA VERSION OF VISTA ↗Connect a model of your choice. No trained specialist model weights are bundled today.
07 / EVIDENCE BEFORE CONFIDENCEEXECUTABLE EVALS & BENCHMARKS
Measure whether the tool
earned your trust.
Rosetta measures repair success and false confidence on held-out tasks. The cases, traces, and verdicts stay available for inspection.
Same cases.
Observable differences.
Compare baseline and candidate source with a case suite. Inspect the report for output differences, captured state changes, and invalid runs.
Measure the repair.
Keep the evidence.
Compare baseline repair attempts with attempts that receive harness verdict feedback. Use held-out tasks and saved traces to examine repair success and false confidence.
Better language models.
Earned through evaluation.
Use executable feedback to guide language-specific model development. Specialist training remains on the roadmap; current claims stop at implemented tooling.
Benchmark tooling is available. No model-performance numbers are presented on this page.
Inspect the benchmark code ↗08 / DOWNLOAD ROSETTASTART IN YOUR TERMINAL
The next critical change
deserves proof.
Install Rosetta and open it in your codebase. The built-in verifier is available for MUMPS/YottaDB projects.
Explore the repositoryONE COMMANDChecksums, verify-first install, and uninstall
Python 3.11+ and the OpenCode terminal engine. Installs into your home directory; no sudo, no shell profile edits.
01 / INSTALL
curl -fsSL /install.sh | sh02 / OPEN ROSETTA HERE
rosetta03 / CHECK THIS PROJECT
rosetta status04 / SEE THE THESIS, OFFLINE
rosetta demoThe installer verifies the release against its published SHA256SUMS and refuses a mismatch. It leaves the OpenCode engine executable intact and adds Rosetta's TUI presentation. See the MUMPS coding demo. rosetta demo replays recorded evidence offline; live MUMPS verification needs a dedicated YottaDB environment provisioned by your team.