Documentation + behavioral confirmation
Understand your legacy code — before you change it.
Decades of business rules are buried in code nobody fully understands, and the people who wrote it are retiring. Agentyx produces grounded, line-traceable documentation — and confirms each rule against real runs of your program — so you capture what your system actually does. Read-only, lowest-risk, and your source can stay on your premises.
Why this exists
“Nobody here knows what the code actually does anymore.”
It's the fear behind every stalled modernization. Decades of business rules are undocumented, the SMEs who understood them are retiring, and modernizing what you can't explain feels reckless — because it is. The honest first move is to capture and verify what your system does, before you change a thing.
It's also the lowest-risk place to start: documentation changes nothing in your running system, so it clears risk and procurement at the lowest possible bar — and it has its own urgent driver. The knowledge is walking out the door with every retirement; this captures it while you still can.
How it works
Read the source
Agentyx generates grounded specifications, business rules and runbooks from your actual code — not a summary an LLM invented.
Trace every statement
Each documented behavior maps to the exact source line it came from. Documentation you can verify line by line, not an AI's plausible-sounding guess.
Confirm against real runs
Behavioral confirmation: we run your original program and check each rule against its real output — on the scenarios we can run — so the doc is demonstrated, not just asserted.
Keep the corpus
Those input/output scenarios aren't throwaway — they become your parallel-run test corpus when you modernize, so the work compounds.
What you get back
- →Grounded specifications, business rules and runbooks — from your real code.
- →Every statement traced to the exact source line — verifiable, not a guess.
- →Each rule confirmed against real runs of your program (on the scenarios we can run).
- →A reusable test corpus — the confirmed scenarios become your parallel-run corpus at modernization.
- →A read-only deliverable — nothing in your running system changes; your source can stay on your premises.
What we can confirm — and what we report
Computational and batch logic runs cleanly and confirms well. Interactive programs (CICS / BMS screens), VSAM/DB2-heavy code, or externally-integrated paths need recorded traces or fixtures to execute in isolation — so we confirm the computational core strongly and the IO-heavy parts on the scenarios we can run.
And we report coverage honestly: each rule is “confirmed on N representative cases,”never “every rule proven on every input.” A hallucinated spec of a core program is worse than none — so where we can't confirm, we say so, and the traceability still lets you check every claim against its source line.
Why it's different
Grounded, not hallucinated
Every statement traces to a source line you can check — the opposite of pasting code into an LLM and trusting the summary.
Confirmed, not just described
We run your program and check each rule against its real output, so the documentation is demonstrated on real behavior — not asserted.
Reusable, not throwaway
The confirmed scenarios become your modernization test corpus — so understanding the system also de-risks converting it.
Start where the risk is lowest
Capture and verify what your mainframe does — before you change a thing, and before the last expert walks out the door. When you're ready to modernize, the docs and the confirmed scenarios are already in hand.