- Home
- AI agents
- AI agent registry and sprawl
- Agent lifecycle management
Govern and secure · AI agent registry and sprawl
AI agent lifecycle management: build, test, approve, deploy, monitor, change, retire
Agent lifecycle management, also called AgentOps, is running an agent like production software: build it, test it against acceptance criteria, approve it, deploy a pinned version, monitor it, change it through the same gate, and retire it with its identity revoked. Because behaviour depends on the prompt, the model, the tools and the data, each is versioned on its own.
In this guide: 83 pages
Key takeaways
- Four things change an agent’s behaviour and each has its own version: the prompt, the model, the tools and the data. Pin all four in production and move them one at a time.
- Every platform now versions agents and lets production point at one version: Foundry agent versions, AgentCore named endpoints, Power Platform solutions and pipelines, Google Agent Runtime revisions.
- Model retirement runs on the vendor’s calendar: Foundry’s standard GA lifecycle is 18 months (12 for Anthropic, DeepSeek, Fireworks and Mistral AI models), with auto-upgrade for standard deployments, and Bedrock’s policy for models launched after 7 Sep 2026 ends in failed requests with no automatic migration.
- A kill switch is only a kill switch once you have tested what it leaves running: a Foundry stop does not end existing runs, and a Microsoft 365 block of a Foundry or SharePoint agent only removes it from Copilot Chat.
What are the stages of an agent’s lifecycle, and what is the gate at each?
Seven stages, each with a gate that produces evidence: build, test, approve, deploy, monitor, change and retire. The gates are what make the lifecycle auditable; an agent edited live has none of them.
The seven stages, what happens in each, and the evidence the gate produces.
| Stage | What happens | Gate and evidence |
|---|---|---|
| Build | Prompt, tools, knowledge and a pinned model assembled as an immutable version; the agent gets its registry record and its identity | A record with owner, sponsor, risk tier and the tools it may call |
| Test | Offline evaluation against an acceptance set (task completion, tool-call accuracy, groundedness), plus injection cases | Scores against the acceptance criteria agreed in writing; a baseline for later comparison |
| Approve | The owner signs the results; the risk tier decides who else must (security, data protection, the business sponsor) | Approval state in the registry: the Requests queue on Microsoft 365, a record moving from DRAFT to APPROVED on AWS |
| Deploy | The approved version goes to a pinned endpoint; permissions are assigned to the agent’s own identity | Version id and endpoint recorded; RBAC on the agent identity, since Foundry does not carry permissions across on publish |
| Monitor | Traces of every model and tool call, cost per agent, online evaluation, alerts | Per-agent dashboards; Foundry Control Plane runs and error rate; AgentCore Failure Insights (preview) for silent failures |
| Change | A new version through the same test and approval; gradual rollout where the platform supports it; rollback by repointing | Pending update in the Requests queue; AgentCore A/B testing; Google revisions with traffic splitting (preview) |
| Retire | Block, wait, delete (a soft delete with a restore window), revoke the identity, archive evaluations and traces | 30-day soft delete on Microsoft 365; DEPRECATED on AWS; unregister on Google |
The sub-page on controlling agent sprawl covers the retirement sequence; this page covers the versions and the switches.
What do you version, and how do the platforms do it?
Four things, separately: the agent definition (prompt and instructions), the model, the tools and the knowledge. A change to any of them is a new version that goes through the gate, and production points at a pinned version of each.
Agent definitions are versioned on each platform in its own way. Foundry creates a new agent version, an immutable snapshot, each time you change an agent; AgentCore Runtime creates version 1 automatically and a new immutable version on every update; Copilot Studio agents live in Power Platform solutions, and a custom solution is how an agent moves between environments. Prompts kept outside the agent have their own registries: Langfuse gives each prompt a version id and a movable production label, LangSmith a commit hash per change with movable tags, and the MLflow Prompt Registry immutable versions with movable aliases.
Models retire on the vendor’s schedule. Microsoft Foundry’s lifecycle has five stages (preview, generally available, legacy, deprecated, retired); a standard GA model lives 18 months, is deprecated for new customers at 12 and retired at 18 with a 410 Gone, while Anthropic, DeepSeek, Fireworks and Mistral AI GA models follow a 12-month lifecycle. Standard deployments auto-upgrade at retirement unless versionUpgradeOption says otherwise, provisioned deployments do not, and retirement dates are not extendable. Amazon Bedrock’s policy for models launched on or after 7 Sep 2026 has three states, active, legacy and end of life: legacy lasts six months for most models or 45 days, existing customers in legacy may lose access after 15 days of inactivity, and at end of life requests fail with no automatic migration.
Tools and knowledge change behaviour as much as prompts. Pin tool lists at approval, and treat a changed tool list, a new MCP server version or a re-indexed knowledge base as a change that re-runs the evaluation set.
How do approval, rollout and rollback work on Microsoft, AWS and Google?
Approval is a queue or a record state, rollout is a pointer from a stable endpoint to a version, and rollback is moving that pointer back. The three clouds implement all three; gradual rollout is the newest part and is preview on Google.
On Microsoft, Power Platform pipelines deploy the same managed solution through stages so customisation cannot bypass QA environments or approvals. In Foundry’s documented (legacy) publishing experience, an Agent Application gives an agent a stable endpoint and its own Entra agent identity, and publishing a new version routes all traffic to it; Microsoft documents a newer publishing model alongside it. Permissions do not transfer on publish, so RBAC must be reassigned or tool calls fail after release.
AWS keeps AgentCore Runtime’s DEFAULT endpoint on the latest version while named endpoints stay pinned until updated, so production uses a named endpoint and rollback is repointing it to an earlier agentRuntimeVersion. A/B testing splits live traffic between versions (GA July 2026), and AgentCore Evaluations (GA 31 Mar 2026) runs the test stage.
Google’s Agent Runtime (Agent Engine until the 22 Apr 2026 rename) added agent revisions with traffic splitting in public preview on 19 May 2026, which is the canary mechanism.
Containment and rollback actions per platform, and what each one leaves running, from the vendor pages read on 2 Nov 2026.
| Platform | Action | What it leaves running |
|---|---|---|
| Microsoft 365 and Agent 365 | Block the agent | For Foundry and SharePoint agents, only availability in Copilot Chat is affected |
| Foundry Control Plane | Stop a hosted or published agent; block a custom agent | Stop does not terminate existing runs; block rejects new requests |
| Copilot Studio | SetAsQuarantined through the Power Platform API, or block in inventory | The agent stays usable in the maker’s test pane |
| Microsoft Entra Agent ID | Disable the agent identity or blueprint; tenant-wide Conditional Access templates that block agent authentication | Objects stay and token issuance stops; disabling a blueprint can break dependent Microsoft experiences |
| AgentCore Runtime | Repoint the named endpoint to a previous version (a rollback) | The earlier version keeps running; the DEFAULT endpoint keeps moving, so production must use a named endpoint |
| Bedrock Agents Classic | Set the alias to REJECT_INVOCATIONS, or repoint the alias | IAM unchanged; the agent remains and can be resumed |
| Power Platform pipelines | Redeploy a previous solution version from run history | Only if the setting is enabled |
| IBM watsonx Orchestrate | Contain: sandboxes and a kill switch for any agent | Technology preview, 27 Oct 2026 |
Test each switch on a throwaway agent and write down what it leaves running. CoSAI’s AI Incident Response Framework (27 Oct 2025) lists the agentic containment steps (disable tools, tighten authorization, reset memory, isolate sessions) and asks who has the authority to disable or roll back, a question to answer before the incident.
What is the control plane, and how is AgentOps different from DevOps?
The control plane is the set of systems that read an agent’s record and act on it: the registry, the identity, the policy point on tool calls, observability and the switches. AgentOps borrows from DevOps and MLOps and adds what an agent needs on top: evaluation of a non-deterministic system, revocation of the agent’s own identity, and a model that retires on someone else’s calendar.
Microsoft calls Agent 365 the control plane for agents (registry, Requests queue, management rules, block and soft delete, with Entra for identity); Foundry Control Plane adds fleet operations for Foundry agents (runs, error rate, cost, continuous evaluation). On AWS the equivalent is the AgentCore family: Registry, Identity, Policy, Observability with cross-account monitoring, and Evaluations; Google’s is Agent Registry, Agent Gateway and Agent Observability.
What differs from DevOps is the evidence. An agent is non-deterministic, so the test stage scores a distribution against acceptance criteria instead of asserting one result; the Foundry evaluation GitHub Action reports confidence intervals between a baseline and a candidate (preview). And forensics need more than logs: CoSAI recommends keeping prompt and response pairs, tool execution traces, system prompts and model versions so an incident can be reconstructed, while CVE-2026-15737 (July 2026) showed that raw prompts written into AgentCore telemetry are themselves a leak.
How do Microsoft, AWS and Google implement it?
The lifecycle features on each cloud, with statuses as the vendor pages showed on 2 Nov 2026.
Capability, Microsoft, AWS, Google
| Capability | Microsoft | AWS | |
|---|---|---|---|
| Agent versioning | Immutable Foundry agent versions; Copilot Studio agents in Power Platform solutions | AgentCore Runtime immutable versions; harness versioning and endpoints (GA 2026) | Agent Runtime revisions (public preview 19 May 2026) |
| Approval | Requests queue (Pending review, Pending update, Pending activate); delegated pipeline deployments with approvals | Registry record DRAFT to APPROVED; an edited record is re-approved while the approved revision stays live | Admin review of sharing requests in Gemini Enterprise (GA 23 Feb 2026) |
| Rollout and rollback | Agent Application routes all traffic to the new version; pipelines redeploy previous solution versions | Named endpoints pinned to a version; A/B testing (GA July 2026) | Traffic splitting between revisions (preview) |
| Kill switch | Block, quarantine or stop; disable the Entra identity; Conditional Access block templates | Deny in AgentCore Policy; remove the workload identity; repoint the endpoint for rollback | Block at Agent Gateway; remove IAM bindings; unregister |
| Model lifecycle | Five stages; 18-month standard GA lifecycle, 12 months for some partner models; versionUpgradeOption per deployment | Active, Legacy and EOL for models launched on or after 7 Sep 2026; no automatic migration | Discontinuations announced in release notes (Gemini 2.0 Flash on 1 Jun 2026) |
Foundry Control Plane carried no explicit GA or preview label on 2 Nov 2026, and the Foundry evaluation GitHub Action uses preview packages.
Enterprise example · Worked example · illustrative
A bank’s expense-approval agent goes through four versions in a year
Illustrative scenario. A regional bank with 4,000 staff, Microsoft Foundry for the agent, SAP Concur for expenses, and an internal audit team that signs off anything that touches payments.
Version 1 was the build: a prompt, a pinned model, three tools (read an expense report, read the policy, draft a decision) and an Entra agent identity with read-only rights. The acceptance set held 120 real reports with known outcomes and 15 injection cases; the gate was 95% agreement with the human decision and zero policy violations. It scored 93% and failed the gate; the prompt was changed, version 2 passed at 96%, the owner and internal audit signed, and the Requests queue published it.
Version 3 was forced by a model retirement date: the replacement was evaluated on the same 120 reports six weeks early. It scored 97% and was promoted through the same gate. Version 4 added a fourth tool, approve under a threshold, which moved the agent from tier 2 to tier 3; the tool ran behind require_approval for a month of shadow operation before the audit team allowed it to act on amounts under the threshold.
Each version is a Foundry agent version with its evaluation results attached to the registry record, and the kill switch (block in Agent 365 plus disable the Entra identity) was tested on version 2 before version 3 shipped.
- Owner
- The expenses process owner; internal audit as the second approver for tier 3
- Identity
- Microsoft Entra Agent ID with read-only rights until version 4; a Conditional Access template ready to block it
- Versioning
- Immutable Foundry agent versions; model pinned with no auto-upgrade; tool list pinned at approval
- Risk tier
- Tier 2 (reads and drafts) through version 3; tier 3 (acts on payments) from version 4
- Approval
- Owner signs the evaluation; Requests queue for publishing; require_approval during shadow operation
- Monitoring
- Foundry Control Plane runs, error rate and cost; Application Insights traces; monthly re-run of the acceptance set
- Retirement
- Versions 1 to 3 retired with evaluations archived; the agent itself gets the 30-day soft delete when the expense system changes
Frequently asked questions
What is AgentOps, and how is it different from MLOps?
AgentOps is the lifecycle discipline for agents: build, test, approve, deploy, monitor, change and retire, with the prompt, model, tools and data versioned separately. MLOps manages models you train and serve; AgentOps mostly consumes models a vendor retires on its own schedule, and adds evaluation of tool use, identity revocation and a tested kill switch.
How do we handle a model retirement?
Read the lifecycle state from the API (Azure lifecycleStatus, Bedrock modelLifecycle), pin the version so a standard Foundry deployment cannot upgrade silently, evaluate the replacement on the same acceptance set well before the date, and promote it as a new agent version. Bedrock does not migrate at end of life, so an untested agent fails instead.
Should prompts be in source control?
Yes, or in a prompt registry that behaves like one. Langfuse, LangSmith and the MLflow Prompt Registry all give a prompt versions and a movable production label, and each deployment record should pin the prompt version it runs, whether the prompt lives inside the agent version or in a registry. Production should reference a pinned version or label and never the latest one.
What is a kill switch for an AI agent, and does it fully stop the agent?
A tested action that stops the agent taking effect: block in Agent 365, stop or block in Foundry Control Plane, quarantine in Copilot Studio, disable the Entra identity, deny its tool calls in AgentCore Policy, block at Google Agent Gateway. Repointing an AgentCore endpoint is a rollback that leaves an earlier version running, so it is a different control. Pair the platform switch with the identity switch, since several platform switches are partial.
How long should we keep a retired agent?
Keep the record, the last approved version, the evaluation results and the traces for as long as your audit retention requires; delete the running agent once the objection period ends, which on Microsoft 365 and Entra starts a 30-day restore window. AWS keeps a deprecated record as terminal and Google removes the record on unregister, so export before you remove.
More in AI agent registry and sprawl
Sources
Each source was read on 2 November 2026. The date shown is the date on the page, or the page’s ms.date for Microsoft Learn; an undated page shows the date it was read.
- Foundry Models lifecycle and retirement
- Agent applications in Foundry Agent Service
- Run evaluations with the Foundry GitHub Action
- Foundry Control Plane overview
- Manage agents in Foundry Control Plane
- Solutions in Copilot Studio
- Pipelines in Power Platform
- Quarantine agents (Copilot Studio admin API)
- Agent actions in the Microsoft 365 admin center
- Agent requests
- Disable agent identities
- Agent identity deletion (Microsoft Entra Agent ID)
- What’s new in Microsoft Entra Agent ID
- Microsoft Ignite 2025: Copilot and agents built to power the Frontier Firm
- AgentCore Runtime versioning and endpoints
- Amazon Bedrock AgentCore release notes
- AWS Agent Registry record lifecycle
- Amazon Bedrock model lifecycle
- Amazon Bedrock Agents Classic maintenance mode
- Deploy an agent (Bedrock Agents Classic versions and aliases)
- CVE-2026-15737 (AgentCore Python SDK telemetry)
- Gemini Enterprise Agent Platform release notes
- Gemini Enterprise release notes
- Prompt version control
- Prompt engineering concepts
- MLflow Prompt Registry
- AI Incident Response Framework V1.0
- GenAI Incident Response Guide 1.0
- IBM introduces identity and control for AI agents
- Deploying Microsoft Agent 365 at Microsoft
Planning an AI program?
Talk to the team that builds it and runs it after launch.
- Built to SOC 2, HIPAA and GDPR standards
- EU AI Act-aligned delivery
- Microsoft Solutions Partner