Rewrite the estate.
Mainframe and AS/400 applications rebuilt as cloud-native microservices by a deterministic AI factory — equivalence proven at every station.
Retire the switch.
A cloud-native payment engine that retires legacy switch platforms — and the legacy SWIFT rail. ISO 8583 and ISO 20022 on one core, dual-run to cutover.
AI agents, built for financial operations.
Investigate payments, reconcile accounts, resolve disputes and triage fraud — custom agents grounded securely in your own data.
Every rule your business runs on, carried over. Proven, application by application.
The deterministic modernization factory for mainframe and AS/400 estates. Nothing assumed. Nothing lost. Nothing unproven.
Every application. Same stations. Same result.
Intake
Mainframe, AS/400 and legacy application estates
Legacy code base
50 years of
patched modules
Deep analysis
Business workflow, data flow & variable flow mapped
Estate mapped
Flows · interfaces
duplicates · workflow
Re-architect
Event-driven microservice blueprint, risks ringfenced
Re-architected
Domain-driven · cloud-native
event-driven
Rewrite
Human-grade code — tested, security-cleared, cloud-ready
Rewritten
Microservices · reimagined UI
tested & secured
Verify
Automated parallel comparison testing proves equivalence
Verified
Shift-left functional
& data verification
Refactor. Reimagine. Rewrite. Prove.
You've watched the line run. This is what each station does to your estate — four disciplines, applied in order to every application.
Refactor
Reimagine
Rewrite
Prove
POWERED BY OUR CORE IP — A PROPRIETARY MULTI-SCORING ENGINE THAT UNDERSTANDS CODE STRUCTURE AND DATA FLOW · DETERMINISTIC · REPEATABLE · AUDITABLE
Three engines run the line.
The machinery behind the method — each engine owns its discipline and hands evidence to the next.
Prism ™
- Complete estate map & dependency graphPrograms, jobs, data and interfaces — nothing missed
- Living as-is architectureInteractive views your teams keep using after day one
- Scope fixed before pricingAn evidence-based effort model — no mid-program surprises
Blueprint ™
- Domain model & bounded contextsBusiness functions grouped; duplication designed out
- Integration contracts defined up frontEvery upstream and downstream agreed before build
- Go / no-go with the full risk pictureYou decide on facts, not optimism
Forge ™
- Human-grade Java & Spring servicesNo emulation layers, no translator artifacts
- Verified as it generatesData-tested in development, with a validation report for every test
- Security cleared at the sourceStatic scans, SonarQube gates and penetration testing per component
- LivDoc™ documentation built inThe living system record, generated alongside the code
Pluribus
A single modern payment engine — and the gateway in front of it. ATMs and POS terminals connect to it directly; it connects out to the card networks, Interac, Fedwire, CHIPS and your SWIFT gateway. It runs beside the platforms you have, takes traffic rail by rail, and retires them without a cutover event.
- Card payments — authorization, reversals, stand-in & settlement
- Canadian payments — native Interac format support
- US wires — Fedwire and CHIPS on the same engine
- Cross-border — SWIFT ISO 20022, native, no translation layer
- One operations view — every payment traced end to end
The name: from e pluribus unum — "out of many, one." Many formats, many rails — one engine.
Don't rewrite the switch. Replace it.
IBM Connex, HP Tandem, BASE24, ACI MTS, Finastra GPP — today every payment type runs on its own aging platform. Pluribus replaces them all with one engine, takes traffic gradually, and retires platform after platform. One engine: ISO 8583 cards · Interac · Fedwire · CHIPS · SWIFT.
The industry already moved.
CHIPS and Fedwire are ISO 20022-native. SWIFT retired MT for cross-border payments in 2025. Every platform that still speaks yesterday's formats is now the risk on your books. Pluribus retires both sides of the estate — card switches such as IBM Connex, HP Tandem and BASE24, and the wire and SWIFT platforms beside them, from ACI MTS and Finastra GPP to bolt-on ISO 20022 converters.
Four reasons this is an easy decision.
Every rail, one engine
Cards, Interac, Fedwire, CHIPS and SWIFT on a single platform — one team, one rulebook, one view of every payment in flight.
Dual-run to cutover
Pluribus shadows your live switch until every response matches. Traffic moves gradually — no big-bang cutover, no missed authorization.
Stand-in built in
When a network or host drops, the engine keeps authorizing within your rules — and settles the difference when the connection returns.
50K+ TPS
One commodity cluster outruns the mainframe — with headroom for every peak you'll ever see.
| Dimension | Legacy switch platforms | Pluribus |
|---|---|---|
| THROUGHPUT | 3–20K TPS | 50K+ TPS on commodity infrastructure |
| MAX SCALE | Limited by the frame or rack | Scales horizontally — add pods as volume grows |
| PROVISIONING | 3–4 years | 1 year |
| ROUTING CHANGE | Downtime required | < 1 second · zero downtime |
MTI 0200 · financial transaction request BITMAP F23A450128E09010 DE002 541333••••••0001 · PAN (masked) DE003 000000 · processing code DE004 000000012500 · amount — $125.00 DE007 1005142158 · transmission date-time DE011 002417 · STAN DE037 927814002417 · retrieval ref no. DE039 00 · approved DE049 840 · currency — USD
<FIToFICstmrCdtTrf> <GrpHdr><MsgId>BLSC-20261005-002417</> <CdtTrfTxInf> <PmtId> <EndToEndId>E2E-927814002417</> <UETR>97ed4827-7b6f-4491-a06f-…</> <IntrBkSttlmAmt Ccy="USD">125.00</> <ChrgBr>SLEV</> </CdtTrfTxInf> </FIToFICstmrCdtTrf>
Every payment world, served in its own language.
Each payment type is a different world, with its own formats, rules and operations teams. Pluribus gives each one a first-class lane — on one engine.
The gateway your devices connect to
ATMs, POS terminals and e-commerce gateways connect directly to Pluribus. It authorizes, reverses, stands in and settles — everything the legacy switch did, plus the gateway in front of it.
Canadian payments, natively
Native Interac format support — Canadian debit traffic runs as a first-class format on the same engine, not through an adapter.
High-value payments, native
Fedwire and CHIPS have gone ISO 20022-native. Pluribus speaks it natively — not through a translation layer bolted onto a legacy gateway.
Connects to your SWIFT gateway
Pluribus connects to the SWIFT gateway and speaks ISO 20022 natively — pacs, pain and camt. The MT era ended in 2025; this is what comes after it.
What the engine speaks.
- Authorization & financial — 0100 / 0200
- Reversals & adjustments — 0400 / 0420
- Network management — 0800
- Dialects — Base24 · Interac (Canada) · UK FPS
- EMV chip data — Field 55
- Settlement & reconciliation totals
- pacs.008 — customer credit transfer
- pacs.002 / pacs.004 — status & returns
- pacs.009 — FI credit transfer & cover
- pain.001 / pain.002 — payment initiation
- camt.052 / 053 / 054 — reporting & statements
- Rails — Fedwire · CHIPS · SWIFT CBPR+
- Dual-run migration — shadow, compare, cut over
- Stand-in processing when networks drop
- Store-and-forward — reversals & advices queued through network drops
- Timeout management — every request answered within a 1,500 ms SLA
- Multi-currency with live FX
- Interchange & settlement built in
- Routing & rule changes with zero downtime
- Every payment traced end to end — one correlation ID for audit
Why one engine wins.
One rail fails, the rest keep running
Each payment engine runs in its own space. A card-side failure never halts wires, Interac or SWIFT traffic.
Scale each rail on its own
Scale card capacity for the holiday peak without touching the wire or cross-border engines.
Many rails, no extra platforms
Connect to new networks and rails from the same engine — no separate product, vendor or team per payment type.
New rules land faster
Microservice architecture means a new mandate touches one service — not a monolith release and an outage window.
Evidence, not assertion.
A selection from the portfolio — mission-critical estates across industries, all through the Bluescript Modernization Factory.
The system a bank runs its day on — rebuilt, proven, and handed back while the bank kept banking.
The system
The core accounting engine of a top-tier Nordic bank: the ledger of record behind every account, feeding 600+ applications across the estate. The bank relies on decades of PL/I, CICS and DB2 — systems that deliver stable, high-throughput performance, yet serve as the primary roadblock to open banking.
The risk
In core banking, a single mistranslated rule becomes a mis-posted balance. The quoted alternative was a multi-year manual rewrite — years of dual running, with correctness resting on human review. The board needed certainty, not optimism.
The outcome
The factory mapped the full estate before commitment, then rebuilt it as event-driven Java and Spring microservices on Kafka, with DB2 converted to PostgreSQL. Every output was verified against the bank's own production transactions during development — delivered to production on schedule, at 100% functional parity, and now the blueprint for the wider estate.
A state's offender-management platform — where an outage is a public-safety event — moved to a sovereign cloud without one.
The system
The offender management and administrative core of this U.S. state justice agency houses critical daily records, all anchored in legacy ADSO dialogs over a CA IDMS network database.
The risk
Data integrity here is not a quality metric — it is due process. The mandate was simple and unforgiving: move to a secure government cloud without stopping operations and without losing a single record.
The outcome
The estate was fully mapped — every dialog, record and network set — then rebuilt as C# .NET Core microservices on Azure Government Community Cloud, with the IDMS database converted to a clean Azure SQL relational model. Proven at 100% functional parity with production data during development, and handed to the agency's teams with operations never interrupted.
Millions of customer statements a month — re-platformed with the accuracy of a ledger.
The system
The credit-card statement and billing core of a tier-1 Canadian energy provider: a high-volume COBOL estate of nightly batch chains and CICS screens where every figure printed is a figure a customer pays.
The risk
Billing tolerates no rounding stories. A conversion error would not appear in a test report — it would appear on a customer's statement. The estate had to modernize without a cent of drift and without missing a billing cycle.
The outcome
Monolithic batch chains were refactored into scalable, event-driven Java microservices on AWS, with legacy data flows re-architected for cloud-native statement generation. Verified against production billing runs during development — 100% semantic and functional parity across the portfolio, delivered on schedule and ready for the provider's own teams to run.
AI coding assistants vs. the factory model.
Copilot-style assistants and agentic IDEs make a developer faster. A core-system migration is a different kind of problem. Thousands of programs work together as business workflows — the same functionality repeated in many places, data shared across domains, responsibilities spread across applications. And modernization is never just a code rewrite — the data, the data model and every interface must be rewritten with it. A migration like this cannot rely on code that merely looks right — every application must be proven right.
AI coding assistants & agentic IDEs
- ✕Working unitOne developer, one file at a time — powerful locally, slow across thousands of programs.
- ✕Legacy semanticsNo semantic model of COBOL, PL/I or CICS — mainframe idioms are approximated, not understood.
- ✕LineageNo view across modules — the same rule, copied into hundreds of programs, gets rewritten hundreds of ways.
- ✕ConsistencyEach run can take a different path; style and structure vary across the portfolio.
- ✕ProofNo built-in equivalence testing — correctness rests on human review, and gaps surface late.
- ✕AccountabilityA tool, not a commitment — no one stands behind the migrated system end to end.
The Bluescript Modernization Factory
- ✓Working unitThe whole estate at once — analyzed, planned and generated as one portfolio.
- ✓Legacy semanticsNative understanding of COBOL, PL/I, CICS, JCL and legacy data structures — nothing approximated.
- ✓LineageFull cross-module lineage — duplicated rules found everywhere and built once.
- ✓ConsistencyDeterministic — same estate in, same system out, uniform across thousands of artifacts.
- ✓ProofVerified during development against real production data, with a validation report for every test.
- ✓AccountabilityFixed scope and timeline, with the outcome committed per engagement contract.
Bluescript replaces the pipeline, not the developer.
Deterministic AI for the systems the world runs on.
Bluescript builds the modernization factory that moves mission-critical legacy estates to modern, cloud-native architecture; the payment engines that retire the legacy switch and the SWIFT MT rail on one ISO 8583 + ISO 20022 core; and governed AI agents for financial operations. Every system proven right before it ships.
Why we builtBluescript.
The world's most important businesses still run on systems nobody dares touch — mainframe estates built over decades, payment switches approaching end of life, operations floors held together by manual effort. The industry's answer has been more people, or generic AI that is merely probably right. For core systems, probably is not a standard.
Bluescript was founded in 2023 on a single conviction: AI applied to core systems must be deterministic, governed and provable. Same input, same output, evidence for every result — whether it is rewriting an application, routing a payment or resolving an exception.
That conviction became three products: a modernization factory that proves every application right before it ships; payment engines that retire the legacy switch and the MT rail on one modern core; and governed AI agents for financial operations. Different products, one standard — evidence, not assurances.
Three product lines. One standard of proof.
Legacy estates, reimagined
COBOL, PL/I, CICS and the systems around them — refactored, reimagined and rewritten as event-driven, domain-driven microservices, with 100% functional equivalence proven per application.
Explore the factory →Pluribus
One modern core for ISO 8583 and ISO 20022 — retiring the legacy switch and the SWIFT MT rail without drama, on your timeline, not the deadline's.
Explore Pluribus →Agents built for finance
Governed agents that investigate, reconcile and resolve on top of the modernized core — operating within the controls your auditors already understand.
Explore the agents →Built by industry veterans.
Core systems are a trust purchase. Bluescript is led by practitioners with 25+ years in the systems we build and modernize — people who have run these estates, not just studied them.
Core-systems engineering
Engineers who have built and operated mission-critical platforms across every generation of technology — mainframe, midrange, distributed and cloud — and the architectures, data and integrations those systems depend on.
Banking & payments
Leaders drawn from banking and financial services — payment switches, settlement and core banking — who know what regulators, auditors and operations teams demand of these systems.
Global delivery
Program leadership across our US headquarters and India offshore delivery center — an around-the-clock engineering model behind every engagement.
Investigate. Reconcile. Resolve. Agents built for finance.
AI agents that work your operations queues — reconciliation breaks, payment investigations, disputes, alert triage — grounded in your own data and governed like any privileged operator. Scoped duties. Human sign-off. Every action logged.
Where agents go to work.
Each agent owns one queue, follows your playbook, and documents every step — so your analysts start from a finished brief, not a backlog.
Breaks, investigated end to end
Pulls entries from every connected system, matches and classifies the break, documents each step — and closes it, or hands your analysts a complete file.
"Where is my payment?" — answered
Traces stuck, failed and returned payments across rails, gathers the context, and drafts the resolution with the evidence attached.
Representment, assembled
Builds the evidence package, applies network rules and deadlines, and drafts the case — for a human to approve and file.
Alerts, cleared with rationale
Enriches each alert, clears obvious false positives with a documented reason, and routes genuine risk to your analysts first.
First response in seconds
Scores and annotates suspect transactions with the reasoning behind each call — investigators start from a brief, not a queue.
Returns built from source data
Assembles regulatory reports and evidence packs where every figure traces back to its source record.
Autonomy you can defend to a regulator.
Agents in a bank are held to the same standard as the people they assist. Ours are built for that standard from day one.
Blast radius decides
Reversible, low-risk work runs on its own. Anything that moves money or changes an account waits for human sign-off.
Every decision, replayable
Each action carries a human-readable log — what the agent saw, what it did, and why — that a reviewer can reconstruct end to end.
Scoped, observed, reversible
An agent gets the same controls as any privileged operator — scoped access, full observability and rollback. Never a free hand.
Every agent, on the record
Each agent is catalogued: the systems it touches, its risk class, and exactly where humans sit in its loop.
Agents are only as good as the core they stand on. Ours stand on a proven one.
The factory delivers a documented, data-clean core. Pluribus runs the rails. The agents work on top — governed, grounded, never guessing. Three products. One standard: evidence.
Bring us the hardest problem you have.
A legacy estate, an aging payment switch, an operations floor run on manual effort — we'll show you the evidence before you commit.
Your legacy, reimagined.
Bring us your most complex application. We'll show you the blueprint, the risks and the plan — before you commit.
Retire the switch. Keep the lights on.
Bring us your switch inventory and your rail map. We'll show you the replacement plan, rail by rail — before you commit.
Bring us the hardest problem you have.
A legacy estate, an aging payment switch, an operations floor run on manual effort — we'll show you the evidence before you commit.
Put an agent on your hardest queue.
Reconciliation breaks, payment investigations, dispute deadlines — pick the queue that hurts most, and we'll show you a governed agent working it, evidence first.