The lifecycle changes when agents stop being tools and start being actors.
The SDLC organised software engineering for decades on one assumption: a human at every stage, writing, reviewing, validating, deploying. Once agents retrieve context, implement changes, validate output and respond to signals, that assumption breaks — and the sequencing, the triggers and the platform requirements all move with it.
Six assumptions that no longer hold.
None of these were wrong. They were correct for as long as humans were the only actors in the system. The ASDLC is the framework that accounts for what happens when they are not.
Why this matters
SDLC assumed
ASDLC requires
Work moves through paths, and every path has a type.
A path is a valuable way for a user — human or agent — to achieve an outcome and progress along a value stream. Each one declares what inputs it expects, what the platform does when it is invoked, and what output it must produce before work continues.
The hybrid loop is the structural novelty
It has no equivalent in the SDLC, and it is the piece most often misdiagnosed. Teams treat a first-pass agent failure as evidence the approach does not work, when the correct response is to structure the platform so that repeated runs against error-updated context converge. Productivity comes from the loop closing, not from the first attempt landing.
Deterministic paths do not go away
Even in a fully automated plant, robots do not replace conveyor belts. Deterministic systems are already proven, already reliable, and faster than any stochastic process for their class of work. Apply autonomy where judgement creates value; keep determinism where determinism wins.
The paths model, the three path types and the hybrid loop pattern are drawn from Weave Intelligence's research on the ASDLC and the Agentic Engineering Platform, by Kaspar von Grünberg. See What is the Agentic Software Development Lifecycle (ASDLC)? and What is an Agentic Engineering Platform?
Eight paths, one loop, no idle handoffs.
Work enters as a ticket or a signal and moves through context retrieval, implementation, validation, promotion, deployment, observation and remediation. In the SDLC a human initiated each of these. In the ASDLC, what changes is who initiates, who executes, and what governs the handoff between them.
Three layers, and a human role for each.
Agents do not replace engineers; they industrialise execution. Robotic arms automated welding without removing the need for manufacturing expertise — somebody still designs the car, tunes the line and owns quality control. The same division holds here.
01
The spec is the source code
Write the spec before the code. Agents read it; code fulfils it. No spec, no build. Delivery becomes an assembly step, and the human contribution shifts from crafting to engineering.
02
Treat context as code
AGENTS.md, rules and skills are version-controlled, peer-reviewed and optimised for machine consumption — not pasted into a chat window and lost when the tab closes.
03
Use gates, not hope
Enforce quality at three levels: deterministic checks that compilers and tests can settle, probabilistic review by a critic agent, and human acceptance for strategic fit.
04
Separate state from delta
The spec describes how the system works. The work item describes what changes. Conflating them is how an agent ends up rewriting behaviour nobody asked it to touch.
05
Commit constantly
Micro-commits are save points. When an agent produces garbage in file four of ten, you roll back four files rather than the whole session.
+1
Write down the definition of done
This is the requirement with no infrastructure equivalent. In the SDLC it lived as tribal knowledge applied at review time. Agents need it explicit — functional correctness, architectural alignment, policy compliance, operational characteristics — or the loop has nothing to optimise against and no way to know when to stop.
The Context / Agents / Gates layering, the spec-as-source-code principle, the three-tier gate hierarchy and the micro-commit practice come from the ASDLC methodology published at asdlc.io, maintained by Ville Takanen and contributors. The written definition of done as a platform requirement is from Weave Intelligence's ASDLC research.
The ASDLC is not one shape. It has four.
Each level is defined by a different role for the human across the lifecycle, and each one changes what the platform must provide. The lifecycle stages do not disappear as you move up — the triggers and the governance do.
The hardest jump
Level 1 → level 2
A new path appears with no SDLC equivalent: converting a human-directed assignment into a governed agent work item with bound identity, assembled context and explicit scope. That is a specification with inputs and outputs, not an informal handoff to a bot. It also forces the question of what code review means when the unit of work is a batch rather than a diff.
The constraint shift
At level 3
The bottleneck stops being review bandwidth and becomes architectural maturity plus the economics of running agents at scale. Every loop iteration spends budget, so cost per accepted output becomes a metric you manage rather than a surprise on the invoice.
The predictable failure
Level 3 ambition, level 1 substrate
Agents run faster than the guardrails around them. This is the most common pattern we are called in to unwind, and it is why our first deliverable is almost always an honest assessment of where you actually are rather than a roadmap to where you were sold.
Each path gets an agent with a charter, not a chatbot with a prompt.
Our agents are named after the paths they own. Each one has a persona, a rule set it cannot reason past, loadable skills, a manifest, and a declared definition of done — and each one reads from a Domain Context Engine so it argues from your domain's facts rather than from the internet's average.
- 01
Context retrieval + specification
Domain Solution Agent
Owns the front of the lifecycle: interrogates intent, reconciles it against the domain's ADRs and constraints, and emits a living spec plus a machine-checkable definition of done.
- 02
Implementation
Domain Development Agent
Executes one work item as a reviewable change set that matches the domain's existing patterns, micro-commits as it goes, and re-enters the loop with gate failures attached as context.
- 03
Validation
Domain Testing Agent
Runs the probabilistic review gate as an adversary with the spec in hand, then promotes recurring findings into permanent deterministic checks.
- 04
Promotion + deployment
Deployment Agent
Classifies risk from evidence, selects the matching rollout, and treats the rollback path as a required output rather than an incident-time improvisation.
- 05
Observation + remediation
BugFix Agent
Consumes signals rather than tickets, establishes root cause before patching, and writes the regression test before the fix. This is where a level-3 platform starts generating its own work.
An agentic workflow is a path definition, not a prompt chain
The definition is not the runtime. It declares the steps, the eval criteria, the human verification points and the gates; an orchestrator walks the graph. Writing it down is what makes the behaviour reviewable, diffable and auditable — and what stops “how do we ship a feature” from being answered differently by every team.
name: feature-delivery
type: hybrid
trigger:
- linear.issue.labelled: agent-ready
- signal.security_advisory
steps:
- path: specify
agent: phaiai/agents/domain-solution
gate: spec.acceptance_criteria_machine_checkable
- path: implement
agent: phaiai/agents/domain-development
workspace: ephemeral # never shared between sessions
gate: [build, unit, lint, policy]
- path: validate
agent: phaiai/agents/domain-testing
gate: evals.rubric >= 0.92
- path: promote
agent: phaiai/agents/deployment
gate: risk_class in [low, medium]
escalate_to: human when risk_class in [high, regulated]
loop:
on_gate_failure: re-enter previous step with failure as context
max_iterations: 3
then: escalate with written diagnosis
definition_of_done:
functional: all acceptance criteria demonstrably met
architectural: no ADR violated, no new pattern introduced silently
policy: ACS dispositions all allow or modify, none denied
operational: rollback dry-run green, SLO budget unaffectedFind out which level your lifecycle is actually at.
We run a two-week assessment against the four-level model: we trace one real value stream end to end, mark every path as probabilistic, deterministic or hybrid, and report where the definition of done is still unwritten. You get the findings whether or not you engage us afterwards.
PhaiAI is an independent practice. The ASDLC and Agentic Engineering Platform frameworks referenced on this page are the work of their authors and are credited in full on the research page. We are not affiliated with, nor endorsed by, Weave Intelligence, asdlc.io, OWASP or Microsoft.