Verify themigration.

Behavioral observability for AI-written software migrations. Run the original and replacement together, then isolate the first change.

See how it worksRead research

The original system remains the approved reference while an AI-written replacement is verified under the same behavioral contract. In this example, the replacement introduces a database write. Strust returns MATCH / DIVERGE / INCONCLUSIVE.

Existing softwareORIGINAL

Approved behavior

Same contractSTRUST

Run both. Compare behavior.

AI-written replacementREWRITE

Candidate migration

Example verdictDIVERGE
First changed behaviorDatabase write
Existing system
NO WRITE
Replacement
WROTE 1 ROW

The contract stays fixed while the code changes.

Strust runs existing software and its AI-written replacement against one approved behavioral boundary.

EVALUATOR FIREWALL

The writer cannot grade its own rewrite.

Candidate generation stays separate from the reference, comparison policy, and evidence history.

Writer owns
Candidate code
Verifier owns
Truth boundary
Reviewer gets
Finding and evidence
PAIRED EXECUTION
  1. Verifier

    Pin the contract

    Approve the reference, inputs, runtime assumptions, observations, and comparison policy.

  2. Runner

    Execute the pair

    Run the existing system and candidate rewrite under the same declared conditions.

  3. Comparator

    Find the origin

    Stop at the earliest contract-relevant difference, before downstream effects obscure it.

  4. Evidence store

    Retain the evidence

    Return a replayable finding to the coding agent and a reviewable decision to the owner.

One changed decision. Two useful views.

Agent view isolates the next patch. Reviewer view translates the evidence into impact and a human decision.

BEHAVIOR VERIFIER
COBOL TO JAVAIllustrative scenario B
AGENT DIAGNOSIS / F-02

First divergence: Branch action

Batch branch B-17 / null-account path

Cause isolated. Patch the changed behavior and rerun.

REFERENCECOBOL
TRACE CAPTURED

IF ACCOUNT-ID = SPACES

NEXT SENTENCE

ELSE PERFORM WRITE-CLAIM

END-IF

CANDIDATEJAVA
TRACE CAPTURED

if (accountId == null) {

writeFallback(claim);

} else { writeClaim(claim); }

batch.advance();

EXECUTION CHECKPOINTS
  1. NULLAccount input
    NULLEQUIVALENT
  2. TRUEGuard B-17
    TRUEEQUIVALENT
  3. SKIP_WRITEBranch action
    WRITE_FALLBACKORIGIN
  4. 0Rows emitted
    1CHANGED
  5. UNCHANGEDBatch count
    INCREMENTEDCHANGED
FIRST DIVERGENCE

The first changed decision is Branch action: the source returns SKIP_WRITE while Java calls writeFallback.

Before you run a comparison.

What the verdict means, and where the evidence stops.

What does Strust compare?

The approved reference and candidate run with the same inputs, runtime assumptions, observations, and comparison policy. Strust looks for the first difference within that declared contract.

Does MATCH mean the rewrite is correct?

MATCH means the declared observations agree for the compared execution. It does not establish correctness for every input or for behavior outside the contract.

When is a result INCONCLUSIVE?

When the evidence does not support a comparison under the declared contract. Missing or unsupported evidence must remain distinct from a match or a behavioral difference.

Is the demo a live verification run?

The demo contains illustrative COBOL-to-Java scenarios. Replay walks through the example evidence; it does not execute your code. The research page explains the method and its evidence limits.

Bring the rewrite you cannot afford to get wrong.

Tell us what is changing and what behavior must stay the same.

Contact Strust