For companies running on software nobody dares to touch

Your legacy software, rebuilt. Without stopping the business.

We watch how your product is used today, write down every rule it follows, and rebuild it from that record. Each part is proven against the original before it goes live. The first part is free, so you see the result before you decide anything.

See it work on your product, free

Observed · a sample orders app

A rule nobody wrote down Save needs a region first

Written down · 11 scenarios

Create order · 11 scenarios

Scenario 03

Givena new order, no region

Whenthe user presses Save

ThenSave stays disabled

  1. 01Create an order with a region
  2. 02Totals round per line
  3. 04Discount override, admins only
  4. 05–117 more

Rebuilt

Proven

11 / 11 scenarios

From our delivery work so far

To date

100M+

lines of legacy code modified

To date

100B+

AI tokens spent

One round

28 AI agents

working in parallel on 4 machines · 800+ branches · 1–1.5M lines

The old product holds rules nobody wrote down.

That is why rewrites fail: the new version misses rules nobody knew were there, and your customers find them first. It is why quotes stay vague, and why you depend on the few people who remember.

So we record what your product actually does, before anyone writes new code.

Sample: what the documentation says against what the old product actually does
What the documentation saysWhat the product actually does
Save submits the order.Save stays disabled until a region is chosen.
The total is the sum of the lines.Each line is rounded first, then added.
Nothing about discounts.Admins see a discount override. Nobody else does.

Three phases · thirteen steps

We don't guess what your product does. We record it.

01 · Free · steps 1–5

Discover & prove

We use your product the way your people do and record what it does, screen by screen. We map every flow (one complete task, like creating an order), write each one down as plain-language test cases, and rebuild one of them end to end, without touching your live system. No source code needed.

  1. 01 Capture · steps 1–2Run, capture01CaptureWe record your product from outside, in a browser. No source code.
  2. 02 Map · steps 3–4Map, specify02MapEvery flow named and written down as test cases.
  3. 03 Prove · step 5Prove03ProveOne flow rebuilt end to end, free. Your live system untouched.

02 · Steps 6–11

Understand, architect & estimate

Then we trace the rules that never reach a screen, agree the new technology, and price the rest from the flow we already proved. How we go that deep is your call: our engineer inside your team, an export your own people run, or access under NDA.

  1. 04 Size · steps 6–11Analyze, trace, architect, benchmark, plan capacity, estimate04SizeThen we trace what recording can't see, agree the technology and price the rest.

03 · Steps 12–13

Generate, migrate & hand over

AI builds the remaining flows in parallel, people check every one, your data moves over in stages, and we hand everything over.

  1. 05 Generate · steps 12–13Generate, handover05GenerateEvery remaining flow builds in parallel. You approve what goes live.

See all 13 steps

Capture

  1. 1Run access the product
  2. 2Capture record from outside

Map

  1. 3Map inventory every flow
  2. 4Specify scenarios, edge cases

Prove

  1. 5Prove one flow rebuilt, free

Size

  1. 6Analyze hidden rules, dependencies
  2. 7Trace logic, data, APIs
  3. 8Architect stack, infrastructure
  4. 9Benchmark size from the first flow
  5. 10Plan capacity compute, agents
  6. 11Estimate scope, time, cost

Generate

  1. 12Generate build, integrate, verify
  2. 13Handover migrate data, deliver the result

What you have at the end

  • A modern system that does what the old one did, proven flow by flow.
  • Everything it does written down, so you no longer depend on who remembers.
  • Everything handed over: code, tests and data, on your own infrastructure.

Old on the left. Rebuilt on the right.Old on top. Rebuilt below.

Every rebuilt flow is checked against the old product, case by case. Where they differ, you see it, and we tell you before you find it.

Example · a fictional orders app

Sample pilot report: six flows, scenarios passing against the old product
FlowScenarios passingNoteResult
Sign in6 / 6Match
Search customers9 / 9Match
Create order11 / 11Match
Order total7 / 8Total due rounds per line, not per orderDiff
Issue invoice10 / 10Match
Close period7 / 7Match

What recording can't see

So step 6 goes deeper, the way you choose: our engineer inside your team, an export your own people run, or access under NDA.

  • Batch jobs and scheduled tasks
  • Back-office and admin-only rules
  • Private integrations
  • Data effects that never reach a screen

FreeOne flow of your product · claim it now

See your product rebuilt before you commit.

One complete flow of your product, say creating an order, rebuilt for free, without touching your live system. No source code, nothing to pay.

Takes a minute · no commitment

