The migration
you can prove.

The business case

A mainframe estate carries three costs at once: the risk of a migration that goes wrong, the bill for staying where you are, and the clock on the people who understand the code. Bylazora answers the first, and changes the arithmetic on the other two.

We are equally honest about the other side: mainframes are reliable and cheap per workload. The argument is the licensing trajectory, the skills cliff, and the strategic cost of lock-in, not that the mainframe is broken. And there is nothing to procure to evaluate any of it: the engine is free, and the proof trial takes one job and an afternoon.

How you would actually use it

A migration is a queue of jobs, and every job is the same loop. The gate does not care what language the replacement is written in, who wrote it, or whether an agent drafted it: it compares outputs, byte for byte. The reference directory defines the contract.

# one job becomes a sealed workspace
$ bylazora-core migrate new batch-txn \
    --input transactions.csv --input balances.csv \
    --output final_balances.csv --output summary_report.csv \
    --copybook TXNREC.cpy --cobol-source BATCHTXN.cob

# the legacy output is the contract
$ bylazora-core migrate reference batch-txn
sealed reference: 2 file(s)

# write the routine, then run the gate
$ bylazora-core migrate verify batch-txn
IDENTICAL

# the verdict trail is append-only
$ bylazora-core migrate status batch-txn
job batch-txn (rust)
  inputs : transactions.csv, balances.csv
  outputs: final_balances.csv, summary_report.csv
  sealed : yes
  verdict: IDENTICAL (attempt 1, 0 diffs)

The worked example is in the repository: sample/ is a sealed migrate workspace, a COBOL batch job with its GnuCOBOL capture and its migrated Rust target. CI re-derives the reference from the COBOL, asserts the seal, and runs the gate, so a single differing byte fails the build. That is the template. Copy the shape, swap in your job.

Point your coding agent at the gate

The MCP server ships inside the same binary. Point Claude Code, Cursor, Copilot or any MCP client at it and your agent can drive the engine: draft a migration, run it on your data, and read the verdict back as a diff. What it cannot do is mark anything proven. Only the validator does that, byte for byte, against your legacy reference. The agent proposes; the gate disposes.

# wire a client in one command
$ npx bylazora setup claude
wrote .mcp.json

# or serve the tools directly
$ bylazora mcp
JSON-RPC 2.0 over stdio, no network

# the config it writes: node plus the CLI;
# the engine path is discovered, never
# hardcoded, and works on every platform
{
  "mcpServers": {
    "bylazora": {
      "command": "node",
      "args": [".../cli.js", "mcp"]
    }
  }
}

# the tools the agent gets
validate        byte-compare against the
                legacy reference
bench           run a tier, report wall time
copybook_parse  read a COBOL copybook
migrate_verify  build + gate a job workspace
migrate_status  the contract and the verdict

# the one thing no tool can do
mark a run proven    <- the validator only

This is what the byte-exact gate was built for. A model that drafts a migration is useful; a model whose draft has to survive a byte comparison with the legacy system is trustworthy. Those are different claims, and only one of them can be checked.

Get the engine

One binary, every platform. Prebuilt and signed for the platforms below, and published as source on crates.io, so any machine with a Rust toolchain can build it too. Every binary carries a sha256 and an Ed25519 signature, verifiable offline against the published public key.

Which tier runs where

The honest NVIDIA point: CUDA is an optional acceleration path, never a requirement. The wgpu tier is byte-exact on the same NVIDIA cards, which is why it ships on every platform while CUDA ships on one. An estate without NVIDIA hardware loses nothing but a fraction of headline speed, and the gate's verdict is identical either way.

# from crates.io (any platform with Rust)
cargo install bylazora-core

# or the signed binary for your platform
# https://github.com/bylazora/bylazora/releases

# the agent CLI on npm: setup, rules,
# template, and the delegated loop
npm install -g bylazora

# wire your agent in one command
bylazora setup claude

# then point your agent at the gate
bylazora mcp

The governed migration cycle

Seven phases. Governance artifacts at every step, inspectable by you at any time.

