Origence is a U.S.-based financial technology company. Its engineering organization operates a portfolio of business-critical applications that support high-volume, mission-critical operations for its clients nationwide.
Problem Statement
What the customer was trying to solve
Origence runs a portfolio of business-critical services built on .NET Framework and hosted on virtual machines. The estate worked, which is why it had survived — but it constrained the business in four ways.
- Cost was fixed rather than consumption-based: capacity had to be planned and paid up front, with hardware and maintenance overhead attached.
- Change was slow and risky. Patterns varied between services, so engineers could not move between them without relearning, and nobody could state the blast radius of a change before making it.
- The security baseline could not be raised uniformly. Secrets, authorization, and dependency scanning were handled differently by service.
- Scaling was vertical and manual, with no circuit breaking or asynchronous workflow handling when a downstream vendor degraded.
Rewriting 10+ services manually was the obvious path and the unaffordable one. This migration means an engineer spends weeks reconstructing intent from legacy sources before writing anything, and the next engineer on the next service starts from zero. Throughput would have been capped by the number of people who could hold a legacy service in their head.
Use Case
Legacy application modernization at portfolio scale: migrating business-critical .NET Framework services from VM hosting to containerized .NET 10 services on Azure, using a governed, multi-agent engineering pipeline built on Claude.
- Category: AI for software engineering — code understanding, migration and review
- Secondary: Agentic workflow orchestration with enforced governance
The unit of work is a whole service, not a file or a function: the pipeline inventories the legacy service, designs its modern equivalent against a fixed architecture, plans and sequences the pull requests, implements them, and gates each one on automated architecture, security and test reviews before a human approves the merge.
Strategy
What the partner brought
A governed multi-agent pipeline on Claude Code that turns migration into a repeatable, instrumented process rather than a series of individual efforts. Four things distinguish it from general-purpose AI coding assistance:
Structural code understanding rather than reading. A Roslyn-backed analyzer parses the legacy service into compact structured metadata — interfaces, implementations, dependency injection map, layer violations — so agents reason over structure instead of consuming whole files.
Enforced governance, not guidance. Hooks block a code-targeted search until a structural analysis tool has run, block pushes to trunk, block secret writes, and block a commit until every mandated review agent has filed a report card. These are controls, not conventions.
Autonomous review of loops with human gates. Architecture, code and security reviews score each pull request; a score below threshold re-runs the implementing agent. Four human approval gates freeze state at discovery, design, plan and pre-verification.
Measured, not asserted. A Control Plane records real token and cost telemetry per agent and per phase, harvested from the actual session transcripts and priced server-side. Efficiency claims are more auditable than estimated.
How we used Claude Code
Claude Code, extended by a purpose-built modernization plugin that ships subagents, hooks, skills and four MCP servers. The plugin is dormant in any repository that has not been onboarded, so it can be distributed safely across an engineering organization.
- Subagents: 100+ agent definitions covering discovery, design, planning, implementation, code review, security review, testing, verification and retrospective.
- Hooks: PreToolUse, PostToolUse, SessionStart and Stop hooks that enforce policy rather than advise it.
- MCP servers: a Roslyn-backed C# analysis server, a LangGraph pipeline state machine, a session-state server, and a TypeScript analysis server.
- Skills and a governed 39-file knowledge base, served to agents by declared topic rather than loaded wholesale.
Modernization architecture
The diagram below shows the modernization path for each service. Legacy .NET Framework services hosted on IIS on Windows Server virtual machines are onboarded to the AI-assisted modernization pipeline, which takes them through six phases (discover, design, plan, breakdown, implement and verify) with human approval gates that freeze state after discovery, design and planning and before verification. Approved pull requests are deployed through Azure DevOps and Terraform as .NET 10 services running in Linux containers on Azure Container Apps.
Figure 1. Legacy-to-modern architecture and the modernization pipeline phases
Models — deliberately mixed by task type
Every agent declares the tier it runs on. The distribution below is the measured state of the agent roster, not an intention:
Claude model | Agents | What runs there |
Claude Opus | 2 | Architectural design and architect review — the two steps that exercise genuine judgement |
Claude Sonnet | 92 | The bulk of delivery: implementation, code review, security review, test engineering, verification |
Claude Haiku | 6 | Mechanical work: status, PR creation, changelog writing, token tracking, context budget, past-failure checks |
Routing is adaptive as well as declared: a review score below the quality threshold escalates the retry to a more capable tier, so reasoning is paid only where quality requires it.
Joint Outcome
Origence and MAQ Software rebuilt a portfolio of VM-hosted .NET Framework services as containerized .NET 10 services on Azure Container Apps using a governed, Claude-powered migration pipeline — putting eleven services into production across two phases, with six automated Gatekeep gates, including architecture, security and test coverage, enforced automatically on every pull request.
Results
Delivery against the migration plan
Phase | Scope | Window | Status |
Phase 1 | 6 services | Jan – Apr 2026 | Deployed to production |
Phase 2 | 5 services | May – Jul 2026 | Deployed to production |
Dimension | Before | After |
Hosting | VM-hosted .NET Framework on IIS (Windows Server) | Containerized .NET 10 on Azure Container Apps (Linux) |
Architecture | Varied per service | Clean Architecture (Endpoints → Services → Domain), enforced by analyzer |
Data access | Mixed patterns | Dapper with parameterized SQL, standardized |
Resilience | Direct calls, no circuit breaking | Refit + Polly retries and circuit breakers; NServiceBus for async workflows |
Secrets and config | In source and appsettings | Azure Key Vault, provisioned by Terraform with no manual portal edits |
Deployment | Manual, VM-based | Docker chiseled images, Terraform, Azure DevOps CI/CD |
Security | Per-service, inconsistent | OWASP Top 10 gates, CVE scanning in CI, policy-based authorization |
Test coverage | Variable | 80% or above, enforced before merge |
Review | Human only, variable depth | Automated architecture, code and security review scoring 8/10 or above, plus four human gates |
Adoption and scale
- One pipeline serving the whole portfolio across the program, with the same gates applied to every service — eleven in production to date.
- 100+ specialized agents, four MCP servers, and a governed 39-file knowledge base distributed as a single installable Claude Code plugin.
- Telemetry per agent, phase and session streaming to a Control Plane dashboard, so cost and quality are visible per migration rather than at the end.
- The pipeline supports five delivery modes — migration, greenfield, feature addition, bug fix and brownfield improvement — so the same governance applies beyond the migration itself.