Skip to content
  1. Home
  2. AI agents
  3. AI agent registry and sprawl
  4. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
Seven lifecycle stages, the gate at each, and what is versionedSeven stages in a row: Build, with prompt, tools and model pinned; Test, against an evaluation set with injection cases; Approve, where the owner signs off and the risk tier sets the gate; Deploy, to a pinned version on a named endpoint; Monitor, with traces, cost and evaluations; Change, a new version through the same gate; Retire, with block, revoke and soft delete. Four things are versioned separately: the prompt and instructions, the model, the tools and MCP servers, and the knowledge and data. Underneath, the control plane (registry, identity, policy, observability and a tested kill switch) reads the versions and acts on the agent.The stages, each behind a gateBuildprompt, tools andmodel pinnedTesteval set plusinjection casesApproveowner signs off;risk tier gateDeploypinned version,named endpointMonitortraces, cost,evaluationChangenew version viathe same gateRetireblock, revoke,soft deleteVersioned separatelyPromptimmutable versions;a production labelModelpinned; upgradeoption setToolspinned tool lists;approved revisionsKnowledgeindex version;retention rulesControl plane: registry, identity, policy, observability, tested kill switchSeven lifecycle stages, the gate at each, and what is versionedSeven stages in a row: Build, with prompt, tools and model pinned; Test, against an evaluation set with injection cases; Approve, where the owner signs off and the risk tier sets the gate; Deploy, to a pinned version on a named endpoint; Monitor, with traces, cost and evaluations; Change, a new version through the same gate; Retire, with block, revoke and soft delete. Four things are versioned separately: the prompt and instructions, the model, the tools and MCP servers, and the knowledge and data. Underneath, the control plane (registry, identity, policy, observability and a tested kill switch) reads the versions and acts on the agent.The stages, each behind a gateBuildprompt, tools and model pinnedTesteval set plus injection casesApproveowner signs off; risk tier gateDeploypinned version, named endpointMonitortraces, cost, evaluationChangenew version via the same gateRetireblock, revoke, soft deleteVersioned separatelyPromptimmutable versions;a production labelModelpinned; upgradeoption setToolspinned tool lists;approved revisionsKnowledgeindex version;retention rulesControl plane: registry, identity, policy,observability, tested kill switch
Seven stages, each behind a gate, with the four things that are versioned separately underneath and the control plane that reads them.

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.

StageWhat happensGate and evidence
BuildPrompt, tools, knowledge and a pinned model assembled as an immutable version; the agent gets its registry record and its identityA record with owner, sponsor, risk tier and the tools it may call
TestOffline evaluation against an acceptance set (task completion, tool-call accuracy, groundedness), plus injection casesScores against the acceptance criteria agreed in writing; a baseline for later comparison
ApproveThe 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
DeployThe approved version goes to a pinned endpoint; permissions are assigned to the agent’s own identityVersion id and endpoint recorded; RBAC on the agent identity, since Foundry does not carry permissions across on publish
MonitorTraces of every model and tool call, cost per agent, online evaluation, alertsPer-agent dashboards; Foundry Control Plane runs and error rate; AgentCore Failure Insights (preview) for silent failures
ChangeA new version through the same test and approval; gradual rollout where the platform supports it; rollback by repointingPending update in the Requests queue; AgentCore A/B testing; Google revisions with traffic splitting (preview)
RetireBlock, wait, delete (a soft delete with a restore window), revoke the identity, archive evaluations and traces30-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.

PlatformActionWhat it leaves running
Microsoft 365 and Agent 365Block the agentFor Foundry and SharePoint agents, only availability in Copilot Chat is affected
Foundry Control PlaneStop a hosted or published agent; block a custom agentStop does not terminate existing runs; block rejects new requests
Copilot StudioSetAsQuarantined through the Power Platform API, or block in inventoryThe agent stays usable in the maker’s test pane
Microsoft Entra Agent IDDisable the agent identity or blueprint; tenant-wide Conditional Access templates that block agent authenticationObjects stay and token issuance stops; disabling a blueprint can break dependent Microsoft experiences
AgentCore RuntimeRepoint 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 ClassicSet the alias to REJECT_INVOCATIONS, or repoint the aliasIAM unchanged; the agent remains and can be resumed
Power Platform pipelinesRedeploy a previous solution version from run historyOnly if the setting is enabled
IBM watsonx OrchestrateContain: sandboxes and a kill switch for any agentTechnology 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

