The Agent Development Lifecycle: 4 Stages for Production
LangChain founder Harrison Chase published a reference framework on May 9, 2026, for what "shipping an AI agent to production" means in 2026. It's not a tutorial — it's a discipline: four stages — Build, Test, Deploy, Monitor — with cross-cutting governance. The sentence that sums it up is in the opening paragraph: "The difference between getting an agent to work once and building agents as a repeatable practice comes from having the right development lifecycle in place."
For teams that have spent 18 months wiring prototypes and are now hitting the "demo vs serious production" wall, this is the framework that puts words on what the good teams already do intuitively. We unpack the four stages, what happens in each, and what it changes for an AI team's MLOps stack in May 2026.
The context
For 18 months the agent community focus has been simple: make it work. Impressive demos, hackathons, internal POCs. The implicit bet was that once the prompt and the loop were dialed in, the rest would follow.
Reality crystallised around Q1 2026: making it work once isn't enough. Production agents demand monitoring (an agent can return a technically successful response and still fail the task), testing before production (you can't patch an agent at 3 a.m. the way you patch a web service), and governance (cost runaway, unaudited tool access). What Chase formalises is the bridge from artisanal phase to industrial practice — exactly the terrain where AI Act requirements and post-Copilot agentic cost constraints force maturity.
The four stages of the lifecycle
Stage 1 — Build: pick the right abstraction
The most common mistake on the team side: choosing the wrong abstraction level. Chase splits tooling into three categories, and you need to know which one you're using:
- Frameworks (abstractions): LangChain, CrewAI — you describe the behavior, the framework does the scaffolding
- Runtimes (execution): LangGraph — you describe the state graph and transitions, the runtime executes
- Harnesses (structure): Deep Agents, Claude Agent SDK — you build on a pre-existing pattern that constrains the shape
No-code / low-code (LangSmith Fleet, Claude Cowork, n8n) covers cases where business teams need to intervene without dev.
The components to wire up are now relatively stable: prompts, tools, skills, retrieval, structured outputs, agent loops, MCP servers, middleware, hooks, filesystem access. What changes is the maturity with which they're composed.
Critical anti-pattern: aiming for a perfect eval suite before any deployment. "In practice, that is rarely realistic," Chase writes. Better to ship something useful and test enough.
Stage 2 — Test: before production, not after
This is the sharpest break with traditional SDLC. In conventional software, accepting some bugs in production is normal. For an agent, pre-production testing is non-negotiable — you can't hot-patch emergent behavior the way you patch a stateless service.
Three sub-elements to industrialise:
Datasets built from actual usage. Not a generic benchmark — your dataset must reflect your cases: past support tickets, historical traces, collected edge cases. It's the least flashy work and the most decisive.
Two-headed metrics. Ground truth (did the agent produce the right answer vs reference) AND criteria-based (is the answer grounded, policy-compliant, efficient). Both families are complementary, not substitutable.
Multi-turn simulations. For any conversational agent — voice agent, support agent, coding agent — testing in single-turn is a trap. Chase insists: realistic multi-turn evaluation, simulated if necessary.
Common anti-pattern: shipping a prompt change without a comparable baseline. You iterate "blind" and nobody knows whether you improved or broke things.
Stage 3 — Deploy: durability and human-in-the-loop
Deploying an agent doesn't look like deploying an API. Three primitives have become near-mandatory:
Durable execution. Progress checkpointing, error recovery without replaying side effects. Tools cited: LangSmith Deployment, AWS AgentCore, Temporal. Without it, an agent that crashes at step 14 of a 20-step workflow has to start over — including DB writes or emails already sent.
Human-in-the-loop. Ability to pause the agent at any node, wait for human approval, resume. Not a V2 afterthought: the approval pause must be designed into the graph from the start. It's also what AI Act article 14 requires.
Sandboxes. Isolated execution with virtual filesystem (LangSmith Sandboxes, Daytona, E2B). Backing storage Postgres or S3 for files without code execution. For agents touching the system or writing code, isolation is what makes autonomy acceptable.
Key decoupling: a Context Hub lets you version prompts and context separately from application code. Consequence: adjusting a prompt no longer requires a redeploy. Iteration cycle drops from hours to minutes.
Stage 4 — Monitor: trajectory, not just latency
The essential shift: trace the full trajectory of every agent execution. Not just latency/cost/uptime — the entire chain of calls, tool invocations, intermediate reasoning, outputs.
Chase puts it bluntly: "An agent can return a technically successful response and still fail the task." Your usual SRE dashboard won't catch that. You need application-level signals:
- LLM-as-judge evaluators on production samples
- Regex pattern detection for suspicious behavior
- User feedback attached directly to traces, not in a separate Excel tab
The key insight: "Agent observability powers agent evaluation. Traces start the improvement loop." This is exactly the logic we explored on GitHub's token-optimisation method — without traces, no optimisation, no FinOps.
Governance as a cross-cutting frame
What surprises teams discovering the framework: governance isn't a stage — it's a frame wrapping all four. Four axes:
- Cost controls: budgets, monitoring, alerts, attribution per agent/team
- Tool access: audit trails, conditional authorisation, human-in-the-loop for sensitive actions
- Discoverability: a shared registry of prompts, skills, tools, retrieval sources, policies
- Reusability: stop every team from reinventing the same evals, the same deployment, the same tracing
The sentence that disarms typical developer pushback: "Good governance is not about slowing teams down. It is about making fast iteration possible without losing visibility."
At a company scale with multiple AI teams, this is the Platform Engineering function for agents.
What this actually changes for AI teams
Three concrete implications for anyone steering an AI team's maturity:
1. Test moves before deploy, not after. Radical inversion of the SDLC reflex. Practical consequence: you need a dataset of real cases before production. The right reflex to install from prototype day one: log every trace to a queryable store — future evals, future fine-tuning datasets.
2. The four stages aren't optional at scale. A team that skips Monitor or Test gets its bugs reported by customers. The Chase framework puts words on what good teams were already doing. For teams just starting, it's the industrialisation checklist. For teams with 6-12 months of agents in production, it's the gap audit that reveals which stage is missing.
3. Shared governance becomes its own MLOps function. The "Platform Engineer for agents" role that didn't exist 18 months ago becomes the position that unblocks scale across multiple teams. If every squad reinvents its tracing, its evals, its budget controls, you pay 5× for the same problem. It's exactly the commercial terrain where an MLOps freelance or consultancy can plant a flag.
For a team realising it's been stuck on "Build" for a year, the order of operations is clear: stand up Test (D), wire Monitor (D+15), industrialise Deploy with checkpointing (D+30), structure governance (D+45). Roughly six weeks to move from artisanal to repeatable practice.
TL;DR
- Harrison Chase framework published May 9, 2026: 4 stages (Build, Test, Deploy, Monitor) + Governance as cross-cutting frame
- Build: pick the right abstraction (frameworks vs runtimes vs harnesses), start simple
- Test before production: real dataset, ground-truth + criteria metrics, multi-turn simulations
- Deploy: durable execution (LangSmith / AgentCore / Temporal), human-in-the-loop, sandboxes, Context Hub
- Monitor: full trajectory (traces), LLM-as-judge, feedback attached to traces
- Governance: cost controls, audit tool access, discoverability, reusability — this is the Platform Engineering role for agents
Industrialising AI agents? SeedVision offers 3-5 day AI audits and 15-30 day production rollouts. See the packages or book a 30-min call.