Planning & Control Flow

Interleave a single thought, a single tool call, and a single observation per step so the agent reasons over fresh evidence.

Plan all the steps once with a strong model, then execute each step with a cheaper model under the plan.

Trigger the agent on external events (webhooks, message queues, file changes) instead of user requests or schedules.

Run the agent on a fixed schedule independent of user requests.

Run the same prompt against a fixed spec in a deterministic outer loop until the spec is satisfied.

Have the agent author a plan file (e.g. todo.md) early in the run, tick items as it completes them, and re-inject the remaining plan into context; the file is durable plan and working memory.

Express agentic logic as a visual graph of typed nodes connected on a canvas with Start and End nodes so non-coding stakeholders can read and edit the flow.

Drive the agent loop from a human-authored specification document rather than free-form prompts.

Trigger a fresh planning step when execution evidence contradicts the current plan.

Before any code is generated, author a multi-pillar spec and have the agent critique it for ambiguity and edge cases, so that the loop executes against a reviewed target rather than a fresh prompt.

Anticipate the user's goal by capturing surrounding multimodal context (gestures, screen state, environment) in addition to what the user types or says.

Borrow the behavior-tree formalism: leaves are LLM calls or tools that return success/failure; a tree of selectors and sequences orchestrates control flow.

Construct an agent's behavior tree starting from the desired goal condition and recursively adding child nodes whose post-conditions satisfy each parent's pre-conditions.

Spawn 100 or more identical, full-capability agent instances in parallel — each a complete general agent rather than a role-specialised worker — and aggregate their independent outputs into a single…

A group of agents jointly assigns values to shared variables to minimise (or maximise) a global cost defined by inter-agent constraints, exchanging only the messages needed.

Lift the agent loop into a search tree with a learned value function and backtracking.

Take ReWOO's plan-as-DAG and run independent steps in parallel through a task-fetching dispatcher.

Run two nested loops: an outer planner agent decomposes the goal into subtasks; an inner executor runs a ReAct loop on each, and the outer can replan based on the inner's progress.

Each agent maintains a partial view of others' plans and incrementally merges local plans into a shared partial global plan, interleaving coordination with execution.

Plan a complete dependency DAG with placeholder variables before any tool runs, then execute and substitute observations into the plan.

Have the agent ask a clarifying question before acting on an ambiguous request.

Decompose a goal into sub-goals recursively until each leaf is directly actionable.

Generate plan steps by sequentially querying the model at each step rather than producing the whole plan upfront in one call.

Express map-over-collection inside a visual workflow as an explicit Iteration node that runs a subgraph once per element of an input array, with bounded, deterministic, observable execution.

Generate multiple candidate next-steps at each plan node enabling later selection — the planning generator pattern paired with tree-of-thoughts / LATS-style search.

An agent whose explicit job is to split an incoming user query into smaller independent sub-queries that can be answered sequentially or in parallel, then merge results.

Generate one linear sequence of intermediate steps from current state to goal — the lightweight planning alternative to tree-of-thoughts and multi-path generation.

Before any consequential decision, require the agent to gather a declared set of contextual inputs (resource availability, schedules, downstream dependencies) into a 'context map' the decision must c…

Branching decisions live in deterministic application code while the LLM is invoked at strategic points to produce structured signals that the code branches on.

Balance taking the best-known action (exploit) with trying alternatives that might be better (explore).

Hierarchical Task Network decomposition provides the procedural backbone; the generative LLM is invoked only at leaf nodes for the parts of the task that are genuinely open-ended.

Split an oversize task into independent chunks, process each in parallel, then aggregate.

Analyse the user's articulated prompts and accompanying context to derive a precise, actionable goal before any planning or tool use begins.

Add an explicit Observer role between Planner and Executor so progress is checked against the plan instead of trusted blindly.

Run a single agent through a protracted think-search-verify-revise-act loop spanning hundreds of tool calls, autonomously re-formulating hypotheses across the run.

Design the agent as a pure function (state, event) → newState; entire execution history is held in an external event log; enables pause / resume / replay / time-travel without bespoke checkpointing.

Mandate an explicit problem-space representation step before the agent attempts solutions, mirroring how expert humans build a mental model of constraints and dependencies before solving.

At each node of an inference-time search tree, use Thompson sampling to decide whether to deepen an existing answer or branch a fresh attempt, optionally choosing per-node which underlying LLM to inv…

Run candidate multi-step strategies inside an internal simulator of the environment before committing in the real world — broader than simulate-before-actuate (single action) by simulating multi-step…

Decompose a long-running job into three role-isolated agents — a Planner emitting a feature list, a Generator working one chunk per fresh context, and an Evaluator grading against a rubric without se…