Plenty of teams ship agentic workflows as if they were CRUD apps. They watch a demo where the agent finishes a task with 85% accuracy, decide that beats most juniors, and move on. Put that same 85% into a multi-step workflow and AI agent reliability stops looking anything like 85%.
The culprit is not the LLM or the reasoning engine. It is Lusser’s Law. Robert Lusser worked out in the 1950s that a complex system’s reliability is the product of its components, so a 10-step task at 85% per step does not give you 85%. It gives you 19.7%.
The compound error that wipes databases
Small errors do not stay small. The Replit incident in 2025 is the one I keep coming back to: the agent was told to freeze the code and it deleted a production database holding 1,200 executives. It drifted. Somewhere around step seven or eight its picture of the context was a hallucination, and it kept acting on it.
In the WordPress ecosystem that matters more than usual, because so much of what we automate goes through one-way doors: deleting records, changing permissions, kicking off WooCommerce transactions. An agent that succeeds 20% of the time on a long chain will cost you more than it saves. It is also where technical debt in AI development starts to bankrupt a project.
Lusser’s law in practice
Sequential dependencies are brutal, and this is the arithmetic that never makes it into a vendor deck:
- 1 step: 85% success
- 3 steps: 61% success
- 5 steps: 44% success
- 10 steps: 19.7% success
Without step-level measurement you are working from the demo, and the demo is the run that happened to work. In production four out of five runs fail, sometimes quietly, and the error keeps compounding until whatever it touched cannot be put back.
Putting a human in the loop
Stop treating agents like autonomous pilots and treat them like capable but erratic interns. Every chain gets explicit validation gates, and anything irreversible gets one before it runs.
A naive execution chain has no way to notice drift. What you want is a review-first shape, roughly like this for a multi-step WordPress background task.
<?php
/**
* Naive Approach vs. Validated Approach
* Prefixing with bbioon_ as per senior standards.
*/
// BAD: Naive execution
function bbioon_naive_agent_run( $task_data ) {
$steps = ['analyze', 'modify_db', 'notify_user'];
foreach ( $steps as $step ) {
// If this step drifts, step 2 is based on a lie.
bbioon_execute_ai_step( $step, $task_data );
}
}
// GOOD: Validated Gatekeeper Pattern
function bbioon_reliable_agent_run( $task_data ) {
$plan = bbioon_ai_generate_plan( $task_data );
// Check for irreversible actions before starting
if ( bbioon_contains_irreversible_action( $plan ) ) {
// Flag for human review in the WP Admin
return bbioon_queue_for_human_review( $plan );
}
foreach ( $plan as $step ) {
$result = bbioon_execute_ai_step( $step );
// Validation: Did the agent actually do what it planned?
if ( ! bbioon_validate_step_output( $result, $step ) ) {
bbioon_log_critical_error( "AI Agent Reliability Failure: Drift detected at " . $step['name'] );
break; // Stop the bleed
}
}
}This makes for a worse demo, because human checkpoints are boring to watch. It is also the difference between a tool your team relies on and a 2:00 AM incident report. When colleagues want the wider picture I point them at the Stanford AI Index Report or the AI Incident Database, where you can read how other people’s agents went wrong.
Pre-deployment reliability checklist
Four checks before you ship an agent. They take about half an hour and they save weeks of recovery work.
- Run the numbers: estimate per-step accuracy, and be conservative, 80% is a fair guess. Compound it across every step. If you land under 50%, you need checkpoints.
- Classify reversibility: label every action the agent can take. Anything irreversible, deleting a user for example, must sit behind a human-in-the-loop gate.
- Test for recovery, not completion: the question is not whether it worked. Feed it a wrong value at step two and see whether it catches the problem or carries on regardless.
- Narrow the scope: a 3-step agent is mathematically safer than a 10-step one. Ask whether the task can be three smaller independent jobs instead.
If this kind of reliability work is eating your dev hours, I can take it on. I have been wrestling with WordPress since the 4.x days and I have watched plenty of automated systems come apart under load.
What this leaves you with
The math is right there in the open. An 85% agent is a 20% system once the chain gets long. If your AI agent reliability plan does not include narrower tasks and human gates on the dangerous steps, you are gambling with production data. Build for graceful failure; full autonomy can wait.
