An AI agent project still needs the fundamentals of a traditional software development lifecycle (SDLC): clear requirements, sound architecture, testing, secure releases, and operational ownership. It also needs additional practices for model behavior, context and data, tool permissions, ongoing evaluation, and runtime oversight. The difference is an extension of the SDLC—not a replacement for it.
What changes when software includes an AI agent?
Conventional software is generally built around functionality that engineers specify and implement. An agent adds a model that interprets context and may choose actions, including calls to tools or connected systems. That makes the system’s behavior more dependent on the inputs, data, model, permissions, and operating conditions surrounding it.
The amount of additional control needed depends on the use case. An agent that drafts text for human review has a different risk profile from one that can change records or initiate transactions. Traditional acceptance criteria remain useful; they should be supplemented with checks for behavior across varied inputs and conditions, and for whether the agent stays within its authority.
There is no single universally established agent lifecycle. Microsoft Learn describes one vendor’s five-phase approach, while NIST offers risk-management and secure-development frameworks that can be applied across a lifecycle. These are complementary perspectives, not competing universal standards.
Recommended Free Tools
#1 Best Overall
How the lifecycle stages compare
| Lifecycle stage | Conventional SDLC emphasis | Additional agent concern | Useful evidence or release check | Accountable owner |
|---|---|---|---|---|
| Planning | Requirements, intended functionality, and acceptance criteria | Define the agent’s objectives, context, assumptions, data inputs, permitted tools, constraints, and whether an agent is justified by the value it adds | Documented use case, boundaries, risk assessment, and acceptance criteria for both task outcomes and allowed behavior | Product owner with engineering, security, and risk stakeholders |
| Experimentation | Prototypes and validation of technical assumptions | Try representative real-world data and current models; assess whether results hold beyond a narrow proof of concept | Recorded evaluations against relevant examples and failure cases; known limitations documented | Engineering and product, with data or model specialists where relevant |
| Architecture and build | Components, interfaces, implementation, and integration | Specify the agent’s role, tool integrations, access boundaries, fallback behavior, and observability | Reviewed design, permission boundaries, integration tests, and traceability for decisions and actions | Technical lead or architect, alongside security |
| Testing and release | Unit, integration, security, regression, and acceptance testing as applicable | Evaluate behavior across varied inputs and operating conditions; keep evaluation active throughout the lifecycle | Test and evaluation results, security review, defined release criteria, and a rollback or containment plan | Engineering and quality teams, with security and risk review appropriate to impact |
| Deployment and operations | Controlled release, monitoring, incident response, and maintenance | Monitor agent behavior and tool use, collect feedback, track incidents, and adjust controls when needed | Runtime monitoring, accountable operational ownership, incident procedures, and periodic review and testing | Named service owner with operations, product, and risk support |
Planning: define goals, context, and authority
Start with the problem and the intended outcome, as in a conventional project. Then make explicit what the agent will be given, what it may do, and which conditions should cause it to stop or hand work to a person. Microsoft advises deciding whether an agent adds enough value to justify its added complexity.
- Objectives: Describe the task and what counts as an acceptable result.
- Context and inputs: Identify the information the system can use, including relevant data sources and assumptions.
- Tools and permissions: List available integrations and the actions each may perform. Grant only the access needed for the use case.
- Constraints and escalation: Set boundaries, fallback behavior, and situations requiring human review.
- Risk and ownership: Identify affected users, likely harms, decision-makers, and the person or team accountable after release.
NIST’s AI Risk Management Framework (AI RMF 1.0) frames risk management across design, development, deployment, and operation and monitoring. It is a way to organize responsibilities and risk work, not a prescriptive agent build sequence.
Experimentation: test assumptions before committing to a design
A proof of concept can show that an agent works on selected examples without establishing that it will behave reliably in production. Microsoft recommends grounding experimentation in real-world datasets and current models. It warns that synthetic or limited test data can leave a proof of concept performing poorly in production; this is guidance, not a quantified prediction.
Use experiments to challenge the plan: try representative inputs, difficult cases, and conditions likely to expose ambiguity or failure. Record what was tested, what did not work, and what the system should do when it cannot complete a task safely. Microsoft also recommends reducing the gap between experimentation and build where model or data drift could affect results.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchArchitecture and build: make the boundaries concrete
Alongside the components and interfaces found in ordinary application architecture, an agent design needs to show how the model interacts with context, tools, users, and other systems. AWS Prescriptive Guidance describes adapting architecture through “scaffolding”; in practical terms, that means building the roles, integrations, guardrails, and runtime visibility around the agent rather than treating the model as the whole application.
- Role: Define the agent’s purpose and the actions it is not meant to take.
- Integrations: Specify which tools and data sources it can use and what each connection permits.
- Boundaries: Apply access controls and constrain actions to the approved scope.
- Fallbacks: Decide how the system responds to uncertainty, errors, unavailable tools, or requests outside its remit.
- Observability: Capture enough information about inputs, decisions, tool calls, and outcomes to investigate problems, while respecting privacy and security requirements.
These are design choices, not a claim that every agent is autonomous. The required safeguards should reflect the agent’s capabilities, access, and potential impact.
Testing: retain software tests and add ongoing evaluation
Keep conventional practices such as unit, integration, security, regression, and acceptance testing where they fit the system. Add evaluation of the agent’s behavior across varied inputs and operating conditions, including whether it uses tools appropriately and respects its boundaries. A single successful demonstration or a one-time pre-release check does not establish behavior over time.
NIST AI RMF 1.0 states: “Test, Evaluation, Verification, and Validation (TEVV) tasks are performed throughout the AI lifecycle.” That makes evaluation a recurring activity: use it during design and development, before release, and in response to operational changes or observed failures. Release criteria should specify both the outcomes the agent must achieve and the unacceptable behaviors it must avoid.
Deployment and operations: keep accountability after launch
Use normal release discipline, but plan for controls that matter at runtime. NIST describes operation and monitoring as ongoing AI risk-management work, including monitoring, periodic updates and testing, incident tracking, and redress or response. Assign a service owner who can act on those signals rather than treating launch as the end of the lifecycle.
- Monitor performance and behavior relevant to the use case, including tool activity where appropriate.
- Collect user feedback and provide a route to report harmful or incorrect outcomes.
- Track incidents, investigate causes, and define response and escalation procedures.
- Review changes to models, data, integrations, and operating conditions; test again when changes could affect behavior.
- Be able to adjust permissions, constraints, or availability when the agent behaves outside its intended boundaries.
Microsoft Learn names its agent development lifecycle phases as “discovery, experimentation, build, deploy, and operational steady state.” Microsoft says the phases can overlap and iterate, with later feedback informing earlier work; it presents the framework as its guidance, not as a universal standard.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Security and governance: extend established controls
AI-specific work does not remove the need for secure software development. NIST SP 800-218A, intended for use with SP 800-218, adds secure-development practices for generative AI and dual-use foundation models. NIST’s publication record describes practices “specific to AI model development throughout the software development life cycle.” Use the profile to complement the organization’s existing secure-development process rather than treating AI as a separate exemption from it.
NIST’s DevSecOps reference model recommends traceability and review of AI-generated artifacts through established SDLC control gates. Its project page describes the current AI implementation as human-directed generative AI and says future project work will explore agentic AI; this project-specific description is not a deployment study or proof that agentic controls are settled.
Putting the comparison into practice
- Keep the existing SDLC backbone. Retain requirements, design review, secure implementation, testing, change control, release approval, and operational ownership.
- Add agent-specific decisions early. Define context, tools, permissions, constraints, fallback behavior, and risk before the architecture hardens.
- Evaluate with representative conditions. Include varied inputs and meaningful failure cases, and document evidence and limitations.
- Gate release on both capability and control. Confirm the system performs the intended task and remains within its defined authority.
- Operate it as a changing system. Monitor outcomes, track incidents and feedback, and revisit controls and tests as models, data, or integrations change.
AWS Prescriptive Guidance also recommends carrying forward iterative delivery, customer feedback, cross-functional collaboration, and CI/CD, while adapting planning, architecture, testing, and deployment for agentic systems. Its “zones of intent” and lifecycle reframing are vendor-authored guidance. They can inform a team’s process, but they should not be mistaken for an industry-wide standard.
Neither the cited frameworks nor guidance establishes a universal agent lifecycle, a numeric productivity advantage, or an industry-wide failure rate. Choose controls based on the system’s purpose and risk rather than assuming all agents need identical autonomy or safeguards.
Quick Recap
Sources and frameworks
- Microsoft Learn: Agent development lifecycle
- NIST: Artificial Intelligence Risk Management Framework (AI RMF 1.0)
- NIST: SP 800-218A, Secure Software Development Practices for Generative AI and Dual-Use Foundation Models
- AWS Prescriptive Guidance: Evolving software delivery for agentic AI
- NIST NCCoE: Notional Reference Model for DevSecOps
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
