Agentic SDLC is a software development lifecycle in which AI agents plan, write, test, and ship code changes across each phase, while humans set intent and approve the work at defined gates. When agents open most of the pull requests, the merge gate, where a human approves each pull request, becomes the main control point for cloud cost, so cost review belongs at that gate before changes deploy. The agentic SDLC is also called the AI-native SDLC or the agentic development lifecycle (ADLC).
Dimension | AI-Assisted Development | Agentic SDLC |
|---|---|---|
Unit of work | A suggestion or completion a developer accepts in an editor | A multi-step task an agent carries from issue to pull request |
Who opens the pull request | The developer | The agent, under its own identity or on behalf of the requester |
Human role | Writes code and reviews suggestions | Sets intent, approves plans, and reviews and merges at gates |
Pull request volume reaching reviewers | Limited by how fast developers write code | Grows with the number of agent tasks running in parallel |
Cost exposure | Tool licenses or model usage, plus the cloud cost of merged changes | Agent run cost (model usage, CI minutes), plus the cloud cost of merged changes |
How the Agentic SDLC Works
In an agentic SDLC, an AI agent receives a goal, such as a GitHub issue or a written spec, and works through it in a loop. The agent reads the relevant code, makes changes, runs tests, fixes failures, and returns the result as a pull request. Some setups add an orchestrator agent that splits a goal into subtasks and hands each subtask to a specialized agent.
The human role in an agentic SDLC moves from writing each change to directing and approving work. Engineers define the goal and what a correct result looks like, approve plans before large changes start, and decide what merges and what reaches production. These approval points are the gates of an agentic SDLC, and they are where an organization applies its controls.
GitHub Copilot cloud agent, formerly called Copilot coding agent, shows how agentic SDLC gates work on a real platform. Copilot cloud agent takes an assigned GitHub issue, works in an environment powered by GitHub Actions, and opens a pull request. Copilot cloud agent cannot approve or merge its own pull request. By default, GitHub Actions workflows on a Copilot pull request wait for a person with write access to approve them.
An agentic SDLC keeps the familiar lifecycle phases: planning, implementation, testing, review, release, and operations. The difference lies in who does the work inside each phase and where people step in to approve it.
Agentic SDLC Phases and Human Approval Gates
Each phase of an agentic SDLC pairs agent work with a human or automated gate:
Planning: Agents add detail to tickets and draft specs or task plans. A human approves the scope and assumptions before implementation starts.
Implementation: Coding agents write application code and infrastructure as code (IaC), the configuration files, such as Terraform, that define cloud resources. The agent loop has no human gate inside it, so the merge gate that follows carries the control.
Testing and verification: Agents generate and run tests and fix failures. Continuous integration (CI) checks act as automated gates that each pull request must pass.
Review and merge: Review agents can flag risky changes, and a human approves and merges each pull request. Cost estimates and policy checks belong at this gate, where a change is still a diff that can be revised.
Release and operations: Agents can ship changes behind feature flags and watch rollouts. Production deployments and rollbacks usually stay subject to human approval.
Agentic SDLC vs AI-Assisted Development, AI-DLC, and ADLC
AI-assisted development keeps the developer in charge of each change: the developer writes code and accepts or rejects suggestions from an AI tool. In an agentic SDLC, a developer hands a multi-step task to an AI agent and reviews the finished pull request.
AI-DLC, short for AI-Driven Development Lifecycle, is a named methodology that AWS introduced in 2025. AI-DLC places AI agents at the center of each lifecycle phase while humans keep decision-making authority. AI-DLC is one specific methodology for running an agentic SDLC.
ADLC has two meanings in current usage. As "agentic development lifecycle," ADLC is a synonym for agentic SDLC. As "agent development lifecycle," ADLC describes how teams build, test, and operate AI agents themselves, a separate discipline. Agentic coding, a narrower term, covers only the implementation phase of an agentic SDLC.
How Does an Agentic SDLC Change Cloud Cost Governance?
An agentic SDLC raises the number of infrastructure changes that reach review, which makes the merge gate the main point of cloud cost governance. Coding agents can open IaC pull requests faster than reviewers can price each change by hand. A monthly cloud bill review finds the cost of those changes after the resources are running. A cost estimate on the pull request finds the same cost before merge, when the change can still be revised.
Reviewer attention is the limited resource at the merge gate of an agentic SDLC. Cost thresholds let low-impact pull requests merge with a visible estimate and send only high-impact pull requests to a named approver. That routing keeps budget control with an engineering manager and spends reviewer time only on changes above the threshold.
An agentic SDLC also creates two cost streams that need separate tracking. Agent run cost covers the model usage and CI minutes consumed while agents work. GitHub, for example, bills Copilot cloud agent work in GitHub Actions minutes and AI credits. Infrastructure cost is the cloud spend created by the changes agents merge, and tracking only one of the two streams hides part of what an agentic SDLC costs.
Allocation and unit economics in an agentic SDLC draw on the same pull request and agent run data. Agent-opened pull requests can be attributed to the team or issue that requested them. Cost per merged pull request, calculated as agent run cost divided by the number of merged pull requests, shows what each completed change cost to produce.
Adding Cost Review Gates to an Agentic SDLC
Teams adding cost review to an agentic SDLC usually apply the following controls:
Estimate cost on every IaC pull request. Run a cost estimate on each pull request that changes infrastructure as code, whether an engineer or an agent opened it, and post the cost difference in the pull request.
Set thresholds that require a named approver. Define the cost increase that needs human sign-off, and make the cost check a required status check so an agent-opened pull request cannot merge without it.
Give agents cost and tagging policies at generation time. Coding agents that read the organization's cost and tagging policies while writing IaC open fewer pull requests that fail review.
Keep agent identity separate in approvals. Record which agent opened each pull request and who requested it. On GitHub, the approval of the person who asked Copilot to open a pull request does not count toward required approvals.
Track agent run cost per team. Report agent run cost next to infrastructure cost, and use the monthly bill review to check trends in changes that already passed the gate.
Tools like Infracost estimate the cost of Terraform and other IaC changes in CI/CD and post the cost difference as a pull request comment before deployment. Infracost guardrails can send a notification or block a pull request that crosses a cost threshold until someone reviews it.
Related Concepts
Terraform Cost Estimation: the pre-deploy cost check that turns an agent-written Terraform change into a cost difference at the merge gate.
AI Cost Governance: the policies and approval controls applied to AI spend, including the cost of running coding agents.
Token Economics: the per-token pricing behavior that drives agent run cost in an agentic SDLC.
LLM Observability: the tracking of model calls and token usage that makes agent run cost visible per task.
Cloud Cost Forecasting: the practice of projecting cloud spend, which has to account for a higher rate of merged infrastructure changes when agents open pull requests.
Frequently Asked Questions (FAQs)
What is agentic SDLC?
Agentic SDLC is a software development lifecycle in which AI agents plan, write, test, and ship code changes while humans set intent and approve the work at defined gates. In an agentic SDLC, an agent carries a multi-step task from an issue to a pull request. Humans review the result and decide what merges and what reaches production.
What is the difference between agentic SDLC and AI-assisted development?
In AI-assisted development, a developer writes the code and accepts or rejects suggestions from an AI tool. In an agentic SDLC, a developer assigns a multi-step task to an AI agent, which makes the changes and opens a pull request for review. The agentic SDLC moves the human role from writing each change to approving finished work.
What does ADLC stand for?
ADLC stands for either agentic development lifecycle or agent development lifecycle, depending on the source. Agentic development lifecycle is a synonym for agentic SDLC, in which agents do engineering work across the lifecycle. Agent development lifecycle describes how teams build, test, and operate AI agents themselves.
Where do humans approve work in an agentic SDLC?
Humans in an agentic SDLC usually approve plans before implementation starts, review and merge pull requests, and approve production deployments and rollbacks. On GitHub, Copilot cloud agent cannot approve or merge its own pull requests, so a person makes the merge decision. Cost estimates and policy checks belong at the merge gate of an agentic SDLC, where a person approves each pull request.
How does an agentic SDLC affect cloud costs?
An agentic SDLC adds two cost streams: agent run cost from model usage and CI minutes, and infrastructure cost from the cloud resources that merged changes create. Coding agents can open infrastructure pull requests faster than reviewers can price them by hand, so an agentic SDLC needs a cost estimate on each pull request before merge.
How do you add cost review to an agentic SDLC?
Cost review in an agentic SDLC starts with a cost estimate on every pull request that changes infrastructure as code, posted in the pull request itself. Cost thresholds then decide which pull requests need a named human approver, enforced through a required status check. Giving coding agents the organization's cost and tagging policies while they write code reduces the number of pull requests that fail cost review.
Is AI-DLC the same as agentic SDLC?
AI-DLC, the AI-Driven Development Lifecycle, is a specific methodology that AWS introduced in 2025. Agentic SDLC is the general term for any lifecycle in which AI agents do work across each phase, and AI-DLC is one named way to run an agentic SDLC with humans keeping decision-making authority.
Prevent Cloud Budget
Overruns Earlier
Download the whitepaper to see how teams shift FinOps left and add cost guardrails in pull requests.