ADLC: how the AI agent development lifecycle differs from SDLC, and how to apply it
TL;DR
ADLC (Agent Development Lifecycle) extends SDLC for probabilistic software: evals throughout, traces for every step, gradual rollout and continuous monitoring after shipping. Its core is a loop that turns real failures into test cases and a quality gate that blocks any unmeasured change, even a model version swap.
On this page
A team ships a customer-support chatbot using the process everyone knows: write the spec, build it, get every test passing, release. Two weeks later the agent starts promising refunds to a group of customers that the policy doesn't allow. Not a single line of code changed. What changed was how customers phrased their questions, the data in the knowledge base, and possibly the model version on the provider's side. The unit tests are still green. This is why more and more organisations (IBM, Salesforce, Arthur and others) talk about ADLC, the Agent Development Lifecycle: a lifecycle built specifically for AI agents, running alongside the familiar SDLC.
This post explains how ADLC differs from SDLC, what its phases are, why the eval loop sits at the heart of it, and gives a checklist your team can start using now. There is no single ADLC standard yet: each organisation names and counts the phases differently. The post pulls together what the sources agree on and flags where a view belongs to one of them.
Why isn't SDLC enough any more?
SDLC was built for deterministic software: the same input gives the same output, and behaviour changes only when someone edits the code. AI agents break both assumptions. IBM sums it up: agents are probabilistic, the same input can produce different outputs, and behaviour can “drift” even when the code stays the same. On top of that, agent failures are harder to spot: an answer can sound perfectly reasonable and still be wrong, or a multi-step chain can fail at step five in a way you can't reproduce.
| Aspect | SDLC (traditional software) | ADLC (AI agents) |
|---|---|---|
| Nature | Deterministic, hand-written logic | Probabilistic; behaviour depends on model, prompt and context |
| Input | Tightly specified (forms, API schemas) | Free-form user language with endless variations |
| Testing | Binary pass/fail | Score distributions against quality thresholds, over many runs |
| What ships | Code | Code + prompts + model configuration + context/data + eval suite |
| Failure modes | Bugs, crashes, regressions | Hallucinations, drift, wrong tool calls, policy violations, cost overruns |
| After release | Maintenance and bug fixes | Release is only the start: continuous monitoring and tuning |
| Who's involved | The software team | Cross-functional: engineering, data, AI ops, business, legal |
One point worth noting: Salesforce and Atlan both describe ADLC as extending SDLC, not replacing it. The rest of the system (APIs, databases, UI) still follows SDLC; ADLC governs the “agent layer” on its own.
The phases of ADLC
IBM splits ADLC into 6 phases, several of which form a loop. Salesforce uses 5 phases with two loops: an inner loop (development: tweak the prompt, run, score) and an outer loop (after deployment: monitor and refine with real data). The two models line up fairly well:
1. Plan
Agree on the use case, KPIs and measurable success criteria; describe the desired behaviour in natural language. Salesforce adds: define the persona, ethical guardrails, the scope of context and memory, the list of tools, and a handoff plan to a human for when the agent gets stuck. IBM stresses a question that often gets skipped: does this problem actually need an agent? Often a regular automated workflow or a single LLM call is enough, cheaper and easier to control.
2. Code & build
Choose models (IBM suggests a “portfolio” of large, domain-specific and small models), design prompts and orchestration, connect tools via MCP, add RAG. Two practices matter most: version control for prompts and orchestration configuration, just like code, and a least-privilege sandbox for every tool. IBM also proposes giving each agent its own identity so you can audit what it did.
3. Test & release
This is where ADLC differs most from SDLC. Unit tests are still needed for deterministic tools, but they can't replace scenario-based evals: comparing the agent's behaviour against ground-truth trajectories, scoring with LLM-as-a-judge plus human reviewers, and adding red teaming to probe for prompt injection and jailbreaks. Salesforce adds goal-based end-to-end tests, adversarial tests, human graders for tone and conversational flow, and performance and load tests.
4. Deploy
Roll out gradually: canary, blue-green or rolling, with the ability to roll back to the previous agent version. Salesforce separates two steps: deploy (push the new version) and activate (turn it on for users), so it can be pulled back quickly.
5–6. Operate & Monitor
Track quality, latency, cost and satisfaction; detect drift; tune prompts, tools, models and memory. At the governance level: regular audits for fairness, transparency, security and compliance, plus a catalogue of agents and tools recording owner, version and risk level. Salesforce suggests labelling conversation logs (by humans or an LLM) to build data for later tuning.
The heart of ADLC: the eval loop
Arthur, one of the companies popularising the term ADLC, argues that most of the effort lies in getting from “it runs” to “it's trustworthy”. They call the core loop the Agent Development Flywheel, with 4 steps, and treat the eval suite as the single most important success factor.
- Real usage and simulation: widen gradually from internal testers → a pilot group → production, while running large-scale simulated sessions in parallel.
- Find failures and hotspots: trace every decision and every tool call, and compare against benchmarks and KPIs.
- Add failures to the eval suite: every real failure becomes a test case, so regressions can't return.
- Experiment and ship: only push prompt, retrieval or tool changes once quality and KPIs have been measured and there's no regression.
In practice this loop usually becomes a quality gate in CI/CD. Every change (even just a model version bump) has to pass the eval suite before it reaches users. IBM stresses exactly this: changing the model version alone can change behaviour.
A good eval report is more than a single “accuracy” number. It compares the new version with the one in production across several metric groups, and has the power to block a release when a safety metric gets worse, even if everything else looks better:
What to measure: four metric groups
| Group | Example metrics | Measured with |
|---|---|---|
| Quality | Task completion rate, correct tool calls, context relevance | Eval suite, LLM-as-a-judge, human-graded samples |
| Safety | Policy violations, data leaks, prompt-injection success | Red teaming, guardrails, adversarial test sets |
| Operations | Latency, token count, cost per task, error rate | Traces (e.g. OpenTelemetry), cost dashboards |
| Business | Satisfaction, human-handoff rate, cost per outcome | User feedback, business metrics |
These four groups follow IBM's classification. Salesforce adds two very practical signals: how often a conversation hits a “dead end”, and how often it has to be handed to a human.
Context: why care now
Atlan cites several Gartner forecasts: by the end of 2026 about 40% of enterprise applications will include task-specific agents (up from under 5% in 2025). Yet more than 40% of agentic AI projects may be cancelled before the end of 2027. Forecasts or not, they carry the same message as the other sources: building an agent demo is easy; running a trustworthy agent in production is hard. That hard part is what ADLC tries to systematise.
Risks and caveats
- No common standard yet: IBM has 6 phases, Salesforce 5, Arthur 3 broad stages, and others differ again. Don't get stuck debating names; take the common core: evals throughout, full tracing, gradual releases, continuous monitoring.
- Many sources are vendor content: IBM, Salesforce, Arthur and Atlan all sell related products. The frameworks are useful, but you don't need their tools to apply them.
- LLM-as-a-judge can be wrong too: a judge needs a clear rubric and regular calibration against human graders, otherwise you're just automating a subjective opinion.
- Evals cost money: running hundreds of scenarios, several times each, after every change adds up. Split a fast suite (every PR) from a full suite (before release).
- Don't drop SDLC: the tools, APIs and permissions around the agent still need unit tests, code review and security like any other software.
How to apply this
- Dev: start with 30–50 real scenarios taken from logs or the business, score them with a simple rubric, and run them in CI whenever the prompt or model changes. Version prompts in Git like code. Turn on tracing for every tool call from day one.
- Tech Lead: define a quality gate with concrete thresholds per metric group. Safety metrics can block a release. Deploy via canary and have rollback ready. Assign an owner and a risk level to every agent.
- PM: write the KPIs and “desired behaviour” in natural language before the team builds; define when the agent must hand off to a human. Treat the eval suite as a product asset: every customer complaint is a new test case. And ask IBM's first question: do we really need an agent?
Sources & references
- What is the agent development lifecycle (ADLC)? — Dave Bergmann, IBM Think
- Agent Development Lifecycle — Salesforce Architects
- Introducing the Agent Development Lifecycle (ADLC) — Adam Wenchel, Arthur
- ADLC vs SDLC: How the Agent Development Lifecycle Differs — Emily Winks, Atlan