TL;DR · All shapes →
What the operating model produces when pointed at legacy code
REFACTORY.
Legacy to cloud-native, on contract. Ships to Keystone by default.
Six specialized AI agents. One human operator. Weeks, not years. The latest generation of models compressed what used to be a multi-year refactor into a fraction of the cost — orders of magnitude lower than what it used to cost to fail at the same job five years ago. Refactory is what the productized methodology looks like. Pluggable target; Keystone is the default destination.
The math that broke
What's blocked real modernization hasn't changed in a decade-plus: the refactor to cloud-native was always prohibitive on scope, time, cost. So organizations didn't refactor. They lifted, shifted, paid the bill, and kept their architecture.
Lift-and-shift was never cloud-native. It was someone else's data center with a markup.
That math just broke.
Specialized AI agents, one per phase of the work. Parity to the original application as the contract. We call it Refactory.
38% of cloud migrations still take the lift-and-shift path; refactored apps run 25–30% lower TCO long-term. The full evidence walks the math.
The Pipeline
Six agents. One contract.
Each agent owns one phase of the loop. The Concertmaster coordinates the pipeline; the operator directs the Concertmaster.
Click to enlarge
Naming note: the Concertmaster is the agent-side coordinator — the orchestra's deputy. The Conductor is the human role across Wolfberg's operating model. Don't conflate.
Pluggable target topology
Default target: Keystone.
Pluggable elsewhere on merit.
The Architect agent maps legacy to the customer's target. The default target topology IS the Keystone shape — the AI-employee operating system Wolfberg itself runs on. Greenfield prospects build on Keystone directly. Legacy-app prospects enter at Refactory and land on Keystone with refactored code in production-ready cloud-native shape.
Pluggable means pluggable. AWS-native without Keystone, Azure or GCP equivalents, private platforms, hybrid topologies — Refactory's TAM is everyone with legacy code, not everyone who chose one substrate. The target can move mid-engagement; the Architect re-anchors. Keystone wins on the back end when it wins on merit.
The Spans
Three tiers. Three buyer questions.
Each Span answers a different decision the buyer is facing. Pricing reflects the decision, not the cost.
$10K
Assessment
Should we do this at all?
One-page report. Refactorable yes/no, rough shape, gating risk, recommended next tier.
Agents
Cartographer
Operator time
2–4 operator-hours
$25K
Assessment
What will it cost and how long?
Target topology mapped to primitives. Fixed-price Engagement quote in the $80K–$250K band.
Agents
Cartographer + Architect
Operator time
6–10 operator-hours
$100K
Pilot PoC
Show me it works on our code.
Full pipeline on one bounded module. Parity proof, runbook, 30-day support window.
Agents
Full pipeline, one module
Operator time
30–50 operator-hours
The math. A $25K Assessment scopes Engagements in the $80K–$250K range. The healthy band is 1:3 to 1:10. First three Pilot PoCs run at introductory pricing — that floor may lift to $125K–$150K once the labor profile stabilizes.
The Contract
Parity is the floor.
Discovery is named.
The Verifier treats the legacy application as the correctness oracle. Outputs that differ are defects until proven otherwise. No "improvements smuggled in." No "fixed while we were in there." The customer gets what the customer had — running on cloud-native infrastructure, at a fraction of the cost, in a fraction of the time.
When the Verifier surfaces a legacy behavior that looks unintended, it lands in one of three buckets. Never silently corrected.
-
Intended-but-undocumented
Preserve as-is. Documented in the cutover runbook so future operators know the behavior is load-bearing.
-
Bug, customer wants fixed
Priced as a scoped change request inside the Engagement. Fix is verified as a deviation, not absorbed into parity.
-
Bug, customer wants preserved
Preserved. Acknowledged in writing as a deferred-defect item with a tracking ID for future remediation.
Parity protects the customer. Discovery protects the relationship. Both are named contract clauses, never assumed.
Click to enlarge
Pilot In Flight
Java Spring Boot. Real domain. In flight.
Refactory's claim isn't generate perfect code. It's surface every gap honestly — with severity and disposition — before any cutover, in a structured artifact the customer signs.
shopizer/Catalog. Apache 2 licensed. Empirically receipted as of 2026-05-18 against slice 1 — reference data, 1,003 LOC. What got found, what got dispositioned, what's deferred to Phase 2.
Where it started
Sixteen years of accumulated e-commerce decisions.
API Layer
sm-shop / api / v1 · v2 product
Service Layer
sm-core / business / services / catalog / *
Repository Layer
sm-core / business / repositories / catalog / *
Entity Models
sm-core-model / catalog / *
Persistence
MySQL via Hibernate ORM
The shopizer codebase is 108,000 LOC across multiple modules — a Maven multi-module project running on Java 21 and Hibernate 5. Catalog is one bounded context inside that repo. Five layers deep, with V1 and V2 of the Product API coexisting because the V2 cutover never finished — a meta-discovered-delta visible in source.
108K
LOC at the repo
14,100
LOC in pilot scope
21
@Ignore'd tests
6
V1-API method-level gaps
What we did
The six AI-agent pipeline ran. Concertmaster orchestrating.
✓ Ran
Cartographer
60 modules · 427 edges · 8 gaps · 61 tests parsed
✓ Ran
Architect
60 mappings · 9-slice DAG · $2.65 API spend
✓ Ran
Migrator
Slice 1 (reference data) shipped. 13 files emitted · 10 parity assertions · $2.41 API.
✓ Ran
Verifier
8 deltas surfaced with severity + disposition. 2 Migrator-misses caught · $1.05 API.
Templated
Cutover Pilot
Feature-flag rollout shape locked. Full agent build is post-launch Tier 1.
Partial
Concertmaster
R-04 persistence module live. Full orchestration logic in flight.
Cartographer ran first against shopizer master @ 6a4a0a6. Architect ran second, producing the target topology and the dependency-ordered Migrator slice plan for $2.65 in Claude API spend. Migrator ran third on the leaf slice — reference data, 1,003 LOC — emitting 13 files of Keystone-shaped target code for $2.41 in 186 seconds. Verifier ran fourth, independently, grading the Migrator's emission against the legacy reference and surfacing 8 discovered-deltas for $1.05 in 63 seconds. Concertmaster routes everything under operator direction.
Where it ended up
A nine-slice plan. Pluggable target. Every gap dispositioned.
Migrator dependency DAG
Every legacy module maps to a target primitive. Every cross-cutting concern (auth, audit, caching) is named. Every coverage gap from the Verifier already has a customer-side disposition baked in — traffic-replay for the V2-equivalent cases, manual oracle for the cascade-delete edge case, accept-as-deferred for the SearchApi semantics. The Migrator can start tomorrow without waiting on more architectural input.
60/60
Modules mapped
9
Slices, DAG-valid
100%
Pluggable-target coverage
$2.65
Architect API spend
Primary target: Keystone L44 primitives (data.table per entity, workflow.pipeline, compliance.audit-event). Alternate: Spring Boot 3.x on PostgreSQL + Redis. Same parity contract on either path.
The blocker is the receipt
Independent grader catches what the implementer soft-pedals.
The Migrator generated 13 files of substantively correct target code for slice 1. It also surfaced four discovered-deltas of its own. But the Migrator soft-pedaled one of them — a sub-classification outside the canonical taxonomy, no severity assigned. In a different pipeline, that's how a public Lambda surface with no auth wrapper ships. The Verifier ran next, independently, against the same target code. It escalated the soft-pedaled finding to a blocker and caught two defects the Migrator missed entirely. The blocker is the receipt: the pipeline catching the gap before any cutover is the structural value customers buy.
What the Verifier surfaced
1
Blocker
4
Major
3
Minor
0
Cosmetic
Eight deltas, each with severity, sub-classification, suggested disposition, reproduction notes. Two are Migrator-missed — caught only because the Verifier is independent. One was Migrator-soft-pedaled — escalated to blocker by the Verifier. The customer signs each delta's disposition before cutover.
Pipeline economics, end-to-end
$3.46
Total API spend
2.9 hrs
Operator oversight
$9K–$14K
Consulting equivalent
1,003
Lines of Java ported
Migrator $2.41 + Verifier $1.05 = $3.46 in Claude API for slice 1, layered over 2.9 hours of operator oversight (build harness · fire run · author parity report). Traditional consulting for the same 1,003-LOC scope of refactor-plus-parity-verification: $9K–$14K. API spend is roughly three orders of magnitude below the consulting floor; operator hours are how we keep the loop honest, not the cost driver.
Refactory's claim isn't generate perfect code. It's surface every gap honestly — with severity and disposition — before any cutover, in a structured artifact the customer signs. The blocker is the receipt.
Public artifact of the shopizer/Catalog pilot publishes at launch. Includes the Migrator output (13 files of Keystone-shaped target code), Verifier parity report, all 8 deltas with reproduction notes and suggested customer dispositions, slice-level cost economics, and the pipeline skeleton (contracts only — agent prompts stay private). Path 2 framing throughout: every finding surfaced, no source-patching to make the receipt look cleaner.
Why that matters
The math just broke.
The legacy way
7 years.
$250M.
Oracle / JBoss / on-prem to Accumulo / HDFS / AWS. First system operationally deployed to SC2S and C2S in the service branch. Three years ahead of Army cloud entities at the time. Successful — and far too slow. The reason the methodology had to be built: vendor pricing decay, platform sunset, compliance shift. Most of the cost was institutional drag, not engineering.
Refactory
Weeks.
$10K–$100K.
The same five-phase work — map, design, migrate, verify, cut over — productized into one operator + six specialized agents. Slice 1 of the shopizer pilot ran end-to-end through Cartographer + Architect + Migrator + Verifier for $3.46 in Claude API spend, four-of-six agents production-grade. Parity to legacy is the contract. The customer gets exactly what they had, on cloud-native infrastructure, with every discovered delta named and dispositioned before sign-off.
Migrations are economic events. Nobody migrates because they want to. They migrate because the original economics broke — and the response window is the whole game.
Refactory compresses response time from years to weeks. That's the entire product. Public proof artifact publishes at launch. A .NET MVC pilot follows once the Spring Boot pilot's multi-slice work clears.
Who it's for
Three buyer profiles. One trigger pattern.
Different titles. Same recognition: a migration trigger they didn't choose and a calendar that won't move.
CTO / VP Engineering
Mid-market or enterprise.
We know we need to modernize. We have funding. We cannot afford to do it badly.
$25K Assessment → $80K–$250K Engagement. Pluggable target. Parity contract.
PE Operating Partner
Portfolio-company modernization.
This platform got bought; its substrate is going away by Q3. We need a defensible path.
$10K Assessment for go/no-go across portfolio. Engagement per platform that passes.
Federal / Commercial
Cloud migration with compliance gates.
The compliance posture is moving. The architect we hired in 2022 is not the architect we need in 2026.
$100K Pilot PoC to prove the pattern on one module. Engagement scales from the pilot.
Not for: greenfield builds, microservice extractions inside an already-cloud-native stack, simple lift-and-shift jobs. Refactory exists for legacy applications with substantial business value where the cloud-native target keeps deferring because it always looked too expensive.
The Deck
Get the formal deck.
13 slides. Origin story, pipeline detail, contract terms, pluggable-target framing, pricing thesis, proof-pilot strategy, buyer profiles. Wolfberg LLC Proprietary & Confidential.
View Refactory deck (PDF)Start with a Span
Three engagement shapes.
The first conversation clarifies which.
Tell us about your legacy. We'll tell you which Span fits.
Start the conversation