AI-assisted · engineer-checked · equivalence-proven · non-production only
You buy a result — a decision on which modernization approach fits your estate, a set of programs converted to Java and proven equivalent, a conversion verified, a program documented — at a fixed price per estate slice, per program, per batch chain or per thousand lines. AI agents do the first pass of the work through governed MCP tools on the SteelFrame platform; our engineers check every result; a byte-level equivalence proof is the guardrail on all of it. Everything happens in non-production. Your production system is never touched — you promote what we prove.
// every service on this page runs the same governed loop, in non-production your artefacts → COBOL, JCL, copybooks, BMS, sample data — under NDA, into a private SteelFrame workspace agent → an AI coding agent works through scoped MCP tools: reads, inventories, drafts, converts, writes tests oracle → the ORIGINAL program runs on SteelFrame: run_capture / export_state / cics_run_script — the expected values compare → the agent's output diffed byte for byte against the run; every difference declared with a reason or flagged engineer → reads the source, the transcript and the diff; fixes what the comparison named; signs the deliverable you → receive code, document or evidence pack with the transcript and capture ids; promote through YOUR change process // the agent never judges equivalence and never touches a live system; the audit log holds every tool call it made.
Explain program structure, inventory an estate from the artefacts, draft a specification, scaffold tests, produce a first conversion, propose a fix for a named defect — fast, and tirelessly, at any hour. Our engineers used to spend most of a documentation or conversion job on exactly this first pass.
Judge whether two programs behave the same; supply an expected value from memory; notice the rule hidden in a PIC clause or a COMPUTE truncation; stop itself from inventing a business rule. Every one of these is handed to the running original on SteelFrame and to an engineer, never to the model.
The agent's tool-call log and transcript, the capture ids of the runs it was judged against, the diff, and the engineer's sign-off — in every deliverable, so your auditors can follow who did what. We say in writing which parts an agent drafted.
The entry offer · assessed on paper, proven on the Proving Ground
Before you commit a budget to one modernization approach, find out which one fits your estate — and prove it. Phase A is the assessment every programme starts with: inventory, dependency graph, complexity, a disposition per application. Phase B is the Proving Ground: three to five of your programs actually run through rehost, refactor to Java and AI-assisted conversion with your own coding agent, each judged by the running original. One offer, one evidence pack, one decision you can defend.
Watch Phase B's loop: "AI Assisted Modernization MCP — Session 1.3 Tests", from our CS550 course recordings. A coding agent in the browser VS Code seat writes a unit-test deck for a CardDemo program through the SteelFrame MCP; the lesson is that test scaffolding is cheap and the expected value has to come from a SteelFrame run of the original, never from the model. The same loop, with the same tools, is what the Proving Ground and every service on this page run. Open on YouTube ↗
Your artefact pack — source, copybooks, JCL, BMS, scheduler definitions, sample data, under NDA — goes into a private SteelFrame workspace. From it: the estate inventory and dependency graph (programs, jobs, copybooks, maps, clusters, tables, call graph, batch DAG) as data, not slides; complexity and risk per program, including the undocumented rules the agent surfaces and an engineer confirms; and a disposition per application against the nine modernization styles in three families that CS500 teaches — rehost and COBOL-on-the-JVM; transliteration, tool refactor, AI-assisted and rewrite; package, hybrid and data-first — with the factors cited, the lock-in each hides and the verification each needs. Plus cost shapes per candidate approach and the verification plan.
Three to five representative programs — the ones Phase A says the decision turns on — are run for real. Golden runs of the originals first. Then rehost as-is on the compatible platform; one program rebuilt in idiomatic Java/Spring by our engineers (the CS520 method, with a rules file of declared differences); the same program converted by your coding agent over MCP under a scoped token (the CS550 loop). Every result is diffed byte for byte against the golden. What matched, what did not and why becomes the evidence pack that makes the Phase A dispositions defensible — and the basis of a fixed price for the next step, or an honest "do not move this one yet".
// Phase B, step by step (SteelFrame, z/OS-compatible side) seed → your COBOL/JCL/copybooks/BMS into a private workspace; or CardDemo as the stand-in inventory_scan → programs, jobs, copybooks, call graph, batch DAG — the estate as data, not slides golden → run_capture / export_state / cics_run_script of the ORIGINAL: spool, datasets, screens, checksums rehost → the application runs as-is on the compatible platform; what it does and does not solve refactor → one program rebuilt in idiomatic Java/Spring by our engineers (the CS520 method) agent → the same program converted by YOUR coding agent over MCP, scoped token, every call audited compare → every output diffed against the golden; differences declared with a reason or listed unexplained report → the evidence pack: what matched, what did not, why, and a fixed price for the next step // the platform never judges equivalence and never converts code; the comparison is a separate, // visible step — and your licensed system remains the sole conformance authority.
Why buyers are asking for this now, from the public record: Gartner predicts that more than 70% of mainframe exit projects started in 2026 will fail to deliver because generative AI's capabilities were overestimated, and advises limiting full exits to case-by-case scenarios[1]; ISG reports enterprises prioritising "continuity over replacement", applying different modernization patterns per application portfolio and demanding built-in validation, testing and rollback[2]; Kyndryl's 2026 survey of 2,000 leaders finds 99% have delayed a modernization project and 48% are behind schedule[3]. Modernization assessments are a standard first purchase — Accenture, for one, recommends "a short, 6-week consulting engagement … focused on driving out appropriate treatment strategies"[6] — and Google now offers a pilot to "pick one application to modernize" with its own tools[4]. On what the agents themselves can do, we side with the practitioners who report that AI compresses understanding and drafting but does not remove verification, equivalence testing and parallel running — "many exit projects conflate 'AI can explain this code' with 'AI can safely migrate this code'"[5].
All three are AI-assisted the same way, all three are fixed-price, all three are delivered in non-production, and all three end in evidence. Two are where we ask new clients to start; the conversion follows an Approach Assessment or a scoping call.
| Service | What you buy | Priced as | Where it sits |
|---|---|---|---|
| Modernization as a fixed-price project | an agreed set of COBOL or Assembler programs converted to Java for an agreed price — agent-drafted in the style you choose, engineer-finished, equivalence proven on SteelFrame before handover | fixed price per scope, quoted after a Modernization Approach Assessment or a scoping call | After the assessment |
| Equivalence testing as a service | you (or your vendor, or your AI tool) convert the code; we prove the new build behaves like the original — batch by record layout, screens by BMS field, data to your own control totals, every difference explained or listed as unexplained. The agent drafts scenarios and harnesses; the oracle run supplies every expected value | fixed price per program or per batch chain; per re-run during parallel running | Start here |
| Legacy code documentation | undocumented COBOL, JCL, copybooks and CICS programs reverse-engineered into readable specifications: purpose, inputs and outputs, business rules with the source line that implements each, call graph, data lineage. The agent drafts; every rule is confirmed by running the program and checked by an engineer | fixed price per program or per KLOC | Start here |
Standing environments and test data — a modernization rehearsal environment, a shop-standard image, project test sandboxes loaded with masked or synthetic data — are on the engagements page and the environments page, not here.
Each block says where the agent works, where the engineer works, and what the guardrail is — because "AI-assisted" should mean something specific.
The situation: you have decided which programs move and in which style — ideally after a Modernization Approach Assessment — and you want a number that does not grow with the team's timesheets.
What you receive: the agreed COBOL or Assembler programs converted to Java in the agreed style — idiomatic Java/Spring refactor, faithful transliteration, or agent-led conversion with engineers finishing every result — with equivalence proven on SteelFrame against golden runs of the originals before handover. Differences are declared in writing with a reason, or they are defects we fix before you pay. Code, tests and the evidence pack are yours.
AI-assisted how: the agent produces the first conversion in the chosen style and the first test suite; the suite's expected values are SteelFrame runs; the agent is then allowed to fix only what the comparison named, in a loop the engineer watches; the engineer finishes the code to the craft rules (money as decimals, every I/O path handled, layering) and signs it. The green comparison is the acceptance gate, not the agent's confidence.
Priced: fixed price for the agreed scope, per program or per KLOC, quoted after scoping. Proof on SteelFrame is the acceptance gate; proof on your licensed system, with goldens your staff capture, is the go-live gate and is scoped with you. We hand over; you deploy.
The situation: your conversion vendor — or your own team, or an AI tool — reports percent-complete. Your auditors ask whether the new system computes what the old one computed. Row counts answer the copy; they do not answer the arithmetic.
What you receive: baseline outputs produced by actually executing your batch and transactions — your programs, your job streams, masked or synthetic data — then a byte-level comparison of the converted system's reports, posted state and screens against that baseline, program by program. Every divergence comes explained with evidence or flagged unexplained; a cause is never invented to close a ticket. The same method, with the same tooling, as our migration-verification engagement, sold here per program so you can start small.
AI-assisted how: the agent reads the programs and drafts the scenario list, the edge cases and the comparison harness; every expected value comes from a SteelFrame run of the original, never from the model; the engineer reviews the scenario coverage and explains the divergences; the diff is the guardrail.
Priced: fixed price per program or per batch chain, quoted after a scoping call; per re-run during parallel running. Target-agnostic: Java, C#, COBOL on another platform, a packaged core. Your conversion vendor stays your conversion vendor. Entirely non-production: fixtures of real behaviour are captured by your staff on your system.
The situation: the programs run; the people who wrote them have retired; the specifications, if they ever existed, describe a version from two decades ago. Every modernization plan, audit and vendor RFP stalls on the same question — what does this program actually do?
What you receive: a readable specification per program: purpose, inputs and outputs with record layouts, the business rules it implements with the paragraph and line that implements each, the programs it calls and is called by, the datasets and tables it touches, and the jobs that run it. Produced by reading the source and running it on SteelFrame — rules are confirmed against observed behaviour, not inferred from names.
AI-assisted how: the agent inventories the set (inventory_scan,
the call graph) and drafts the structure and the first list of rules from the source;
each candidate rule is then exercised with a run whose inputs make it fire; the engineer
strikes what the run disproves and adds what the agent missed — typically the rule that
lives in a PIC clause or a truncation. The delivered document names which parts began as
an agent draft.
Priced: fixed price per program or per KLOC after an inventory scan of the set. Input: source, copybooks, JCL and sample data under NDA; nothing is needed from your production system. Deliverable is offline-readable and version-pinned.
| Model | Used for | Status |
|---|---|---|
| Fixed-price project | the Modernization Approach Assessment, legacy code documentation, equivalence testing, and conversion of an agreed program set — an outcome we can define before we start and verify when we finish; everything on this page is bought this way | Available |
| Dedicated team | a named team working a programme of conversions, documentation and equivalence runs under our management, still measured on outcomes, once fixed-price projects have outgrown one-at-a-time scoping | Later |
| Build-operate-transfer | a centre we build and run for you in Manila, then hand over — people, method and platform | Future |
Every service on this page is a fixed price, quoted after a scoping call — per estate slice for the Approach Assessment; per program, per batch chain or per KLOC for the rest, and per re-run where parallel running needs one. We do not publish rate cards because we do not sell by the hour.
Sources: [1] Gartner press release, 18 Jun 2026; CIO Dive, 22 Jun 2026 · [2] ISG press release, "Enterprises Seek Structured, Low-risk Mainframe Modernization Plans", 13 Apr 2026 · [3] Kyndryl, 2026 State of Modernization Report — data sheet (2,000 leaders) · [4] Google Cloud blog, "Mainframe migration and modernization with AI", 4 Aug 2026 · [5] Open Mainframe Project, "Discovery Is Not Migration", 22 Jul 2026; mLogica, "Mainframe Modernization in 2026: From Conversion to Proof" · [6] Accenture, "Reframe your mainframe" (banking, PDF); durations of 10 days to 8 weeks are listed for comparable assessments on the Microsoft commercial marketplace (Fujitsu, Ensono, Astadia, Kyndryl, Mphasis)