DevAgents OSDevAgents OS
← Blog
·8 min read·agentic-ai·google·adlc·sdlc·governance
Cristiano Ferreira

The end of the SDLC: why the Agent Development Lifecycle (ADLC) is a loop, not a line

In traditional software engineering, deploy is the finish line. Once code ships to production, development pauses and maintenance begins. But what happens when the software isn't static? When the system isn't made up of just functions, but of AI agents that never stop reasoning?

For agentic AI, deployment isn't the end. It's where the real cycle begins.

The market just made this transition official. During Google Cloud Next 2026, Google didn't just unveil new models; the company codified a fundamental shift in the work architecture by introducing the ADLC (Agent Development Lifecycle) as the natural successor to the classic SDLC.

For technology leaders, CTOs, and architects, this isn't just a change of acronym. It's a complete shift in how software engineering is operated, governed, and paid for.

1. The contrast: SDLC (linear) vs. ADLC (continuous loop)

Old-school software development (SDLC) is a factory line: plan, code, test, deploy, and maintain. Each phase is sequential, driven by human validations, moving through one stage at a time. Quality control (QA) usually waits until the end of the project. Change scope mid-cycle, and things break.

The ADLC (the new shape) runs on different physics. The agent builds the scaffolding, tests it, evaluates its own performance, and ships to production. The phases follow a continuous loop, not a straight line. Evaluation (Eval) happens in real time, and the lifecycle constantly replans itself. Software becomes an organism that reasons and adjusts, not a static artifact that just executes.

2. Automating the automation: google-agents-cli

Until a few months ago, this was just a theoretical mental model. Now, giants like Google have turned it into a command line.

The introduction of uvx google-agents-cli changed the game. In practice, this tool takes your coding agent of choice (be it Anthropic's Claude Code, OpenAI's Codex, or local tools) and turns it into a specialist at orchestrating other agents across cloud infrastructure.

Without jumping between terminals or navigating cloud dashboards, the developer uses natural language to guide the agent through complex skills: from designing the workflow and structuring the ADK (Agent Development Kit) code, to running deploys and ensuring observability.

3. The 6 phases of the agent lifecycle (ADLC)

Building a robust agent under the new ADLC paradigm requires six integrated steps:

  1. Build: create the agent's structure and equip it with tools. In today's hybrid ecosystem, the choice of model (Gemini, Claude, GPT) is just a routing detail.
  2. Test locally: run it in a sandbox (Playground) with hot-reloading. The agent tests its hypotheses before any contact with the production cloud.
  3. Eval: the shift from "Pass/Fail" to an LLM-as-a-judge architecture. You're not just evaluating whether the code works — you're evaluating the agent's reasoning and how efficient its decision-making was.
  4. Deploy: the agent comes alive (e.g., Agent Runtime on Cloud Run). With millisecond cold starts, the agent keeps running and reasoning for days to solve long-horizon problems.
  5. Register: integration into the organizational structure, giving the agent a traceable corporate identity (IAM).
  6. Observe (continuous operation): where agents use a memory bank for long-term sessions, connect via the MCP protocol to use tools, and use A2A (Agent-to-Agent) to hand off smoothly from one specialist agent to another.

The hidden risk: a continuous loop demands continuous governance

Google nailed the ADLC infrastructure. The SDLC really does end at deploy, while the ADLC keeps the reasoning loop running in production.

But this is exactly where corporate engineering runs into its biggest risk.

If the agent keeps reasoning, optimizing, and calling tools after deployment, who's governing the execution? As we've already warned at DevAgents OS about the Debt Triangle in Agentic AI, an agent running in a continuous loop without strict architectural limits is a ticking time bomb of Token Debt (inference costs exploding) and Autonomy Debt (unaudited operations in production).

That's why Agentic Orchestration platforms are the missing piece of this puzzle. The ADK (Agent Development Kit) provides the building blocks, but the enterprise needs a governance layer above it that defines how far this "continuous reasoning" can go, how much it can cost, and when human approval (human-in-the-loop) must be mandatory.

How to start without drowning

For companies trying to migrate from SDLC to ADLC without losing operational control, the rule is to scale responsibly:

  1. Walk the prototype path first: don't try to wire up the entire cloud on day one. A local API key and an isolated sandbox are enough to test the agent's behavior.
  2. Write your evals before the agent: in the ADLC, the evaluation scorecard is what dictates quality. If you don't know how to measure the machine's reasoning, don't put it to work reasoning.
  3. Pass local evals before deploy: never release an agent to the cloud without an LLM-as-a-judge having strictly validated its security guardrails and architecture.
  4. Add tools last: get the basic reasoning loop working flawlessly before giving the agent access to corporate memory and external systems via MCP. The secret isn't the size of the attack surface — it's control over the flow.

Software development will no longer be measured by lines of code written, but by the quality of the reasoning we put into production. Govern the loop, and the AI will do the rest.

See how DevAgents OS governs the ADLC's continuous loop, with cost limits and human approval →

References

_Published August 3, 2026_