1. Grab. We take custody of your code and documentation with provenance and access controls.
2. Review. AI-assisted analysis builds the function inventory: what each program does, what it touches, what is dead code.
3. Rebuild. Each function is re-implemented, recompiled, or AI-drafted then engineered onto its assigned tier. Logic is preserved 1:1 in semantics.
4. Deploy. Functions become containerized jobs on the target platform, orchestrated by a scheduler that preserves batch windows and dependencies.
5. Migrate data. DB2 tables, VSAM files, and generation datasets move to canonical formats with fixed-point decimal semantics preserved exactly, at the precision the schema declares. No float drift.
6. Test. The equivalence gate: every function must reproduce its legacy output byte-for-byte, continuously enforced. One differing byte is a failure.
7. Roll over. Dual-run shadowing against production, reconciliation, then per-function cutover. Every step reversible until sign-off.

The engine is free. The run is how we get paid.

The byte-exact gate, the three tiers, and the parsers are open source: AGPL for the engine, Apache-2.0 for the parsers. Anyone can read the validator, run it, and prove their own migration, without asking us for anything. Bylazora earns its keep on two things: the commercial licence, for estates that cannot accept AGPL, and doing the migration with you when you would rather not do it alone.

What is in the box: the byte-exact validator, the three-tier engine (CPU, wgpu, cudarc), the C ABI, the MCP server, the copybook parser and DB2 importer, the judge harness, the sample migration, and the evidence annex. What stays ours: the playbook, the corpora, the replication recipes, and pricing, the know-how, not the code. And the AI boundary: your assistant can operate the engine through its MCP interface, propose, and measure. It cannot mark a job proven. Only the validator can.

Not a test at the end

The engine is the runtime of the new solution. Six positions in a migration, one tool:

The migrated system does not merely pass a test once. It runs on the engine that tests it, and the gate is the safety system of the new estate.

The evidence

A representative COBOL batch program, per-account aggregation over transaction files, certified on the shipped Rust engine across three tiers and four scales, up to one billion rows: the CPU tier, the vendor-neutral wgpu GPU tier, and the CUDA container tier. Every output byte-identical to the COBOL reference. Three tiers share one parallel chunked host read (0.3.1): the cudarc CUDA tier leads on NVIDIA (68.8x at 1B, 8.75s), the wgpu tier holds 61.3x on any GPU or none, and the CPU tier 28.1x with no GPU.

Wall time in seconds, measured, lower is better

| SCALE     | COBOL       | CPU TIER    | GPU TIER    | GPU TIER        |
|           | (BASELINE)  | (RUST)      | (WGPU)      | (CUDA, CUDARC)  |
+-----------+-------------+-------------+-------------+-----------------+
| 1M ROWS   |        0.79 |        0.03 |        0.02 |        0.02     |
| 10M ROWS  |        5.34 |        0.11 |        0.11 |        0.12     |
| 100M ROWS |       55.59 |        2.18 |        1.54 |        0.92     |
| 1B ROWS   |      601.56 |       21.40 |        9.82 |        8.75     |
+-----------+-------------+-------------+-------------+-----------------+

The honest detail: the read path is the whole game, and all three tiers now share the same 8-thread parallel chunked reader (0.3.1). The cudarc CUDA tier holds 68.8x at 1B rows (8.75s against the COBOL reference's 601.6s), the wgpu tier 61.3x on the same card or none, and the CPU tier 28.1x with no GPU. The RAPIDS container the cudarc tier replaces measured 0.2x at 1M and 8.9x at 1B; those numbers are provenance in the annex, and the container remains the escape hatch for arbitrary jobs. The vendor-neutral wgpu tier is byte-exact on NVIDIA, and on software Vulkan with no GPU at all: the same binary runs on AMD, Intel, Apple, and the web. We publish the crossover because it feeds profiling, not verdicts: the ratios say what is worth testing on each tier. The migration team balances infrastructure and cloud options, job complexity, and batch size to choose the best value-for-money target state. You never pay for acceleration that does not accelerate.

Indicative economics

Acceptance criteria are contractual: byte-exact equivalence and the benchmark evidence. All figures are indicative planning ranges, not quotes.