Contact The agents document, design, build, test and operate on their own, but a named person signs off before each new stage begins. Three human gates turn an autonomous fleet into an accountable migration: assessment, design, and promotion.
Each gate sits between two stages: the agents can't start the next stage until a person signs off the last one. Inside Build → Test → Operate, the agents iterate on their own, the gate comes once the suite is green.
Documenters reconstruct the functional behavior of every legacy asset into the knowledge base; the Surveyor scores complexity and prioritizes the backlog.
The Architect turns the knowledge base into a Target Design Spec, applying your naming, error-handling and orchestration standards.
Builders generate the assets for the chosen platform and flavor.
Test agents and the Reconciler verify the generated assets against the documented legacy behavior.
Operators deploy and run in DEV; failures go back to the builders and the loop repeats until the suite is green.
Every gate gives a person a prepared artifact, a clear set of criteria, and a single decision: sign off, or send it back.
Between the design gate and the promotion gate, there's no human in the inner loop. The Operator runs the build in DEV, the Test agents and the Reconciler flag what doesn't match the documented behavior, and the builders patch it: over and over, until the suite is green. Every iteration is logged.
Deploys to DEV and runs the pipelines for real, reading every failure.
Test agents and the Reconciler compare the output against the documented legacy behavior.
The fix is generated and the loop re-runs, no human in the inner loop.
Green on iteration 3: the human reviews the iterations, severity and tests at Gate 3.
When the suite is green, a person reviews the validation report before anything is promoted. They're not re-running the work, they're judging the evidence the loop produced:
Only then does it promote through your existing DEV → ACC → PRD process. Every iteration is recorded in the knowledge base, so the verdict is informed and auditable.
No design is built and no asset is promoted without a named person's sign-off. The autonomy stops at the gate.
Each asset's gates block records who approved what and when, a trail your governance and auditors can follow.
Issues surface at a gate, not in production. Sending a stage back early costs minutes, not a release.
Your people. The assessment is signed by your data and migration leads, the design by your architects and platform owners, and promotion by your data owners and release managers. The agents prepare the evidence; your experts make the call.
Nothing proceeds. The stage re-runs with your feedback (re-document a misread asset, adjust the design, or send a build back into the loop) until you're satisfied. Catching it at a gate is far cheaper than catching it in UAT or production.
Yes. Every knowledge-base entry carries a gates block recording the state (approved or pending) at each gate, so the trail is auditable and you always know what has been signed and what has not.
The agents do the heavy lifting continuously and autonomously inside the loop; the gates are decision points, not queues. You review prepared evidence (a scorecard, a design spec, a validation report) rather than reverse-engineering what happened.
Yes. The three gates align to assessment, design and production promotion, and the reviewers and approval steps map to your existing roles and DevOps process: the fleet fits your governance; it doesn't replace it.
See the gates on your own estate: the assessment fills the knowledge base for a representative slice, and your team signs off Gate 1 before anything else begins.
Plan my migrationA short form, no spam. We usually reply within one business day.
