Agent-Led Cloud Migration: How On Moved 24 Services in Weeks, Not Quarters

On October 8, 2026 Google Cloud and sportswear brand On published a migration announcement, and the numbers are the story. On used AI agents to migrate 24 core services to Google Cloud, cutting migration time from three months to two weeks per service. A small team of internal engineers ran 15 migrations completely in-house with under five minutes of planned downtime per service. As On's CTO Narek Verdian put it, AI changes the economics of execution. That sentence deserves a slow read: what got cheap is execution, not judgement.

24 core services, under five minutes of planned downtime each

Why the numbers matter

Everyone claims AI productivity gains; this announcement offers checkable numbers. Twenty-four core services. Three months down to two weeks per service. Fifteen migrations run entirely in-house. Under five minutes of planned downtime per service. Deployment patterns across more than 20 code repositories mapped in hours instead of days. And a counterfactual: an external vendor quoted $500,000 to move a fraction of those microservices. When execution costs drop by an order of magnitude, the maths around project scope changes. Migrations that were not worth doing become worth doing, and work that had to be outsourced can be absorbed. There is a second-order effect worth naming. When the marginal cost of execution drops this far, the right question stops being 'is this migration worth the effort' and becomes 'which migration should we do next'. Teams that budget around a fixed number of engineering hours per quarter will keep under-investing in work that just became cheap, while teams that re-price execution will discover a backlog of work that was previously uneconomic. The binding constraint moves from hands to judgement: how many changes can humans meaningfully review and approve in a week.

# The migration was not one clever prompt. It was four specialised
# agents with narrow, checkable jobs and a human gate at the end.
MIGRATION_AGENTS = {
    "analyzer":  "read every repo, map inconsistent deploy patterns",
    "generator": "produce infrastructure config + translation pipeline",
    "validator": "run tests and environment validation before cutover",
    "runner":    "apply infra changes, then stop for human approval",
}

# Key property: every agent hands its output to the next as an
# artifact a human can read, not as an opaque side effect.

Four agents and one pipeline

This was not one clever prompt. It was specialised agents with narrow, checkable jobs: an analyzer reading every repository and mapping inconsistent deployment patterns, a generator producing infrastructure configuration and translation pipelines, a validator running tests and environment validation before cutover, and a runner applying infrastructure changes before stopping at a human gate. The property that makes it auditable is that every agent hands the next step a readable artifact rather than an opaque side effect.

# Step one: analysis at a scale a person cannot match by hand.
# On's engineers mapped deployment patterns across 20+ repositories
# in hours instead of days - that compression is the whole point.
def analyze(repos):
    manifest = []
    for repo in repos:                       # 20+ of them
        manifest.append({
            "repo": repo.name,
            "runtime": repo.detect_runtime(),
            "deploy_pattern": repo.infer_deploy_pattern(),
            "stateful": repo.has_persistent_state(),
            "cutover_risk": repo.estimate_cutover_risk(),
        })
    return manifest           # the input for everything downstream

Agents take the mechanical steps; humans own the irreversible decisions

Bounded execution: drawing the agent's authority on a line

The design term that matters is bounded execution. Agents were given defined tasks with clear checks, and the moment a change became consequential the workflow stopped for human approval. Engineers reviewed generated code, ran infrastructure changes and authorised production cutovers. This is not 'the AI shipped to production by itself'. It is 'the AI carried the mechanical work to the end, and humans made the few irreversible calls'. The cleaner that line, the more an agent can safely own.

# Step two: generate the boring, mechanical parts. Config
# scripting, data replication and environment validation are
# exactly the work agents are reliable at - and exactly the work
# that eats a migration budget.
def generate(entry):
    return {
        "iac":            gen_terraform(entry),      # infra as code
        "replication":    gen_data_replication(entry),
        "env_validation": gen_env_checks(entry),
        "translation":    gen_pipeline(entry),       # legacy -> target
    }

# Nothing here is clever. That is the point: mechanical work should
# be expensive for nobody and identical every single time.

Why mechanical work is the right thing to hand over

The announcement names three things offloaded to agents: configuration scripting, data replication and environment validation. They share a profile - tedious, repetitive, with a checkable right answer - and they are exactly where migration budgets leak. The value is not only speed. It is that agents do the same thing identically every time, which humans writing the thirtieth config script do not. And mapping deployment patterns across 20+ repositories in hours is not a case of doing it slightly faster; it is a scale humans cannot reach by hand at all. The audit argument is underrated. Regulated environments rarely ask whether a change worked; they ask who made it, what evidence supported it, and how you would prove that months later. An agent that emits the same artifact shape every time is far easier to audit than a human who solved a similar problem last quarter in a slightly different way. Standardised output is not a stylistic preference in this context. It is what makes the trail readable.

# Step three: validation runs before any production change.
# 'Bounded execution' means the agent's authority stops at a line
# the team drew in advance - and it stops there every time.
def validate(artifact):
    checks = {
        "unit_tests":   run_tests(artifact.repo),
        "integration":  run_integration_suite(artifact.repo),
        "env_parity":   compare_env(artifact.source, artifact.target),
        "data_sample":  verify_sample_rows(artifact.replication),
    }
    failed = [k for k, ok in checks.items() if not ok]
    if failed:
        raise ValidationFailed(failed)   # fix and re-run, never skip
    return True

Rethink how the work gets done, don't automate a process that already exists

Rethink the work before you automate it

One line in the announcement is easy to skim past and directionally important: the team says it chose to rethink the work from the ground up rather than automate a process that already exists. The difference is large. Automation caps out at the efficiency of the old process; rethinking starts from what is optimal under new constraints. On also pushed the method outward, rolling out Gemini Enterprise to every employee so teams could build custom no-code agents for executive reporting, market research, scheduling and onboarding. The same capability, reused from infrastructure work into internal process. On's approach also suggests a sequencing rule. Do not start with the process you most want to automate; start with the one where you can define done most precisely. A migration step with a test suite is a good candidate because the agent's output can be checked mechanically. A step that depends on a stakeholder's taste is a bad first candidate, however much time it consumes. Earn the right to automate the fuzzy work by first proving you can govern the crisp work.

# Step four: the human gate. Engineers ran infrastructure changes
# and authorised production cutovers. Consequential changes stay
# with people; the agent never approves its own release.
CUTOVER = {
    "planned_downtime_budget_seconds": 300,   # under five minutes
    "requires_human_approval": True,
    "approver": "on_call_engineer",
    "rollback": {"automatic": True, "trigger": "health_check_fail"},
}

def cutover(service, approval):
    if not approval.signed_by_human:
        raise NeedsHuman("cutover approval missing")
    return service.promote(downtime_budget=CUTOVER["planned_downtime_budget_seconds"])

# The economics shift because *execution* got cheap, not because
# judgement got automated. Those are different claims.

A reusable migration playbook

If you want to copy this, take the steps in order. First, run analysis before writing code: have agents walk every repository and produce a manifest of runtime, deploy pattern, whether state is persistent, and cutover risk. Second, have agents generate all the mechanical artifacts while humans review. Third, make validation a hard gate - tests, integration suite, environment parity, data sampling - and fix rather than skip failures. Fourth, put production cutover behind human approval with a pre-declared downtime budget and automatic rollback trigger. Fifth, freeze the whole thing as a blueprint so the next migration reuses it instead of reinventing it.