Even the strongest agents complete their planned steps and still miss the goal. On WebArena's realistic web tasks the best agent reached just 14.41% end-to-end success against 78.24% for humans, with the gap blamed partly on agents that never verify the objective before declaring done (WebArena, arXiv:2307.13854, 2023).
Key facts.
- Completing steps is not satisfying the goal: a 2025 goal-plan-action framework separates plan adherence, did the agent run its steps, from goal fulfillment, did the outcome meet the objective, and agents routinely pass the first while failing the second (Agent GPA, arXiv:2510.08847, 2025).
- A self-asserted "done" is not evidence: Terminal-Bench's rubric flags missing verification of required properties and requires an agent to confirm at least one core property with an observed, substantive result before completion, because "looks good" is insufficient (Terminal-Bench, arXiv:2601.11868, 2026).
- The end-to-end gap is wide: the best WebArena agent reached 14.41% versus 78.24% for humans, attributed partly to missing failure recovery and verification (WebArena, arXiv:2307.13854, 2023).
Why does finishing the plan not finish the task?
Because the plan is a sequence of steps, and the goal is a state of the world, and nothing in a naive loop connects the two at the end. The agent generates a plan, executes each step via tool calls, and when the last action returns it declares the task complete and exits. There is no terminal step that re-checks the objective: that the file actually uploaded and its checksum matches, that the record exists with the correct fields, that the requested outcome is now true. So a plan that was subtly wrong, or a step that silently failed downstream, produces a clean-looking finish over an unmet goal. The benchmark evidence is blunt: agents complete planned steps yet clear a small fraction of realistic end-to-end tasks, because step completion and goal achievement are different things (WebArena).
Why do agents declare done prematurely?
Because the loop's stopping condition is plan exhaustion, not goal satisfaction. When the agent reaches the end of its plan, the simplest behavior is to report success, and nothing pushes back. This is the gap between plan adherence and goal fulfillment: an agent that grades itself on having run the steps will call a task done while the actual end state, the thing that defines success, is wrong (Agent GPA). A self-assertion like "looks good" is not evidence the goal was met (Terminal-Bench). The agent is a careful executor of steps and an indifferent checker of outcomes.
# End the workflow with a goal check, not just plan exhaustion run_plan(steps) state = observe_world() # independent observation, not the plan's own logs if not goal_satisfied(state, objective): # end-state invariant, not "did I run the steps?" replan_or_escalate(objective, state) else: report_done() # only after the goal is verified
How do you make completion mean the goal?
End every plan with an explicit validation against the objective. Add a terminal critic step or a separate verifier that observes the actual end state, independently of the plan's own logs, and checks the goal's invariants: the artifact exists and is intact, the record matches, the requested change is true. If the check fails, the agent re-plans or escalates instead of reporting done. Measure final-state match in your evals and in production, not step completion or plan adherence, so premature done shows up as a metric. Checkpoint long workflows and validate at the checkpoints, so drift is caught mid-run rather than at the end. The agent then stops when the goal is satisfied, which is the only stopping condition that means the task is actually finished.
Plan completion versus goal verification
| Aspect | Declares done on plan exhaustion | Verifies the goal |
|---|---|---|
| Stopping condition | Last step ran | Objective satisfied |
| Flawed plan | Finishes wrong, reports success | End-state check fails, re-plans |
| Silent downstream failure | Unseen | Independent observation catches it |
| Evaluation | Step / plan adherence | Final-state match |
| Long workflow | Validated only at end, if at all | Checkpoint validation throughout |
Plan complete reads as goal complete everywhere; a better model still skips the check, so the rework recurs. (arXiv:2307.13854)
The pattern is that a plan is a list of steps and a goal is a state of the world, and an agent that stops on plan exhaustion declares success without ever checking the two match. End with a goal-validation step that observes the real end state, re-plan or escalate when it fails, and measure final-state match, and plan completion stops being mistaken for task completion. Making the goal check the stopping condition, rather than running out of steps, is reliability at the pattern level, which is what VibeModel builds as the Pattern Intelligence Layer.
Frequently asked questions
Why does the agent stop before the goal is met?
Because its stopping condition is running out of planned steps, not satisfying the objective. Add a terminal goal check so completion means the end state matches the goal, not that the plan was exhausted.
Who should do the final validation?
A critic step or a separate verifier that observes the actual end state independently of the plan's own logs. Self-reported plan adherence is exactly the thing that lets premature done slip through.
What should I measure?
Final-state match against the goal, in evals and production, not step or plan completion. That metric is what reveals tasks that finished the plan but missed the objective.