What you get · steps 1–5

  1. 01
    A map of your product

    Every flow it has, who uses it, what it depends on, and the open questions.

  2. 02
    One flow written down

    What it does, rule by rule, with plain-language test cases.

  3. 03
    That flow rebuilt and working

    Running on our side, with the evidence; every difference from the original recorded.

  4. 04
    An assessment

    How complex the rest is, what access we would need, a first sizing. Not a quote.

Tell us about the product.

We reply with the flow we would start with and a first sizing. Not a quote.

Add details · optional
Lines of code
Codebases / services
Age of the codebase · optional
Self-run pilot · optional

What happens next

  • Send your email. That is all we need.
  • We reply with the flow we would start with and a first sizing.
  • We record, rebuild and prove that flow, free. You decide after.

After one proven flow, the rest builds in parallel.

The groundwork · ours

Groundwork

Recording your product, mapping its flows, writing them down, proving the first one. This is the heavy part, and we do it without taking your team's time.

The build · ours

Generate

Then every remaining flow is built at the same time on our platform, with as much computing capacity as the work needs. Building is not the slow part.

The handover · yours to keep

Hand over

Each flow comes back verified against the old product, with the evidence. It goes live when you say so, and the old product stays live until then.

The timeline is set by the data migration and the pace you want to go live at, not by how fast code can be written.

Meanwhile

Your team keeps shipping. Nothing freezes.

A rewrite usually means a feature freeze and your best people in workshops. Not here. Your team keeps working on the old product as usual. We work alongside, on our own, record what changes, and switch each flow over when it is proven. The old product retires flow by flow.

Compared

Three ways to modernize, side by side.

Where each one starts, what you see before you commit, and what you hold at the end.

Three ways to modernize compared: a classic rewrite, in-house with AI assistants, and Actogram
A classic rewriteIn-house with AI assistantsActogram
Starts fromThe spec and the old codeThe old codeHow your product actually behaves, from the outside
Before you commitA proposalA trial licenceOne flow rebuilt and proven, free
PaceMonths per releaseWeeks per featureEvery flow built in parallel; you set the go-live pace
Your team's timeThe whole projectThe whole projectA few answers, when we ask
How quality is checkedThe vendor's QAAd hoc, per developerAutomated checks and human review on every flow
The old product meanwhileFrozen or forkedChanged in placeKeeps running and keeps shipping until each flow is proven and switched
What your team has afterNew codeNew code and new habitsCode, documentation, tests and data, handed over

A classic rewrite

Starts from
The spec and the old code
Before you commit
A proposal
Pace
Months per release
Your team's time
The whole project
How quality is checked
The vendor's QA
The old product meanwhile
Frozen or forked
What your team has after
New code

In-house with AI assistants

Starts from
The old code
Before you commit
A trial licence
Pace
Weeks per feature
Your team's time
The whole project
How quality is checked
Ad hoc, per developer
The old product meanwhile
Changed in place
What your team has after
New code and new habits

Actogram

Starts from
How your product actually behaves, from the outside
Before you commit
One flow rebuilt and proven, free
Pace
Every flow built in parallel; you set the go-live pace
Your team's time
A few answers, when we ask
How quality is checked
Automated checks and human review on every flow
The old product meanwhile
Keeps running and keeps shipping until each flow is proven and switched
What your team has after
Code, documentation, tests and data, handed over

Three ways to work with us. Your rules every way.

What you keep

You own the result. We build it and hand it over.

  • The product's source code and release assets
  • Every flow written down, with its test cases
  • Automated tests and quality checks
  • Architecture and data records
  • Data migration records
  • Decision logs

Questions

Do you need our source code?
Not to start. The free pilot works from the product as your people use it, in a browser. The flows recording can't see are covered later, in the way you choose: our engineer joins your team, your own people run an export we give them, or we get access under NDA. Where something can't be seen from outside, we simulate it, label it clearly, and never present it as proven.
Can we start without giving you any access?
Yes. Run the self-run pilot in Claude Code on your own machine: it reads your repository locally, measures one flow, writes its spec, rebuilds it on your branch, and produces a sheet of counts and sizes. Only the sheet reaches us. What the session reads goes to your model provider under your own terms. Ask for the handout in the form.
Do you touch the live system?
No. Recording watches the product work and never changes your live data. The rebuilt flow runs on our side, never inside your live system.
What does the full engagement cost?
The pilot is free, with no commitment. The rest is priced after the pilot and the architecture decision, flow by flow from the map we build: the build itself, integration and checking, human review, infrastructure and data migration. We don't quote before we have seen the product.
How fast is it?
Fast where it counts. The first flow is proven in the free pilot, before any commitment. After that the remaining flows are built in parallel; the timeline is set by the data migration and the pace you want to go live at, not by how fast code can be written.
Do we depend on you afterwards?
No. You keep everything we build for you: the code, the documentation, the tests and the data.