CapabilityMicrosoftAWSGoogle
Agent versioningImmutable Foundry agent versions; Copilot Studio agents in Power Platform solutionsAgentCore Runtime immutable versions; harness versioning and endpoints (GA 2026)Agent Runtime revisions (public preview 19 May 2026)
ApprovalRequests queue (Pending review, Pending update, Pending activate); delegated pipeline deployments with approvalsRegistry record DRAFT to APPROVED; an edited record is re-approved while the approved revision stays liveAdmin review of sharing requests in Gemini Enterprise (GA 23 Feb 2026)
Rollout and rollbackAgent Application routes all traffic to the new version; pipelines redeploy previous solution versionsNamed endpoints pinned to a version; A/B testing (GA July 2026)Traffic splitting between revisions (preview)
Kill switchBlock, quarantine or stop; disable the Entra identity; Conditional Access block templatesDeny in AgentCore Policy; remove the workload identity; repoint the endpoint for rollbackBlock at Agent Gateway; remove IAM bindings; unregister
Model lifecycleFive stages; 18-month standard GA lifecycle, 12 months for some partner models; versionUpgradeOption per deploymentActive, Legacy and EOL for models launched on or after 7 Sep 2026; no automatic migrationDiscontinuations 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.

  1. Foundry Models lifecycle and retirement Microsoft Learn, 24 July 2026
  2. Agent applications in Foundry Agent Service Microsoft Learn, 19 June 2026
  3. Run evaluations with the Foundry GitHub Action Microsoft Learn, 30 April 2026
  4. Foundry Control Plane overview Microsoft Learn, 6 May 2026
  5. Manage agents in Foundry Control Plane Microsoft Learn, 15 July 2026
  6. Solutions in Copilot Studio Microsoft Learn, 29 April 2026
  7. Pipelines in Power Platform Microsoft Learn, 29 September 2026
  8. Quarantine agents (Copilot Studio admin API) Microsoft Learn, 14 July 2026
  9. Agent actions in the Microsoft 365 admin center Microsoft Learn, 23 September 2026
  10. Agent requests Microsoft Learn, 2 September 2026
  11. Disable agent identities Microsoft Learn, 29 April 2026
  12. Agent identity deletion (Microsoft Entra Agent ID) Microsoft Learn, 15 May 2026
  13. What’s new in Microsoft Entra Agent ID Microsoft Learn, 1 May 2026
  14. Microsoft Ignite 2025: Copilot and agents built to power the Frontier Firm Microsoft Copilot blog, 18 November 2025
  15. AgentCore Runtime versioning and endpoints AWS documentation, undated page, read 2 November 2026
  16. Amazon Bedrock AgentCore release notes AWS documentation, undated page, read 2 November 2026
  17. AWS Agent Registry record lifecycle AWS documentation, undated page, read 2 November 2026
  18. Amazon Bedrock model lifecycle AWS documentation, undated page, read 2 November 2026
  19. Amazon Bedrock Agents Classic maintenance mode AWS documentation, undated page, read 2 November 2026
  20. Deploy an agent (Bedrock Agents Classic versions and aliases) AWS documentation, undated page, read 2 November 2026
  21. CVE-2026-15737 (AgentCore Python SDK telemetry) CVE Program, 16 July 2026
  22. Gemini Enterprise Agent Platform release notes Google Cloud, 28 October 2026
  23. Gemini Enterprise release notes Google Cloud, 21 September 2026
  24. Prompt version control Langfuse documentation, undated page, read 2 November 2026
  25. Prompt engineering concepts LangSmith documentation, undated page, read 2 November 2026
  26. MLflow Prompt Registry MLflow documentation, undated page, read 2 November 2026
  27. AI Incident Response Framework V1.0 CoSAI (OASIS Open Project), 27 October 2025
  28. GenAI Incident Response Guide 1.0 OWASP GenAI Security Project, 28 July 2025
  29. IBM introduces identity and control for AI agents IBM Newsroom, 27 October 2026
  30. Deploying Microsoft Agent 365 at Microsoft Microsoft Inside Track, 21 November 2025

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