Planning and search: what should happen next?¶
简体中文 · English
Agents / 64 questions · 16 papers
Try answering each question before opening the explanation. The bank grows as papers and questions are added.
Read this topic's comparisons, analysis, and cross-paper Q&A
64 questions · 16 papers
Agents / Planning and search: what should happen next?
Basics
What kind of apparent success does DRAGO guard against when an LLM converts a natural-language problem to a formal specification?
Repairing LLM-Generated Specifications with Deterministic Diagnosis
Show answer and example
Answer: The model can produce a parseable, solvable specification that omits requirements, and the solver will faithfully solve the wrong problem. DRAGO uses localized diagnostics to constrain repairs rather than taking any solution as proof the original problem was solved. Formalization and solving need separate checks.
Illustrative example: Example: A schedule must assign both people. Omitting one person makes the scheduling problem easier, but that apparent success exposes a formalization error.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why doesn't a satisfiable result prove that a formal specification faithfully captures the task?
Repairing LLM-Generated Specifications with Deterministic Diagnosis
Show answer and example
Answer: The solver checks only the constraints that were written. It cannot tell whether a natural-language requirement was omitted or substituted. DRAGO diagnoses vocabulary contracts, reachability probes, and alignment with the task separately. Repairs must strictly reduce blockers without gaming the check by dropping goals. A probe that runs out of budget must report unknown, not proven unsatisfiable.
Illustrative example: Example: A task requires reaching two places, but a specification listing only one can still be satisfiable. Removing the harder goal makes solving easier without repairing the specification.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
Why can't delete relaxation and full BFS substitute for one another as reachability checks?
Repairing LLM-Generated Specifications with Deterministic Diagnosis
Show answer and example
Answer: Delete relaxation ignores delete effects. A goal absent at its fixed point is unreachable, but goals that appear may not be jointly achievable. Full BFS retains delete effects and proves unsatisfiability only by exhausting the state space; exhausting the budget means unknown. Relaxation is cheaper but one-sided, while BFS is stricter and limited by search size.
Illustrative example: Example: Taking a key may remove a different condition. Two goals can each appear reachable under relaxation even if they cannot hold simultaneously. Full-state search exposes that conflict.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Is it enough for a repair to leave the total blocker weight unchanged or lower?
Repairing LLM-Generated Specifications with Deterministic Diagnosis
Show answer and example
Answer: No. Blocker weight must strictly fall, no blocker dimension may be added, and the goal count must not decrease. Object counts may move only toward the public specification, and a previously solvable specification must not become unsatisfiable or unknown. On rejection the old object is kept and the loop stops. A non-increase rule can accept pointless rewrites, while goal deletion games the diagnostic.
Illustrative example: Example: Reject a rewrite that merely rewords a specification while leaving both blockers. Also reject a rewrite that reduces blockers by dropping a goal.
Sections in the Chinese source: 核心公式, 本地复现与边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why does Janus put unexecuted proposals in the research graph?
Janus: Enhancing Long-Horizon Autonomous Research with Co-Evolving World Models
Show answer and example
Answer: Unexecuted proposals are research directions that can compete for budget. The system estimates value, information gain, and exploration benefit before choosing what to run. The graph also stores actual experimental feedback and abstract skills so later proposals use prior evidence. Predictions guide selection; they do not count as completed experiments or observed scores.
Illustrative example: Example: A model change and a diagnosis of a prior failure can both enter as candidates. Remaining budget determines which one gets compute first.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why compare experimental proposals in pairs and then fit value scores rather than choosing the most compelling description?
Janus: Enhancing Long-Horizon Autonomous Research with Co-Evolving World Models
Show answer and example
Answer: Pairwise comparisons establish a calibratable ordering for expected value, information gain, and exploration benefit. A sparse tournament fits Bradley–Terry scores to connect local judgments. Predictions allocate the experiment budget; executed successes and failures update the model and skills. A high predicted score is neither a completed experiment nor a substitute for execution.
Illustrative example: Example: Proposal A promises a larger metric gain, while B better rules out a key hypothesis. Adjust exploration weight to the remaining budget rather than treating polished promises as results.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
How does selection by predicted gain alone differ from including information gain and exploration benefit?
Janus: Enhancing Long-Horizon Autonomous Research with Co-Evolving World Models
Show answer and example
Answer: Predicted gain alone favors currently promising regions and may overexploit them. Information gain values ruling out uncertain hypotheses, while exploration benefit gives unknown regions a chance. Janus adjusts weights with progress and remaining budget, but only actual execution can correct prediction errors.
Illustrative example: Example: A promises a small but well-understood gain. B may not improve the metric but can distinguish two mechanisms. Early in the budget, B may be worth testing first.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
How do soft comparisons in a sparse tournament become proposal value scores?
Janus: Enhancing Long-Horizon Autonomous Research with Co-Evolving World Models
Show answer and example
Answer: Fit the soft preferences on comparison edges by BCE on sigmoid(g_m-g_n), yielding relative Bradley–Terry scores, then weight the three benefits. This links local preferences without providing absolute success probabilities. The graph and skills update after execution; predictions cannot replace sandbox results.
Illustrative example: Example: If A slightly beats B and B beats C, fit their relative order. A's higher value does not mean its experiment has beaten the best current model.
Sections in the Chinese source: 核心公式, 本地复现, 结果、验证与边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
What do code simulation and model evaluation each do in lookahead?
Code Owns the Simulation, Jev Owns the Evaluation
Show answer and example
Answer: Code executes legal actions on independent copies of the current state and produces actual successor observations. The model compares public consequences and selects an action. This avoids relying solely on textual guesses about transitions, but requires faithful isolation and simulation. Selection itself must not mutate the live environment.
Illustrative example: Example: Open a drawer on a copy to see its contents before deciding whether to open the real one. The scorer need not invent what is inside.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
What does giving newly available successor-state actions add beyond the next observation?
Code Owns the Simulation, Jev Owns the Evaluation
Show answer and example
Answer: The next observation describes the immediate change. Newly available actions show which future paths the step unlocks, exposing long-term value in actions without immediate payoff. Code simulates the transition on a cloned state, and the decision model evaluates public consequences only. Simulator reward or the reference plan must not leak into the scorer.
Illustrative example: Example: Picking up a key does not finish the task, but it enables opening a side door. Seeing that action reveals why the key can matter later.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
What does one-step simulation add over semantic action scoring, and why doesn't it guarantee optimality?
Code Owns the Simulation, Jev Owns the Evaluation
Show answer and example
Answer: Semantic scoring mainly uses action names and the task description. One-step simulation also gives the next observation and newly available actions, revealing unlocked opportunities. It still looks only one step ahead and the scorer may misjudge, so the new action list is not a long-horizon planning oracle.
Illustrative example: Example: Picking up a key may not seem close to the goal until simulation reveals the open-door action. Unknown obstacles behind the door can still prevent success.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Does returning a different object from fork guarantee branch isolation?
Code Owns the Simulation, Jev Owns the Evaluation
Show answer and example
Answer: No. Nested mutable state, random generators, and external resources must also be isolated. Distinct object identities do not justify sharing live files or simulator state. The step exposes only observable text, with no reward, gold plan, or success label. The selected action must be legal and is executed by the caller.
Illustrative example: Example: Two shallow copies share a backpack list, so picking up a key in the clone mutates the real backpack. Different objects did not isolate lookahead.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
What options does JevSpawn preserve when one agent execution path fails?
JevSpawn: Adaptive Agentic Inference through Compositional Action Spaces
Show answer and example
Answer: Early judgments in long tasks can be wrong. Spending the entire budget on one action makes contradictory evidence costly. JevSpawn allocates reasoning adaptively by organizing optional actions into retainable composite branches and shifting effort after execution feedback. This preserves alternatives without promising exhaustive search.
Illustrative example: Example: Inspecting local data and searching online can both be reasonable. If the first path is blocked, continue the other prepared path rather than starting from a blank plan.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why keep several action branches rather than immediately selecting the highest score from the first distribution?
JevSpawn: Adaptive Agentic Inference through Compositional Action Spaces
Show answer and example
Answer: Early probabilities can be wrong. Keeping multiple composite branches leaves room to recover after contradictory evidence. New feedback reweights priors and guides future exploration; it does not rewrite past success labels. Branches consume budget, so parallel retention trades compute for lower decision risk rather than searching all possibilities.
Illustrative example: Example: Keep both searching and inspecting local files. If search fails, switch to the retained inspection branch without rebuilding the plan from scratch.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
How does branch retention differ from independently resampling plans every round?
JevSpawn: Adaptive Agentic Inference through Compositional Action Spaces
Show answer and example
Answer: Retention preserves the probabilities and states of earlier unchosen options for reuse after feedback. Independent resampling can repeat old errors or lose progress. Retention also consumes compute and memory, so more retained candidates do not prove lower cost; compare at equal budgets.
Illustrative example: Example: After search fails, switch to the existing file-inspection branch. Resampling may suggest the same failed search again.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Why do p(a)·exp(feedback) updates still need normalization and a branch budget?
JevSpawn: Adaptive Agentic Inference through Compositional Action Spaces
Show answer and example
Answer: Multiplication yields unnormalized weights. Divide by their total to obtain a distribution, then retain branches within budget. Multiplication cannot recover a branch with zero prior mass, and extreme feedback can cause numerical instability. The local test verifies a finite posterior and top-branch retention without calling a Jev checkpoint.
Illustrative example: Example: Two branches begin at one half with feedback 0 and 1. Their weight ratio becomes 1:e; e/2 is not a valid probability.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
How does an object-level worker differ from a meta-reasoning controller?
Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning
Show answer and example
Answer: A worker performs task content such as retrieval, coding, or analysis. The controller assesses progress, proposes continuation or branching, compares expected benefits, and dispatches work. Control consumes model-call budget and must count in equal-budget comparisons. Persistent artifacts avoid redoing work.
Illustrative example: Example: A worker writes a test file. The controller decides whether to fix failures, try another approach, or stop. The outputs and costs differ.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why does the controller use a compact state while keeping full results in artifact memory?
Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning
Show answer and example
Answer: Control decisions need progress, candidate actions, and remaining budget. Repeating full material in every prompt raises cost. Persistent artifacts hold reusable evidence for on-demand reference. Assess, Propose, Evaluate, and Dispatch divide responsibility for continuing or branching. Compressing control state must not discard actual work.
Illustrative example: Example: Two workers each write an analysis. The controller keeps the conclusions and file references, then opens the original artifact when needed instead of repeating it in every turn.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
What are the trade-offs of separate Assess, Propose, Evaluate, and Dispatch steps versus a single direct controller?
Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning
Show answer and example
Answer: Separation clarifies state summarization, candidate generation, comparison, and execution, and makes budget feasibility independently checkable. Extra control steps cost calls and may not pay off for simple tasks. Direct control is compact but can conflate evaluation with execution. Compare all calls and final outcomes.
Illustrative example: Example: A one-step calculation may not need four rounds of control. In complex research, assessing whether to branch can avoid expensive duplicated experiments.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
How does the local selector weigh expected value and call cost, and what remains unverified?
Thinking Before Thinking: Scaling Agentic Inference Through Meta-Reasoning
Show answer and example
Answer: It rejects actions that exceed the budget, then selects using expected value and call cost. Full artifacts stay in persistent memory while control state stays compact. Expected values are explicit inputs, not success predictions learned from frontier workers. Three-seed diagnostics verify scheduling and state separation only.
Illustrative example: Example: With two calls left, a three-call action is infeasible regardless of expected value. Do not dispatch it and hide the budget overrun later.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why check preconditions before executing an action in a symbolic action gate?
SAGE: Symbolic Action-Gating and Editing for LLM Task Planners
Show answer and example
Answer: Preconditions tell whether the current world permits an action. Checking first blocks known illegal or unsafe actions and gives the planner a typed reason. The gate covers only modeled rules. Passing it does not prove real-world safety when rules or state are incomplete.
Illustrative example: Example: Grasping requires an empty hand and reachable object. The gate blocks a grasp with a full hand before execution rather than explaining a collision afterward.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why edit only the affected subgoal suffix after a failure rather than rewriting the entire plan?
SAGE: Symbolic Action-Gating and Editing for LLM Task Planners
Show answer and example
Answer: The completed prefix reflects actual execution. A full rewrite can repeat actions or wrongly assume the environment reset. The symbolic gate first blocks invalid preconditions and provides a typed cause; the planner then repairs the affected future steps. Keeping the prefix preserves consistency with the current world, not blind commitment to the old plan.
Illustrative example: Example: A cup has been washed, but the cabinet is locked. Revise how to store it rather than washing it again and assuming the cabinet already opened.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
What do typed failure causes add over a free-text message saying an action failed?
SAGE: Symbolic Action-Gating and Editing for LLM Task Planners
Show answer and example
Answer: Typed causes distinguish missing resources, unmet preconditions, and affected subgoals, allowing a local editor to revise the relevant suffix. Generic text can cause a full rewrite or repetition of completed actions. Structured feedback still depends on accurate symbolic state and does not replace real environment feedback.
Illustrative example: Example: A locked cabinet calls for a key or another location; a missing object calls for renewed perception. Those are different recoveries.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Does a zero-token gate establish a low-cost reproduction of the entire LLM planner?
SAGE: Symbolic Action-Gating and Editing for LLM Task Planners
Show answer and example
Answer: No. Only the symbolic gate uses no language-model calls. Plan generation and suffix editing still have their own costs. The local run executes the gate and a reference suffix editor, not AI2-THOR. Three-seed fixture success is neither embodied task success nor end-to-end inference cost.
Illustrative example: Example: A Boolean check can refuse to open a cabinet without producing the new plan. Counting only the check misses recovery's model calls.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why are edges in a query–evidence–answer graph more explanatory than a list of pages?
SearchAtlas: Analyzing Agentic Search Strategies via Evidential Query Graphs
Show answer and example
Answer: Edges show what evidence a query found and which constraint or answer span it supports. This traces how information reaches the conclusion. A link list records visits without establishing support. Graph extraction itself can be wrong, so an edge is not definitive proof of a fact.
Illustrative example: Example: If all sources discuss price, the graph can show no incoming edge for local availability, which is harder to spot in a list of ten links.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why can an evidential query graph reveal a gap after searching many web pages?
SearchAtlas: Analyzing Agentic Search Strategies via Evidential Query Graphs
Show answer and example
Answer: Page count is not constraint coverage. Directed query–evidence–answer relations must show what supports each condition and whether the conclusion crosses an unverified edge. Graph auditing separates repeated evidence from a genuinely completed reasoning chain. A passing graph interface does not establish reliable evidence collection by the search model.
Illustrative example: Example: Ten pages give a product's price, but none confirms regional availability. A claim that it is sold locally still lacks a support edge.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
Why are search diversity and constraint coverage different metrics?
SearchAtlas: Analyzing Agentic Search Strategies via Evidential Query Graphs
Show answer and example
Answer: Diversity measures differences among queries or sources; coverage measures whether evidence supports the requested conditions. Distinct sites can repeat one fact, and a few strong sources can cover several needs. SearchAtlas audits the support structure rather than treating domain counts as evidence chains.
Illustrative example: Example: Five sites can repeat the same product specifications without covering returns. One official policy page can fill that gap.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Does local validation of evidence-propagation edges include the paper's search agents and automatic parser?
SearchAtlas: Analyzing Agentic Search Strategies via Evidential Query Graphs
Show answer and example
Answer: No. The local run builds and checks edges on public fixtures and does not run the paper's five search agents. The paper's edge F1 measures agreement between automatic graph parsing and human annotations, not local QA accuracy. Executing the interface does not establish evidence extraction or fact judgment on real pages.
Illustrative example: Example: Checking connectivity after being given an edge from Evidence A to Constraint B does not prove the model can extract that relationship from arbitrary web pages.
Sections in the Chinese source: 核心公式或操作, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why is paper reproduction an evolving software engineering task rather than a translation of formulas?
DeepRepro: State-Aware Subplanning for Paper-to-Code Reproduction in Evolving Repositories
Show answer and example
Answer: Equations are only part of the specification. Reproduction also involves dependencies, data formats, interfaces, and tests. Each step changes what can follow. DeepRepro studies how to implement and verify within an evolving repository while retaining alignment with the paper, not how to finish by writing one long plan.
Illustrative example: Example: The network is implemented, but loading data reveals a new axis-order requirement. The training code must fit that interface rather than blindly following section order.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why must a paper-to-code subplan read current repository state rather than following paper order alone?
DeepRepro: State-Aware Subplanning for Paper-to-Code Reproduction in Evolving Repositories
Show answer and example
Answer: Interfaces, dependencies, and files change during implementation. Prior assumptions can expire. Fine-grained subplans use current repository state and execution feedback to decide what to do next. The paper defines the goal; repository state defines what can run. Neither is replaced by one initial checklist.
Illustrative example: Example: The next paper step is evaluator integration, but the data interface has changed. Adapt to the new contract instead of generating scripts that no longer connect.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
What can inspecting artifacts tell you, and what requires rerunning the reproduction?
DeepRepro: State-Aware Subplanning for Paper-to-Code Reproduction in Evolving Repositories
Show answer and example
Answer: Artifact inspection checks that code, logs, and tests correspond to the named paper and revision, auditing an existing execution. A rerun must actually install dependencies, call models, and run tests to see whether results reproduce now. The evidence scopes differ; a consistent local DeepRepro replay does not replace a full Code-Dev run.
Illustrative example: Example: A log shows that tests passed on one commit. Repeating the pass in a clean environment still requires installation and execution.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Does artifact replay count as rerunning official PaperBench Code-Dev?
DeepRepro: State-Aware Subplanning for Paper-to-Code Reproduction in Evolving Repositories
Show answer and example
Answer: No. Replay reads real exports from a pinned revision and checks plans, execution steps, and test coverage in paper and state order. It does not pay again for model API calls or the full implementation experiment. A perfect deterministic mini-suite verifies the state-driven path only, not official reproduction capability or cost.
Illustrative example: Example: Replaying an old test record shows whether a plan revision covered the failure; it does not regenerate code and run all tests in the current environment.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why does a long-horizon search agent need reflection that recovers its route, not just an explanation at the end?
LoongReflect: Boosting Long-Horizon Reflection in Search Agents via Global Perspective Distillation
Show answer and example
Answer: Multi-hop evidence gathering includes failed attempts. An early wrong turn can make later steps depend on bad evidence. LoongReflect changes current information and the continuation path so the agent can recover before the task ends. An accurate retrospective cannot improve the evidence gathering of an already completed run.
Illustrative example: Example: If search keeps finding reprints of the same article, return to the earlier branch and change sources before submitting, not after admitting the evidence is narrow.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why model reflection and backtracking as reversible memory-control actions?
LoongReflect: Boosting Long-Horizon Reflection in Search Agents via Global Perspective Distillation
Show answer and example
Answer: Long searches must choose external actions, which traces to retain, and which fork to return to. Making reflection and backtracking policy actions lets the agent learn when to change memory. A privileged teacher supplies training signals and outcome reward covers long-run success, but evaluation must not give the student the teacher's global view or future answers.
Illustrative example: Example: After a dead end, return to the previous branch and keep the reason for failure. Appending reflection text without changing trace state is not real backtracking.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
How do the fast privileged-teacher channel and slow outcome-GRPO channel supervise different signals?
LoongReflect: Boosting Long-Horizon Reflection in Search Agents via Global Perspective Distillation
Show answer and example
Answer: The fast channel distills fine-grained reflection decisions from the teacher's view. The slow channel optimizes long-horizon policy using final trajectory outcomes. One provides local guidance, the other tests overall effectiveness. Privileged information belongs only with the training teacher or evaluator; the deployed student cannot read gold outcomes to choose backtracking.
Illustrative example: Example: A teacher can identify missing evidence at one search step. Final reward checks whether the complete answer succeeds. Online, the student sees only current observations.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Does a low mini-suite average cost establish savings for a real long-context model?
LoongReflect: Boosting Long-Horizon Reflection in Search Agents via Global Perspective Distillation
Show answer and example
Answer: No. The deterministic suite verifies reflection, backtracking, and state transitions without a real browser, external tools, or the paper's large model. Cost follows the diagnostic definition. When accuracy is saturated, inspect branches and traces; proxy counts do not translate directly into real tokens or API fees.
Illustrative example: Example: A rule branch billed a fraction of a cost unit does not mean real model reflection uses the same fraction of tokens or time.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
What experience does ToolLIFT transfer when tool sets change frequently?
Show answer and example
Answer: API names, arguments, and response formats change across services, but functional steps can stay stable, such as checking identity before reading records. ToolLIFT retains that procedural structure and resolves it against the current tool catalog rather than discarding old traces. Concrete interfaces must still be checked.
Illustrative example: Example: A migration still requires finding a customer before retrieving orders, but the old function names and fields cannot be copied into the new service.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why does lifting a trajectory into a function workflow graph help reuse it with new tools?
Show answer and example
Answer: The graph preserves required operations and dependencies while deferring concrete tools and interfaces until execution. A new tool set can implement the same functional plan using its current schemas. Parameter contracts still matter; each node needs a real tool with the required input/output behavior.
Illustrative example: Example: Old search_web and new lookup can implement evidence retrieval, so the workflow can be reused, but arguments and response formats must be matched again.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
What information does a function workflow graph need versus an executable tool plan?
Show answer and example
Answer: The function graph describes desired operations and state dependencies, preserving procedure across catalogs. An executable plan must also bind each node to a current API, parameters, and actual objects. The first gives transferable abstraction and the second grounds it. A sensible graph does not guarantee valid arguments, and legal calls need not cover the whole task.
Illustrative example: Example: The graph says find customer then find orders. Execution must confirm whether the new service returns customer_id or account_id and which field the order API accepts.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Why preserve state dependencies in Lift and Select rather than saving only a list of functions?
Show answer and example
Answer: Edges show what evidence or object each later step needs, and Select chooses tools based on current state. An unordered list loses variable provenance and preconditions. The mini-suite verifies lifting and selection control flow without real tools; perfect fixture scores do not establish transfer to unseen services.
Illustrative example: Example: Retrieve an order_id before canceling that order. A list saying query and cancel without binding the ID cannot produce a legal second call.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why is a name-relevant tool insufficient for a multi-step tool task?
HyperAgent: Planning and Acting over Tool-Schema Hypergraphs for Tool-Use LLM Agents
Show answer and example
Answer: A call is possible only when its inputs are present, and its outputs may be required later. HyperAgent connects task requirements to these production dependencies and fills state gaps instead of selecting the closest interface by text. Multiple valid transitions are needed for an executable workflow.
Illustrative example: Example: Finding a refund tool does not make a refund possible if it needs an order identifier and payment record. First produce those inputs.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why represent tools as input-to-output hyperedges rather than retrieve by name similarity?
HyperAgent: Planning and Acting over Tool-Schema Hypergraphs for Tool-Use LLM Agents
Show answer and example
Answer: A tool can require several inputs jointly and produce multiple outputs. A hyperedge captures those requirements. The task DAG exposes missing state, then producer relations identify tools that can fill it. Name similarity does not guarantee required arguments or outputs for subsequent steps.
Illustrative example: Example: Invoicing requires an order ID and tax ID. Finding the order ID is insufficient; the hypergraph looks for a tax-ID producer rather than invoking the tool immediately.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
Which describes demand and which describes supply: the task DAG or producer support graph?
HyperAgent: Planning and Acting over Tool-Schema Hypergraphs for Tool-Use LLM Agents
Show answer and example
Answer: The task DAG describes dependencies between goal states and exposes inputs missing for later subtasks. The producer support graph uses tool schemas to identify suppliers and their own input requirements. Together they form an executable tool chain. A producer's ability to return a value does not mean it already exists.
Illustrative example: Example: The refund task DAG exposes a missing order ID. The support graph finds the order lookup tool and checks whether its required user ID can be obtained first.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
When expanding a producer, how do you avoid treating its outputs as existing state?
HyperAgent: Planning and Acting over Tool-Schema Hypergraphs for Tool-Use LLM Agents
Show answer and example
Answer: The graph says a call can produce a field, not that it has. Verify actual input availability before calling and update state only from real results. Local deterministic PlanBench verifies the dependency path, not AppWorld. A complete graph or perfect fixture result cannot replace actual API responses and task verification.
Illustrative example: Example: A customer lookup schema says it returns customer_id. Perform the lookup and verify the result rather than filling an ID from the schema.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why does SIRA focus on vocabulary mismatch between how users ask and how evidence is written?
Superintelligent Retrieval Agent: The Next Frontier of Agentic Retrieval
Show answer and example
Answer: Inverted retrieval relies on term overlap. Users describe phenomena in ordinary language while documents may use technical terms, hiding relevant evidence. SIRA uses a frozen LLM to supply possible evidence terms and constrains expansion to the corpus. It bridges query–document vocabulary, not trains an answer generator.
Illustrative example: Example: A user says a program uses more memory over time. Documentation might call it a memory leak. Adding that term can retrieve otherwise missed material.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why filter generated expansion terms using document frequency in the inverted index?
Superintelligent Retrieval Agent: The Next Frontier of Agentic Retrieval
Show answer and example
Answer: An LLM can suggest plausible terms absent from the corpus or ubiquitous terms that cannot discriminate. Document-frequency constraints ensure terms are retrievable and not too broad. One weighted BM25 query then combines them with the original. It preserves lexical retrieval rather than treating imagined terms as evidence.
Illustrative example: Example: An abbreviation absent from the corpus cannot retrieve documents about a rare disease, while research is too broad. Filtering retains useful terms.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
How does a single weighted BM25 expansion differ from multi-turn agent search?
Superintelligent Retrieval Agent: The Next Frontier of Agentic Retrieval
Show answer and example
Answer: SIRA generates and filters missing terms, then runs one weighted retrieval with the original and expanded terms. It does not iteratively read results and replan. This simplifies interaction but limits recovery from first-pass failure. An agent label does not imply multi-turn self-correction.
Illustrative example: Example: After generating three terms, the method returns one ranking. It does not read first-round pages and invent another set of questions unless a separate loop is added.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
How should zero document frequency, the upper bound, and original query weight be handled?
Superintelligent Retrieval Agent: The Next Frontier of Agentic Retrieval
Show answer and example
Answer: An expansion term must satisfy 0<DF(t)≤τ|C|. Exclude zero-frequency terms and those above the bound. Preserve original-query BM25 and add the expansion contribution multiplied by w. Do not replace the original query or silently introduce multiple retrieval rounds. The local run implements the gate and combination, not the paper-scale index and LLM.
Illustrative example: Example: If no expansion term survives filtering, still return results for the original query rather than dropping the whole query.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why is one plausible reasoning chain insufficient for the tool tasks LATS addresses?
Show answer and example
Answer: Tools or environments may return unexpected results, and a single route may not recover after failure. LATS puts reasoning and actions in an explorable search tree, tests candidates through execution feedback, and uses failure reflection to try alternatives. It links proposals to environment results, though search budget and judgment errors still matter.
Illustrative example: Example: The first search result lacks a price. Return to an earlier search node and revise the keywords instead of inventing an answer from the wrong page.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why can UCT's exploration term give a low-scoring action another try?
Show answer and example
Answer: Mean value reflects observed returns. The exploration bonus grows as the parent is visited more and the child remains rare, giving uncertain branches a chance. Execution feedback updates values and failure reflection guides later expansion. Always taking the current best estimate can lock in a wrong branch, and model self-scores cannot replace environmental feedback.
Illustrative example: Example: Action A was mediocre across ten tries; B failed on its only try. UCT may try B again to reduce uncertainty rather than eliminate it permanently.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
How does LATS's MCTS allocate budget differently from retaining several thoughts per layer?
Show answer and example
Answer: MCTS repeatedly selects branches from the current tree, runs rollouts, and backs up returns and visit counts, directing future budget to paths worth revisiting. Layer-wise search usually compares and prunes a frontier at one depth. Both depend on candidate and evaluation quality; different organization and feedback use do not guarantee one wins on a given task type.
Illustrative example: Example: A depth-two route nearly succeeded. MCTS can deepen it later, while a fixed-width search may retain only the best currently rated candidates at that layer.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Is local search over leaves that are complete plans equivalent to the paper's LM-value search?
Show answer and example
Answer: No. The local path retains MCTS statistics, environmental reward, reflection, and backtracking but uses complete plans as leaves. It does not call an LM value function, the HumanEval executor, or WebShop. A perfect deterministic score verifies the search path, not code-generation or web-task success.
Illustrative example: Example: Choosing a valid route from four premade plans differs from generating actions and evaluating intermediate nodes on a real website.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why can a multi-step tool task spend heavily on rereading existing content?
Show answer and example
Answer: If every return makes the planner reread the task, old plan, and all evidence, input grows even when the next action only substitutes a known result. ReWOO separates planning, tool execution, and final synthesis to reduce repetition. It fits workflows whose dependencies can be expressed in advance, while surprises still need recovery.
Illustrative example: Example: Finding an author and then their birthplace is a known two-step pattern. Each returned string does not require regenerating the plan and rereading all earlier evidence.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
How can a planner express tool dependencies without rereading intermediate observations?
Show answer and example
Answer: The planner writes dependencies as variable references. The Worker substitutes obtained evidence into later tool arguments, and the Solver combines results at the end. This reduces repeated planning calls without deleting data flow. A static plan is less adaptive if an unexpected observation determines a later route that was never encoded.
Illustrative example: Example: Store a person's birthplace as E1, then look up its population using E1. The city is bound later without regenerating the whole plan.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
What do ReWOO and ReAct trade off when handling unexpected intermediate results?
Show answer and example
Answer: ReAct reasons after each observation and can revise its route, but repeated model calls cost more. ReWOO plans before execution and avoids repeatedly reading evidence, but relies more on a workable initial dependency plan. Unexpected errors require separate recovery; a static plan is not inherently a feedback loop.
Illustrative example: Example: When the first query returns several namesakes, ReAct can add disambiguation immediately. ReWOO needs an outer recovery if its original plan has no such branch.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
When can a Worker run tools in parallel, and when must it wait for an evidence variable?
Show answer and example
Answer: Calls without unmet dependencies can run in parallel. A call referencing an earlier E variable must wait for that result. The Solver reads both the plan and actual evidence at the end, not imagined planner results. Local tests verify control flow and counts without real search APIs or a multi-size LLM comparison.
Illustrative example: Example: Weather requests for two known cities can run together. Weather for the newly found city must wait for lookup rather than guess its argument.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why is ToT suited to reasoning that requires trying paths and backing out of dead ends?
Show answer and example
Answer: Local choices affect later feasibility. One uninterrupted answer can carry a bad choice to the end. ToT represents expandable intermediate states, retaining directions, judging progress, and backtracking. This requires states that can be meaningfully evaluated; search does not supply a reliable judgment rule by itself.
Illustrative example: Example: If a partial expression cannot reach the target number, change the previous grouping instead of regenerating the entire solution.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
How does searching a tree of thoughts differ from generating several complete answers at once?
Show answer and example
Answer: Intermediate thoughts are states that can be evaluated and expanded separately. Search can retain early alternatives, prune dead ends, and backtrack. Complete answers are often compared only at the end, paying repeatedly for bad prefixes. ToT still depends on value estimation and width/depth budgets; a tree does not make its evaluator correct.
Illustrative example: Example: An arithmetic problem has three possible initial decompositions. Check which preserve feasible remaining values before expanding, rather than finishing a full answer for obviously impossible ones.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
How do BFS and DFS spend limited ToT search budgets?
Show answer and example
Answer: BFS retains multiple states at one layer, making it easy to compare alternatives at similar progress but requiring a broad evaluated frontier. DFS goes deep on one path and backtracks, keeping a narrower frontier but potentially wasting depth on a bad branch. Width, depth, and pruning thresholds depend on evaluation reliability.
Illustrative example: Example: With three opening moves, BFS explores one step from each. DFS may follow the first to the end before trying the second.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Does the local workflow-coherence value represent GPT-4 self-evaluation quality?
Show answer and example
Answer: No. A small PlanBench uses deterministic workflow coherence, a fixed beam, and backtracking to test thought-tree control flow, not GPT-4 or Game of 24. Counts of nodes and backtracks show that search happens. A perfect score does not establish an open-ended language value function.
Illustrative example: Example: A rule can flag an action that violates a precondition. That does not prove a large model can reliably score the future promise of a creative-writing fragment.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Basics
Why does ReAct put answering and interacting with the outside world in one loop?
Show answer and example
Answer: Internal knowledge may lack current facts and cannot establish whether an action succeeded. ReAct interleaves reasoning with tool or environment calls and uses results in later decisions. This fits tasks mixing information and actions. Observations support correction, but tool failures and misinterpretation can still cause errors.
Illustrative example: Example: Check inventory before deciding whether to order or choose an alternative, rather than guessing stock from general knowledge.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Core mechanism
Why must observations return to the next context instead of letting the model continue its own reasoning alone?
Show answer and example
Answer: Actions obtain real external feedback so the next step can revise beliefs and plans. Without observations, the model can treat expectations as actual outcomes and lose the action-reasoning loop. ReAct alternates reasoning, executable actions, and observations, rather than merely mentioning tools in text.
Illustrative example: Example: The model expects a file to exist, but reading it returns not found. Change the search path rather than analyzing imagined contents.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Method comparison
How do ReAct and pure chain-of-thought differ in when errors surface?
Show answer and example
Answer: Pure chain-of-thought can keep developing internal assumptions without confronting external facts. ReAct gets observations through action and can revise plans mid-run. Feedback may still be incomplete or tools may fail, so alternation does not guarantee facts; verify tool results and their support for the conclusion.
Illustrative example: Example: Search can reveal that author B, not A, wrote a book. Pure internal reasoning may continue inventing details about A.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Planning and search: what should happen next?
Implementation details
Why distinguish generated tokens from environment tokens during ReAct training or evaluation?
Show answer and example
Answer: Tool observations are external state, not policy actions. Do not count them as generated capability or train policy gradients on them. The local deterministic suite verifies the loop and counts; the separate isolated capability protocol also prevents the policy from reading references. Shared method names do not make the evidence interchangeable.
Illustrative example: Example: A 100-word tool return is not 100 words generated successfully by the policy, and hidden answers must not enter a visible reference field.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Topic guide and reading order
Start with this question¶
With long tasks and delayed feedback, how should an agent choose its next action and undo an earlier mistake?
Takeaway¶
Make a single answer an observable decision process: what is known, what is missing, and what evidence can an action obtain? ReAct alternates reasoning and action so environment observations can correct plans. Tree search branches intermediate states, evaluates them, and retains or backtracks under budget. Both track state, and more branches cost model and tool calls. Draw the state, action, and observation first.
Example¶
For a failing unit test, read the stack trace and trace a bad input dimension to its caller. If both a data-split bug and a model-shape bug are plausible, design a small check for each and keep the branch supported by observations. A plan is useful when it guides the next evidence-gathering action. Rewriting one thought three times adds no evidence.
Common pitfall¶
A model score is not independent correctness. More nodes cannot fix bad state or a biased evaluator. Match total call budgets. Local thought/action loops and deterministic search are mechanism checks, not reproduced task-success rates. Keep gold answers, future observations, and hidden plans outside actor inputs.
Reading order¶
Read ReAct for the reason–act–observe loop, Tree of Thoughts for branching, evaluation, and backtracking, then ReWOO for planning before execution to reduce duplicate calls.
Check your understanding¶
Under the same budget, is writing five plans the same search as running two tool checks that distinguish hypotheses?
Show suggested answer
No. The first may only expand text; the second changes observable state and rules out hypotheses. Branch search needs branch states, expansion, evaluation, retention, and backtracking rules. Choose based on information gained and tool cost, not the number of plans.