I recently used OpenClaw to orchestrate a messy but very real infrastructure migration. The job was to take legacy on-prem Windows server disks in mixed formats and turn them into bootable Azure virtual machines. The hard part was not any single step. It was the way the steps depended on each other, and how many of them could fail in ways that only became obvious much later.

Some source images were dynamic VHDs that Azure would reject unless they were converted to fixed VHDs first. Some needed MiB alignment and a valid footer before Azure would accept the upload. Some disks restored cleanly at the storage layer but still failed to boot because the Windows boot chain was incomplete. The entire process was a test of whether AI could coordinate a deep technical workflow, not just summarize one.

The hardest lesson: a live file-level backup can quietly skip locked operating system binaries. That means the disk can look complete while still being impossible to boot. Once that happened, the project stopped being a repair exercise and became a source-quality problem.

What made this hard

There were four real problems:

  • Azure managed disks require fixed VHDs, not dynamic ones.
  • Azure also expects the image size and VHD footer to be correct, including MiB alignment.
  • Restoring only part of a Windows system can break the boot chain in subtle ways.
  • A backup can look complete while still missing critical boot files that were locked during capture.

The last point mattered most. Once it was clear that a live capture had missed key OS binaries, the fix was not another round of boot repair. The fix was to make cold capture a hard pre-flight requirement before investing more time in conversion and upload.

How OpenClaw helped

The interesting part was not just automation. It was orchestration.

OpenClaw handled the work in a sequence that adapted to the state of the system:

  • identify the source type and size
  • choose the right conversion path
  • convert to fixed VHD
  • align and validate the disk image
  • upload into Azure as a managed disk
  • build a VM from the disk
  • inspect the boot screen
  • decide whether repair was needed
  • repair the boot path when necessary
  • recheck until the machine reached a healthy login screen

The boot diagnosis step was especially useful. Instead of logging in manually and guessing, the workflow used console screenshots and a vision model to distinguish between symptoms such as a BIOS disk read error, a missing Windows loader, or a successful boot to the login screen. That let the process choose the correct repair path from actual evidence, not from assumptions.

Why this was a good AI use case

This project worked because the problem was not just procedural. It was stateful. The workflow had to notice when the output of one step changed the meaning of the next step. That is exactly where AI is useful in operations work. It can hold the shape of the process, read the evidence, and adjust when the situation is not matching the script.

That is also why the project felt different from normal automation. A script can run commands. An orchestrator can make sense of a failure, keep going, and avoid repeating the same mistake.

What I liked most

The best part was watching the scars turn into reusable knowledge.

Every time the workflow hit a real edge case, that lesson got captured into a repeatable procedure. The next machine went faster because the earlier failures had become pre-flight checks and codified repair steps. The process started to feel less like heroic troubleshooting and more like institutional memory.

That is the real promise of AI in this kind of work: not replacing judgment, but making judgment go further by remembering what broke last time and applying that lesson immediately.

A few practical takeaways

  • Verify the source image before converting anything.
  • Treat cold capture as a hard requirement when boot integrity matters.
  • Assume Azure will enforce image correctness aggressively.
  • Read the boot symptom before deciding on repair.
  • Use the right tool for the job, especially when Windows and Linux tooling both have a role.
  • Convert hard-earned fixes into reusable workflow steps so the next restore is better than the last one.

Why this matters for AI and automation

A lot of people talk about AI as if it is only good for writing or summarizing. This project showed a different side of it.

AI can orchestrate a deep technical workflow when the environment is messy, the failure modes are layered, and the answer depends on interpreting real operational evidence. It can keep a multi-step migration moving, help diagnose where the problem actually is, and preserve the lessons so the next run is better.

That is the version of AI I find most interesting. Not a chatbot. A capable operator that can guide complex work, read the output, adapt to what it sees, and turn the results into durable process.

Closing thought

The migration was valuable because it solved a hard infrastructure problem. It was memorable because it showed what AI and OpenClaw can do together when the job is not theoretical.

They can run the process, read the evidence, recover from mistakes, and make the next attempt smarter.