IBM i modernization
Migrate off IBM i.
Prove nothing broke.
Constat rewrites your RPG and COBOL as safe Rust, moves DB2 to PostgreSQL, and unhooks the middleware your programs depend on. Then, program by program, it proves the new system produces the same business result as the old one on your own inputs. No big-bang cutover. Nothing dropped silently. No vendor lock-in. It runs entirely on your own infrastructure, so your code and data stay with you.
-
Program-scoped equivalence
old and new run on the same inputs, results you re-check yourself
-
Whole IBM i estate
RPG, COBOL, DB2, middleware, dependencies
-
Verified engine
code generation backed by machine-checked proofs (Lean 4, Z3, CVC5)
-
Humans and agents
a CLI for engineers, MCP tools for AI agents
-
No big-bang
old and new run side by side until you trust it
The proof, in numbers
- 33,784
- machine-checked theorems0 sorry · 4 named axioms
- 53
- programs sealed run-on-bothvs live IBM i V7R5
- 44
- public NIST programs byte-exacton real IBM i, look them up
- 50/50
- workspaces audit COHERENTre-checkable
Why now
Your IBM i works. That's exactly the risk.
Because it runs, it never makes this quarter's roadmap. Meanwhile, three clocks are ticking.
- 01
The experts are retiring
The people who understand your RPG and COBOL are leaving. Every year the code gets harder to change and easier to break.
- 02
The bills keep climbing
Proprietary hardware. Proprietary database. Per-core licensing. You pay more every year just to stand still, and the migration you keep deferring only grows.
- 03
The logic is irreplaceable
Decades of business rules live only in this code. Lose them in a rewrite and you find out in production, in an audit, or in court.
Don't wait for a failure to force the change.
Plan the move while you're in control.
The whole estate
The whole stack moves, or the lock-in stays.
A converter that only touches source code leaves you on the same database, the same middleware, the same platform. Constat moves every layer, and marks each with the assurance behind it.
- 01 RPG, COBOL to Rust
Your code
RPG and COBOL become clean, memory-safe Rust with no unsafe code in your business logic. Readable, testable, and yours to recompile, so it drops into a modern stack.
Rust memory-safe yours - 02 DB2 to PostgreSQL
Your data
PROVENDB2 for i moves to PostgreSQL with its schema and defined behavior preserved. This is the lane we test hardest.
PostgreSQL schema intact behavior checked - 03 CL, MQ, 5250 decoupled
Your middleware
Job control, message queues and green screens get unhooked from the platform instead of dragged along.
unhooked replaceable independent - 04 No vendor lock-in
Your dependencies
OPENThe lock-in leaves with the migration. You keep open Rust and open PostgreSQL, on your own infrastructure.
open stack own infra no lock-in
What we read
Your whole source tree, not just the easy files
One pipeline takes the languages an IBM i estate is actually written in. Each lane is handled on its own terms, and each carries its own maturity label, never a blanket claim.
Proven, not promised
We don't ask you to trust it. We show you.
Proving a rewrite behaves like the original is hard, and most modernization tools do not attempt it. Constat runs your program on real IBM i and the Rust on the same inputs, then hands you the byte-for-byte comparison to check yourself.
Why Rust
A target you can still trust in twenty years
Moving off one legacy platform onto another buys you nothing. Rust is chosen for reasons that outlast the migration.
Memory safe, no garbage collector
The compiler rules out whole classes of failure: buffer overflows, use-after-free, null-pointer faults. There is no garbage collector, so there are no pauses in your batch window.
Reliable at compile time
The compiler rules out data races and dangling memory before the code runs. What used to be a 3am production incident becomes a build error on your screen.
No runtime, no lock-in
Rust compiles to a native binary. No JVM to license or tune, no proprietary runtime. It runs on your hardware, in your cloud, wherever you decide.
A workforce you can hire
COBOL and RPG expertise is retiring. Rust is among the most sought-after languages, with a growing pool of engineers who want to work in it.
Memory safety is now a mandate
Industry analyses from Microsoft, Google and CISA attribute around 70% of severe vulnerabilities to memory-safety bugs. Rust removes them by construction, which is why national security agencies now recommend memory-safe languages.
Why not Java
The usual COBOL target trades one runtime for another: a JVM to license and tune, and garbage-collection pauses that hit your batch window. Rust carries neither.
How we compare
The honest alternatives
Every path off IBM i has a catch. Here is where each one stands, without the marketing.
| Constat | Rewrite by hand | Lift and shift | |
|---|---|---|---|
| Behavior equivalence, re-checkable | Advantage. run both, byte for byte | Limitation. tests, if you trust them | Conditional. same code, nothing gained |
| Off IBM i, no proprietary runtime | Advantage. native Rust binary | Advantage. if you finish it | Limitation. the runtime comes along |
| Database modernized (DB2 to PostgreSQL) | Advantage. the lane we prove hardest | Conditional. by hand, separately | Limitation. DB2 stays |
| Output safe and maintainable | Advantage. memory-safe Rust | Conditional. depends on the team | Limitation. the same legacy code |
| Evidence you can audit | Advantage. proofs and a dossier | Limitation. none | Limitation. none |
How it works
From source to safe Rust, in one pipeline
One pipeline turns your IBM i sources into a Rust workspace that builds and runs. The arithmetic, the collation, the record layouts: reproduced exactly, not approximated.
Built for how you work now
Your engineers drive it. So can their agents.
Constat is a tool, not a black-box service. Engineers run it from the command line. AI agents call the same engine through MCP (Model Context Protocol) tools to transpile, audit, and verify. Same engine, same guarantees, either pair of hands.
A CLI your team owns
One command in, a Rust workspace and its evidence out. Scriptable, inspectable, and yours to run on your own machines.
$ axiom transpile payroll.rpgle --audit→ verify ok · audit COHERENTMCP tools, same engine
An agent applies the same verified process to hundreds of programs, which is what an estate-scale migration actually needs. The same proofs hold at every step.
mcp__axiom__transpile(src, audit=true)→ { verdict: "COHERENT", rc: 0 }Plain language
The jargon, defined
No decoder ring needed. Hover or tap any term to see it in plain words.
Questions
The hard questions, answered straight.
Do I have to trust that the output is correct?
No. We run your original on a real IBM i and the modernized Rust on the same inputs, then compare the resulting business state byte for byte. The evidence travels with each program, and one command re-checks it end to end. You verify the result; you do not take our word for it.
What about programs you have not run on both systems yet?
The equivalence claim is scoped to each program we run on both the original IBM i and the modern Rust. The pipeline still transpiles the rest and the verified engine still applies, but we do not call a program equivalent until it has been compared on real hardware against its modern twin. We tell you exactly which programs sit at which level, and an unproven program is never folded into a headline number. You grow the proven set one program at a time, at the pace you set.
Which languages and files can Constat read?
ILE COBOL, RPG IV in both fixed and free format, embedded SQL, DDS and CL. COBOL on IBM i is the lane we have proven hardest; RPG is a working and fast-moving frontier. If you are unsure whether your estate fits, send us one program and we will tell you plainly.
What happens to my DB2 database?
It moves to PostgreSQL with its schema and defined behavior preserved, and that is the lane we test hardest. Message queues, job control and green screens are modernization targets we validate inside each engagement. We label them as targets, never as proven.
Will the modernized system behave differently?
That is the exact thing we set out to rule out. On the same inputs, the Rust has to produce the same business state as your program on real IBM i, down to the last digit of decimal arithmetic and the collation of every field. If one byte differs, we see it before you do.
Is this a big-bang cutover?
No. You start with one program, get its evidence, and judge it before committing to more. Old and new run side by side, program by program, at the pace you set. There is no push-button switch for a whole estate, and we would not trust one either.
Is the Rust something my team can own?
Yes. It is readable, memory-safe Rust with no unsafe code in your business logic, on a runtime you compile yourself. It builds to a native binary with no proprietary runtime to license, on your own infrastructure. You trade IBM i lock-in for Rust your team owns and recompiles.
Start
Bring us one program.
Pick a real program from your estate. We modernize it, prove it equivalent, and hand you the evidence. You judge the result before you commit to anything bigger.
Thank you. We will be in touch shortly.