Connected Patterns: Bounded Planning That Actually Ships
“A good plan is not the longest plan. It is the plan that ends.”
If you have ever watched an agent work on a complex task, you have seen two extremes.
High-End Prebuilt PickRGB Prebuilt Gaming TowerPanorama XL RTX 5080 Gaming PC Desktop – AMD Ryzen 7 9700X Processor, 32GB DDR5 RAM, 2TB NVMe Gen4 SSD, WiFi 7, Windows 11 Pro
Panorama XL RTX 5080 Gaming PC Desktop – AMD Ryzen 7 9700X Processor, 32GB DDR5 RAM, 2TB NVMe Gen4 SSD, WiFi 7, Windows 11 Pro
A premium prebuilt gaming PC option for roundup pages that target buyers who want a powerful tower without building from scratch.
- Ryzen 7 9700X processor
- GeForce RTX 5080 graphics
- 32GB DDR5 RAM
- 2TB NVMe Gen4 SSD
- WiFi 7 and Windows 11 Pro
Why it stands out
- Strong all-in-one tower setup
- Good for gaming, streaming, and creator workloads
- No DIY build time
Things to know
- Premium price point
- Exact port mix can vary by listing
Some agents rush. They jump into execution with no structure, and the output is shallow or wrong.
Other agents never stop planning. They decompose, and decompose again, and refine the decomposition until the run is out of budget. The plan grows while the deliverable stays empty.
Infinite loops are rarely a single bug. They are usually missing constraints:
- No clear definition of done.
- No step budget.
- No rule for when to stop gathering information.
- No rule for when to accept uncertainty and proceed.
- No moment where execution is allowed to commit.
Multi-step planning becomes reliable when it is bounded.
The Hidden Reason Agents Loop
Agents loop because “more thinking” feels safer than committing.
Planning reduces visible risk because it postpones action. If the system never forces the agent to choose a next step, planning can become a substitute for progress.
A production agent needs a different definition of safety:
Safety is not endless deliberation. Safety is acting inside constraints with verification gates.
Planning as a Phase With Budgets
The easiest fix is to treat planning as a phase, not as an open-ended activity.
A planning phase has:
- A time budget.
- A maximum plan length.
- A target confidence threshold.
- A required “open questions” list.
- A hard transition into execution.
When planning ends, the agent must either:
- Execute the plan, step by step, or
- Escalate to a human because critical uncertainty remains.
This prevents the “plan forever” behavior that kills runs.
Define Done Before You Define Steps
Many loops come from a missing acceptance definition.
If the agent cannot tell what a finished output looks like, it will keep generating more structure as a proxy for completion.
A strong “done” definition includes:
- The artifact type to deliver: report, patch, dataset, checklist, email draft.
- The required sections or fields.
- The audience and tone constraints.
- The success criteria that can be checked.
When done is explicit, planning has a destination.
A Simple Pattern: Plan, Do, Check, Stop
A practical agent loop can be expressed as:
- Plan: choose the next highest-trust action.
- Do: execute one step that changes the world or changes the deliverable.
- Check: verify the result against criteria.
- Stop: end when criteria are satisfied.
The key is that “Do” must change something. If the agent keeps “planning” without producing a change in state or deliverable, the system should treat that as drift and intervene.
Stop Rules That Prevent Replanning Loops
Stop rules are not punishments. They are the rails that keep the run moving.
Stop rules you can encode:
- If the agent revisits the same subtask without new evidence, pause and summarize.
- If the plan changes more than a fixed number of times, require human review.
- If the agent’s uncertainty does not decrease after retrieval, stop retrieving and ask.
- If the deliverable has not advanced after a few steps, force a checkpoint and reroute.
- If the remaining work is small, ship a partial with explicit gaps rather than stalling.
A run that ends with a clear partial deliverable is better than a run that ends with nothing.
| Loop symptom | What it usually means | System-level fix |
|---|---|---|
| Endless decomposition | No definition of done | Add acceptance criteria and a deliverable schema |
| Replanning the same plan | No stop rule for plan revisions | Cap replans and require justification |
| Research spiral | Uncertainty never drops | Budget retrieval and force a decision |
| Perfection rewrite | Output is treated as never good enough | Add “ship threshold” and verification checklist |
| Tool oscillation | Routing policy unclear | Choose a primary tool per subtask and stick |
Planning Artifacts That Keep the Agent Honest
A planning phase should leave behind an artifact that can be inspected. Otherwise, replanning becomes invisible.
Useful planning artifacts:
- A short action list where each action has an output and a verification method.
- A dependency note indicating which steps require earlier results.
- A decision log that records why a path was chosen over alternatives.
- A risk list that marks which steps involve side effects or irreversible actions.
When these artifacts exist, the agent can be audited. More importantly, the agent can see its own commitments. Commitments are what prevent cycling.
Here is an example of a plan step that is hard to loop on:
- Step: “Retrieve the current policy for X from the primary documentation.”
- Output: “A short excerpt plus the updated date.”
- Verification: “Second source confirms the same constraint.”
- Stop condition: “If sources disagree, escalate with both excerpts.”
Contrast that with a loop-friendly step:
- Step: “Research X until confident.”
The difference is not intelligence. The difference is structure.
When to Ask Instead of Replanning
Many loops are really unanswered questions.
If the agent does not have a way to ask for clarification, it will keep planning in circles, hoping that more decomposition will remove ambiguity.
A safe system has an ask policy:
- If a missing requirement blocks progress, ask once with a concrete set of options.
- If a decision requires business judgment, escalate to a human reviewer.
- If a conflict cannot be resolved with evidence, present the conflict and ask for a choice.
- If the plan depends on a preference, ask for that preference early.
This reduces looping because the agent stops pretending it can infer what only a human can decide.
The “Ship Threshold” for Intermediate Outputs
Another loop cause is perfection pressure. The agent believes it must produce the final answer in one shot, so it keeps rewriting.
A better approach is intermediate shipping:
- Ship a partial deliverable that matches the format.
- Mark uncertain sections clearly.
- Provide the evidence you do have.
- List the smallest next actions that would remove uncertainty.
Teams tolerate partial output when it is honest and structured. They do not tolerate endless output that never lands.
A Planning Checklist You Can Encode
Planning can be turned into a short checklist that the agent must satisfy before execution begins.
| Planning requirement | What it prevents | How to verify |
|---|---|---|
| Target restated in one sentence | Goal swaps | Compare to the original request |
| Deliverable format specified | Endless improvisation | Confirm required sections exist |
| Step budget chosen | Infinite decomposition | Count steps and cap |
| Verification method per step | Uncheckable work | Each step has evidence or a test |
| Stop condition defined | Looping | Stop triggers are explicit |
When the checklist is satisfied, the agent must move forward. That single rule does more than any prompt trick.
Make Each Step Checkable
Agents loop less when each step produces something checkable.
Checkable steps:
- Create a draft section in the deliverable.
- Run a tool that returns structured evidence.
- Produce a list of assumptions and mark them verified or unverified.
- Generate a diff, a patch, or a concrete artifact the system can validate.
Uncheckable steps are vague and invite loops:
- “Think more about the best approach.”
- “Consider alternatives.”
- “Reflect on implications.”
Reflection can be valuable, but it must be bounded. Otherwise it becomes the loop.
The Role of Checkpoints
Checkpoints cut loops in two ways:
- They force the agent to summarize what it has actually achieved.
- They provide a stable state that prevents repetitive rethinking.
A good checkpoint snapshot includes:
- Current target statement.
- Constraints and approvals.
- Completed steps with evidence.
- Remaining steps with estimates.
- Open questions requiring human input.
When the agent sees this state, it becomes harder to justify replanning from scratch.
Accepting Uncertainty Without Becoming Reckless
Some uncertainty is unavoidable. If the agent requires perfect certainty to proceed, it will never proceed.
The system should define acceptable uncertainty:
- Low-risk tasks can proceed with assumptions, clearly labeled.
- High-risk tasks require verification or human approval.
- If verification is unavailable within budget, the agent must stop and report.
This keeps the agent from both extremes: reckless guessing and endless looping.
The Shipping Discipline
An agent should learn one habit: ship when the criteria are met.
Shipping does not mean “perfect.” It means:
- The deliverable matches the requested format.
- The key claims are supported by evidence.
- The known gaps are listed explicitly.
- The next actions are clear.
If your system rewards this, loops decline quickly.
Keep Exploring Reliable Agent Workflows
• Preventing Task Drift in Agents
https://ai-rng.com/preventing-task-drift-in-agents/
• Agent Checkpoints and Resumability
https://ai-rng.com/agent-checkpoints-and-resumability/
• Latency and Cost Budgets for Agent Pipelines
https://ai-rng.com/latency-and-cost-budgets-for-agent-pipelines/
• Agent Run Reports People Trust
https://ai-rng.com/agent-run-reports-people-trust/
• From Prototype to Production Agent
https://ai-rng.com/from-prototype-to-production-agent/
Books by Drew Higgins
