For two decades the unit of quality engineering was the test script — something a human wrote, maintained, and eventually deleted when it became too brittle to trust. That model doesn't scale to the release cadence modern platforms demand. The bottleneck was never execution; it was authorship. So we moved the authorship into agents.
From scripts to state machines
Instead of a linear script, each test flow is modelled as a stateful graph. Nodes generate candidate steps, execute them against the app, and decide whether to advance, retry, or heal. LangGraph gives us durable state between those nodes, so an agent can reason about what it just observed rather than replaying a fixed sequence.
graph = StateGraph(TestState)
graph.add_node("generate", rag_generate)
graph.add_node("validate", execute_and_heal)
graph.add_edge("generate", "validate")
agent = graph.compile()The generate → validate → heal loop
The generate node drafts a step from grounded context — a PRD, a design doc, a code schema. The validate node runs it and inspects the result. When a selector drifts or a screen changes, the heal node proposes a fix and feeds it back into state rather than failing the run. Flakiness stops being a human triage problem and becomes a step the graph handles on its own.
What changed in practice
Across a 25+ engineer organisation this cut regression cycle time by roughly 40% and build-verification time by 75%. But the more durable win is cultural: engineers spend their time defining what "correct" means and reviewing agent behaviour, not hand-patching XPaths at 2am.
Agentifying the SDLC isn't about removing engineers from the loop. It's about moving them up a level — from authoring steps to orchestrating the systems that author them.