Tools and collaboration: turning plans into inspectable actions¶
简体中文 · English
Agents / 197 questions · 49 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
197 questions · 49 papers
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does programmable retrieval return only explicitly printed documents to the model?
Learning to Program Retrievals: Composing Search Primitives via Reinforcement Learning
Show answer and example
Answer: A program can retrieve, fuse, deduplicate, and rerank a large pool, but context receives only explicit outputs. This separates retrieval work from observation budget. Secretly appending intermediates bypasses program selection and invalidates the policy comparison.
Illustrative example: Example: Retrieve 50 documents and print three after reranking. The model sees only those three, not the other 47.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why retain retrieval-program supervision for a wrong answer while masking its answer span?
Learning to Program Retrievals: Composing Search Primitives via Reinforcement Learning
Show answer and example
Answer: A syntactically valid, executed program can contain useful retrieval structure even when the final answer is wrong. Mask wrong-answer supervision so it does not teach generation errors. Actors cannot see verifier gold, and environment observations are not policy-generated tokens.
Illustrative example: Example: A program combines and deduplicates two retrieval routes correctly but the answerer copies a date incorrectly. Keep program supervision and mask the wrong date.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does mutating retrieval structure while preserving the query differ from asking the model for a new query?
Learning to Program Retrievals: Composing Search Primitives via Reinforcement Learning
Show answer and example
Answer: Keeping the query isolates retrieval mode, width, fusion, and reranking changes. A new query changes semantics along with control flow. Local mutations can restrict exploration, but using gold to produce correct documents is not a valid mutation.
Illustrative example: Example: Widen retrieval from three to five under the same query to test evidence coverage. Adding answer keywords simultaneously confounds the change.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Does Meta's release of full RPL code automatically make the local typed-program component a full reproduction?
Learning to Program Retrievals: Composing Search Primitives via Reinforcement Learning
Show answer and example
Answer: No. Release improves provenance, not local fidelity. Local work still omits neural retrievers, cross-turn Python state, policy generation, GRPO, and distillation. The main project's CC-BY-NC and vendored licenses still apply. Public code is not permission to copy or upgrade evidence.
Illustrative example: Example: Having factory blueprints does not mean a small pipe simulator makes the same product. The real execution path and costs still need verification.
Sections in the Chinese source: 论文信息, 背景与主要改动. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
How does the local restricted RPL program control retrieval, fusion, and final output?
Learning to Program Retrievals: Composing Search Primitives via Reinforcement Learning
Show answer and example
Answer: It allows at most four distinct queries, prescribed retrieval and reranking widths, real fusion of multi-route results, and a cap on printed documents. Conflicting contents for one ID are rejected, and reranking cannot add unretrieved documents. Local execution interprets data classes and an injected SDK, not arbitrary Python or the paper's token limits.
Illustrative example: Example: Retrieving twenty items and printing three legitimately separates compute and observation. Quietly injecting an unretrieved document during reranking breaks provenance.
Sections in the Chinese source: 核心公式, 本地复现, 成本与复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does World of SWEcraft model a package ecosystem maintained by several agents?
World of SWECraft: Agent Collaboration at Scale via Simulated Software Worlds
Show answer and example
Answer: Fixing one isolated issue does not capture cross-project dependencies or long-term effects. Maintainers continuously change packages, affecting downstream users and requiring coordinated releases alongside local progress. Activity volume does not measure ecosystem quality; verify downstream functionality and resources.
Illustrative example: Example: A package changes a function signature and passes its own tests, but two dependent packages no longer import. Single-issue tests can miss that.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why validate collective improvement on hidden downstream packages instead of only agent-maintained microbenchmarks?
World of SWECraft: Agent Collaboration at Scale via Simulated Software Worlds
Show answer and example
Answer: The group may overfit visible benchmarks while breaking real dependents. Installing frozen releases in unseen downstream packages tests compatibility and benefits. Failures stay in strict or carry aggregation rather than being dropped, and instruction counts do not measure wall-clock speed.
Illustrative example: Example: A function specialized for self-test inputs can improve a microbenchmark while breaking a downstream parser. Hidden dependencies reveal the regression.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does persistent multi-session collaboration differ from one indefinitely long group chat?
World of SWECraft: Agent Collaboration at Scale via Simulated Software Worlds
Show answer and example
Answer: Agents hand off through repositories, issues, PRs, releases, and durable memory, with separate session permissions and budgets. Shared artifacts preserve work without replaying every discussion, but coordination, ownership, and versioning still cost. More agents or larger models do not automatically produce more.
Illustrative example: Example: One maintainer releases a new version and a dependent library adapts using release artifacts, without all chat history being visible every turn.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
How do strict and carry aggregate speed in correctness-failure rounds?
World of SWECraft: Agent Collaboration at Scale via Simulated Software Worlds
Show answer and example
Answer: Strict assigns failed package tasks speed ratio one; carry uses the most recent passing ratio. Both retain all tasks and take a geometric mean. Instruction-count gains are not wall-clock speedup. Local formulas do not execute the ecosystem or reproduce its 55K sessions.
Illustrative example: Example: If an optimization breaks tests, keep the package in the denominator. Carry uses its last valid speed, not a faster failing run.
Sections in the Chinese source: 核心公式, 本地复现与成本判断. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why can a large tool catalog consume context without surfacing the right next action?
TRACER: Trajectory-Aware Tool Retrieval for LLM Agents
Show answer and example
Answer: Keeping every description is costly, while static Top-K may omit the next interface. TRACER predicts a subset from executed transitions and current context so discovery adapts to progress. Candidate prediction does not replace argument validation or successful calls.
Illustrative example: Example: After identity lookup, account retrieval is more likely than rereading a thousand tools. If the user cancels, context should change the recommendation.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why does a tool trie use the complete within-turn call prefix instead of just the previous tool?
TRACER: Trajectory-Aware Tool Retrieval for LLM Agents
Show answer and example
Answer: The same previous tool can occur in distinct workflows. A full prefix preserves path identity and retrieves real training transitions. Context similarity adds current intent, with learned weight and temperature. Unknown prefixes fall back to catalog search rather than force an unseen path onto the nearest old branch.
Illustrative example: Example: Search→download may lead to parsing, whereas authenticate→download may need permission checking. Download alone conflates them.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why learn the mix of frequency and context priors rather than simply add them?
TRACER: Trajectory-Aware Tool Retrieval for LLM Agents
Show answer and example
Answer: Frequent tools can be wrong for current context, while semantic transitions may have few samples. Two linear heads use five state features to set mixing weight and temperature. Temperature changes the confidence gate, not order. Coverage and calibration still matter; frequency is not success probability.
Illustrative example: Example: A prefix usually leads to A, but the current context resembles past transitions to B. Reduce the frequency weight rather than copy blindly.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Why must cross-fitting exclude the target trajectory's entire fold rather than only hide the current label?
TRACER: Trajectory-Aware Tool Retrieval for LLM Agents
Show answer and example
Answer: Other steps from that trajectory can affect trie counts and edge-context means. Hiding the label alone still leaks its structure. Each signal must use an index excluding the full fold, and standardization is fitted on training folds. Training real heads on synthetic vectors is not real tool-selection capability.
Illustrative example: Example: The target tool may be absent from loss input yet already counted in the all-data index, revealing its own answer path.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does SSR start with discovering which agent to consider in a large directory?
Show answer and example
Answer: Sending every capability description to a model raises selection cost. SSR uses discrete public-description signals to build an inverted candidate pool for later decisions. Matching is interpretable and literal, so paraphrases with no shared signal can legitimately yield nothing.
Illustrative example: Example: An invoice signal in both a task and a capability card creates a candidate. Disjoint terminology may not.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why does SSR return an empty pool on no lexical match rather than claim a semantically similar agent?
Show answer and example
Answer: Structural signals are terms and adjacent phrases from explicit fields. IDF gives no semantic score to unmatched content. Inverted lookup skips only zero-score candidates and retains the same lexical ranking. An empty pool exposes missing evidence; arbitrary fallback is not semantic understanding by SSR.
Illustrative example: Example: A card says invoice, and a nonoverlapping paraphrase gets no hit. This is a lexical coverage gap, not a discovered synonym.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why do inverted SSR and an exhaustive scan of the same IDF score rank positive matches identically?
Show answer and example
Answer: All IDFs are positive, so the postings union collects exactly cards sharing at least one query signal and excludes zero scores. Rank by the same score, match count, and ID tie-breaker. Savings come from skipping disjoint cards, not changing semantics. No hit means an empty pool.
Illustrative example: Example: Of a thousand cards, only ten share a term. Scoring those ten returns the exhaustive scan's positive ranking without fake fallbacks.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
What constraints govern repeated words, the 64-signal limit, and empty_pool?
Show answer and example
Answer: Signals are binary and deduplicated. Frequency only affects unigram truncation above the limit, followed by deterministic bigram filling. No hit returns empty_pool without calling a provider for an invented answer. API failures and illegal indexes stay failures. There is no real local LLM orchestration success metric.
Illustrative example: Example: Repeating search ten times does not yield tenfold score, and a zero lexical match cannot silently switch to full-directory semantic retrieval.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does LEASH run a weaker model and hand off only in riskier states?
LEASH: Uncertainty-Aware Weak-to-Strong Escalation and Oversight for Computer-Use Agents
Show answer and example
Answer: Strong calls throughout cost more; weak-only execution may fail in critical states. Risk-triggered takeover trades task outcomes against resource use. Handoffs are not free and risk scores are not inherently probabilities. Account for complete execution and results.
Illustrative example: Example: Use a small model for routine file search and a stronger one for rare recovery states. Value depends on takeover count and actual delivery.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why keep using unexecuted Shadow actions after the stronger model takes over?
LEASH: Uncertainty-Aware Weak-to-Strong Escalation and Oversight for Computer-Use Agents
Show answer and example
Answer: Handoff mitigates weak-model failure but does not prevent the strong model drifting. Weak shadow representations offer a cheap reference for periodic review without executing shadow actions. Distance to the failure reference is not calibrated failure probability or a fixed test takeover quota.
Illustrative example: Example: The strong model is about to delete while the weak shadow suggests checking permissions. Trigger review without running both actions.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why isn't a reference-distance score a calibrated failure probability?
LEASH: Uncertainty-Aware Weak-to-Strong Escalation and Oversight for Computer-Use Agents
Show answer and example
Answer: It compares the weak representation's Mahalanobis distances to Pass and Fail means. Higher values only indicate relative proximity to failure. Shift, covariance, and representation geometry affect thresholds, and target routing proportions are not test quotas. Calibrate on references rather than map scores directly to percentages.
Illustrative example: Example: Score two does not imply 20% failure; a different scale or task distribution can change risk at the same score.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Why calibrate the runtime gate on each task's maximum score, and when does Shadow trigger?
LEASH: Uncertainty-Aware Weak-to-Strong Escalation and Oversight for Computer-Use Agents
Show answer and example
Answer: Calibrate reference risk on maximum action score per task, keeping all observations from a task in the same out-of-fold split. Step quantiles change the overall escalation rate. After handoff, probe every three steps from the first strong action: 1, 4, 7, with at most six interventions and a stop after two changes to strong actions.
Illustrative example: Example: Starting checks only in the third interval misses first-step risk. Splitting steps from one task across train and validation leaks task features.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射、成本与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why not use equally expensive reasoning for every small decision in Jev Agent Harness?
JevAgentHarness: Benchmarking, Deploying and Training Decision Models That Share Control with LLMs
Show answer and example
Answer: Tool workflows have bounded decisions, some suitable for a cheap decider and others needing more reasoning. Explicit delegation with fallback lets savings and error costs define the scope. A cheap decider is not automatically good for open tasks; validate it on states it actually encounters.
Illustrative example: Example: A cheap model may decide whether to keep a candidate record. An open explanation with missing evidence may still require the main model.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why calibrate delegation thresholds by decision type on the agent's own shadow trajectories?
JevAgentHarness: Benchmarking, Deploying and Training Decision Models That Share Control with LLMs
Show answer and example
Answer: Closed-loop execution reaches states after errors, which clean offline multiple choice does not cover. Tool and argument choices also have different risks and benefits. Compare decision and strong models on matched examples, choose reliable thresholds by task value and cost, and fall back on uncertain or unseen classes.
Illustrative example: Example: A small model chooses tools correctly but often supplies wrong arguments. Give the categories separate gates instead of applying one overall accuracy.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does a cost- and task-value threshold differ from a fixed 0.7 confidence gate?
JevAgentHarness: Benchmarking, Deploying and Training Decision Models That Share Control with LLMs
Show answer and example
Answer: Utility uses paired correctness differences between the decision and strong models plus saved call cost. Select a confidence suffix whose bins are all nonnegative. A constant ignores class, error cost, and overconfidence. Fitting is not infallible; the paper retains failed calibration and no-gain additional training.
Illustrative example: Example: A high-stakes error can outweigh a small saving, while a recoverable decision may tolerate a lower delegation threshold.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Should unknown classes or undersampled categories use the nearest threshold?
JevAgentHarness: Benchmarking, Deploying and Training Decision Models That Share Control with LLMs
Show answer and example
Answer: No. Default bins require at least twenty rows, keep equal confidence together, and merge undersized tails. Too few rows for a category, no eligible suffix, or an unknown type means fall back to the strong model. Fit uses calibration validation only; runtime sees no gold or strong-model answers. Local handwritten callbacks test the contract.
Illustrative example: Example: Three argument decisions cannot calibrate a reliable threshold. Fall back rather than borrowing a different tool class's threshold.
Sections in the Chinese source: 核心公式, 本地复现, 成本与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why study teamwork through long-horizon Minecraft completion rather than single-instruction following?
A team of Gemini 4 Argon agents beats Minecraft
Show answer and example
Answer: Exploration, resource gathering, crafting, and combat create dependencies in time and materials, with new state along the way. Multiple agents, observation, and shared information support progress. One full completion demonstrates a possibility but not a probability or causal gain from one module.
Illustrative example: Example: Mining and food gathering can be divided across roles. A note that mining is done does not produce crafting material if it was never acquired.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why can't the Observer and shared notes replace each executing agent's actual environment feedback?
A team of Gemini 4 Argon agents beats Minecraft
Show answer and example
Answer: Summaries help coordinate but can lag or miss local changes. Programs must use world responses to determine success. Programmatic action, durable notes, and multi-session collaboration support long tasks together. A chat claim cannot advance dependent steps, and a described case is not a local run.
Illustrative example: Example: A note says a bridge was fixed, but another agent sees it destroyed. Update from current observation instead of trusting the old note.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How compare evidence and costs for four collaborating agents versus one long-running agent?
A team of Gemini 4 Argon agents beats Minecraft
Show answer and example
Answer: Parallel roles can divide exploration and execution but add communication, duplication, and coordination. The paper gives one long success in a random Easy world, not multiseed controls establishing reliability or cost advantage. Completion does not mean four agents generally beat one.
Illustrative example: Example: Four agents can gather resources faster or all collect the same item. One success cannot isolate teamwork from extra compute.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Can a 27-hour completion be stated as 100% success or a local executable capability?
A team of Gemini 4 Argon agents beats Minecraft
Show answer and example
Answer: No. One case has no independent repetition denominator. Roughly 24,000 calls are the authors' costs. Local work records literature and cost without commercial calls, game execution, GPU receipts, or an Evolve operator. Formal interaction notation is not a Minecraft implementation.
Illustrative example: Example: One game completion is one successful case, not ten successes or a local receipt based on the authors' video.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why log evidence availability time as well as event time during incident diagnosis?
Diviner: Agentic RCA with Human-Governed Adaptation for Large-Scale Infrastructure
Show answer and example
Answer: An investigator may not have later aggregates or conclusions when an event happens. Diviner requires matching incident, target, and window with available time no later than as-of. That separates contemporaneous material from final explanations, but structural compliance does not prove entailment or root cause.
Illustrative example: Example: An error at 10:00 appears in a report generated at 11:00. A 10:30 investigation cannot use that report despite its earlier event time.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why does a tool timeout neither support nor refute a root-cause hypothesis?
Diviner: Agentic RCA with Human-Governed Adaptation for Large-Scale Infrastructure
Show answer and example
Answer: A timeout means no valid observation, not that the service is healthy or faulty. Evidence must match incident, target, time window, and availability. Similar incidents are clues only. Adapting investigation is distinct from publishing a workflow or executing mitigation, which requires separate authority.
Illustrative example: Example: A ranking-log query times out. Mark unknown and gather evidence differently rather than conclude ranking was healthy or use a later postmortem as contemporaneous evidence.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why govern live investigation adaptation differently from publishing persistent knowledge?
Diviner: Agentic RCA with Human-Governed Adaptation for Large-Scale Infrastructure
Show answer and example
Answer: A current plan can adapt to new evidence with local scope. Shared workflows influence future incidents and require a new version, replay validation, and artifact-owner approval. The paper does not authorize autonomous production mitigation or turn observational MTTR changes into randomized causal effects.
Illustrative example: Example: Add a config lookup to this incident. Rewriting the team-wide playbook needs independent validation and an owner release.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
What identity and time constraints must evidence satisfy before entering EvidenceLedger?
Diviner: Agentic RCA with Human-Governed Adaptation for Large-Scale Infrastructure
Show answer and example
Answer: Bind records to the current incident, target, and investigation window. Distinguish event time from evidence availability, which must not exceed as-of. Otherwise unrelated logs or later summaries can be mistaken for evidence available then. Local tests verify provenance and governance, not root cause.
Illustrative example: Example: A predawn error summarized in the morning is not known to the predawn investigator. A similar error from another incident cannot be mixed in.
Sections in the Chinese source: 核心公式, 本地复现, 成本与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why repair an early partial trajectory rather than just summarize failure at the end?
ARIA: Runtime Inspection and Amendment for Multi-Agent Systems
Show answer and example
Answer: Early mistakes propagate across agent messages. Cutting and continuing during a run can prevent amplification. ARIA learns when and where to intervene and how to continue, but must execute the patch to verify it. Replacing a suffix does not prove diagnosis or exact environment rollback.
Illustrative example: Example: A message uses the wrong unit and later agents copy it. Repair before propagation rather than only explain it after completion.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why may a repaired trajectory propose a pending tool call but not write a successful tool result?
ARIA: Runtime Inspection and Amendment for Multi-Agent Systems
Show answer and example
Answer: Results must come from execution; otherwise the patch fabricates evidence. The cut preserves the observed prefix, and continuation proposes new actions before comparison with a fresh control. Structural validity does not prove correct attribution or repair.
Illustrative example: Example: Proposing to rerun tests is legal. Saying all tests passed in the continuation is not; execute and observe them.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why require a patched pass and fresh-control failure together for verified repair?
ARIA: Runtime Inspection and Amendment for Multi-Agent Systems
Show answer and example
Answer: A patched success alone can result from retry randomness or environmental changes. If the fresh control also succeeds, improvement cannot be attributed to a necessary patch. The pair rules out simple retries as repair evidence but is not exact causal replay of a full framework. The paper reconstructs continuation context within a stated scope.
Illustrative example: Example: Tests pass after patching, but also pass on a fresh unpatched rerun. Do not use that pair as verified repair training data.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
What hard constraints apply to the cut event, patch types, and size?
ARIA: Runtime Inspection and Amendment for Multi-Agent Systems
Show answer and example
Answer: The cut retains the referenced observed event and, if nonempty, must precede the identified bad event. A patch allows at most eight events and 12,000 canonical JSON characters, requires nonconflicting IDs, and cannot replay the old suffix with new IDs. Only assistant messages and pending calls are allowed, not fabricated tool results. No five-stage model training ran locally.
Illustrative example: Example: Propose another order lookup, but do not insert an invented tool observation that it was paid.
Sections in the Chinese source: 核心公式, 本地复现, 成本与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why rerank by execution reliability when a tool is semantically relevant?
RATED: Reliability-Aware AI Agent Tool Retrieval via Execution Dynamics
Show answer and example
Answer: The best matching description may refer to a tool that fails, times out, or is unavailable. RATED retrieves semantic Top-K first, then combines static metadata and per-tool online feedback. Reliability complements relevance without justifying a tool that cannot solve the task.
Illustrative example: Example: Favor the weather API that still works over a frequently timing-out equivalent, not an irrelevant reliable calculator.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why does execution feedback update only the LinUCB arm for the tool actually selected?
RATED: Reliability-Aware AI Agent Tool Retrieval via Execution Dynamics
Show answer and example
Answer: Only execution exposes success, error, or timeout. Unchosen outcomes are counterfactual. Per-tool updates avoid blaming all candidates for one failure, while discounting reduces old reliability evidence over time. Semantic top-K supplies candidates; exploration does not prove an uncalled tool is better.
Illustrative example: Example: If tool A times out, update A. Do not mark unused B successful; retain uncertainty until it is tried.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What do the frozen dual encoder and online discounted LinUCB adapt to?
RATED: Reliability-Aware AI Agent Tool Retrieval via Execution Dynamics
Show answer and example
Answer: The offline encoder supplies semantic query-tool representations and stays frozen in deployment. LinUCB updates each arm from actual feedback and discounts older evidence as reliability changes. Bandit reranking is not online retraining of the text encoder.
Illustrative example: Example: Successful calls after service recovery can raise arm value while encoder parameters remain unchanged.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
How does γ affect history for the selected tool in discounted LinUCB?
RATED: Reliability-Aware AI Agent Tool Retrieval via Execution Dynamics
Show answer and example
Answer: Decay the selected arm's diagonal A and b by γ, then add current squared features and execution feedback. Older evidence loses influence, and A also controls exploration uncertainty, so this is not just changing a success rate. The local encoder trained briefly, but the authorized tool binding failed; bandit updates are not tool success.
Illustrative example: Example: Recent timeouts can outweigh a long success history under decay. Permanent cumulative statistics may hide the change.
Sections in the Chinese source: 核心公式, 本地复现, 结果、验证与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why evaluate cheap decisions per completed delivery instead of per invocation?
When Faster Decisions Do Not Make Better Agents: An Empirical Study of Jev in Agent Workflows
Show answer and example
Answer: Agents combine decisions, tools, and retries. Local savings can increase downstream failures and reruns. Jev Workflow counts all resources required for delivery so cheaper decisions and extra attempts share one denominator. Report different success subsets separately rather than advertise local latency alone.
Illustrative example: Example: Saving half a second per decision may cost three extra attempts. The user pays for all of them.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why might faster individual decisions raise total resources per successful delivery?
When Faster Decisions Do Not Make Better Agents: An Empirical Study of Jev in Agent Workflows
Show answer and example
Answer: Errors can cause retries, failed recovery, or premature completion. Resource per success includes cost and time for every attempt divided by successes. Matched successes compare smooth paths only and cannot replace all-attempt delivery or hide failures.
Illustrative example: Example: A route half as expensive per attempt may succeed twice in ten tries, making it costlier per delivery than a slower route that succeeds eight times.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What do matched-success and all-attempt delivery each measure?
When Faster Decisions Do Not Make Better Agents: An Empirical Study of Jev in Agent Workflows
Show answer and example
Answer: Matched-success compares resources only on task/run pairs where both configurations succeed, isolating cost along successful paths. All-attempt includes failed resources and all successes to measure delivery. Conditioning on joint success can hide one configuration's many failures.
Illustrative example: Example: Three jointly solved tasks can show faster decisions without revealing failures among the seven others. Interpret both views.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Why not compute a tidy ratio with zero successes, missing pairs, or invalid resource values?
When Faster Decisions Do Not Make Better Agents: An Empirical Study of Jev in Agent Workflows
Show answer and example
Answer: Cost per success is undefined at zero successes. Missing task/run pairs invalidate comparisons, and negative or nonfinite resources are invalid observations. Report or reject these states rather than delete failures to repair a denominator. The infrastructure consumes real paired traces and neither loads nor fabricates Jev weights or API outputs.
Illustrative example: Example: Do not add ε to an all-failure denominator or copy a paper row as a local run.
Sections in the Chinese source: 核心公式, 本地复现, 结果、验证与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does MingBird focus on small models doing long multi-tool tasks?
Mingbird: A Local-First Agent Harness Enabling Small Open Models to Complete Real Tasks
Show answer and example
Answer: Small models have limited context, tool understanding, and error recovery. Loading all tools and all history adds pressure. MingBird organizes tools, execution loops, and completion checks under resource constraints. Components do not establish reliable arbitrary long-horizon capability; verify actual deliverables.
Illustrative example: Example: A file-and-database task first shows the relevant domain, then executes steps and verifies output rather than reading the whole catalog and declaring completion.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why reintroduce the original task and plan and check artifacts after the model says it is done?
Mingbird: A Local-First Agent Harness Enabling Small Open Models to Complete Real Tasks
Show answer and example
Answer: A long trajectory can forget requirements or confuse executed actions with delivery. Checking the original exposes missing files, missing verification, and early stopping. Loop detection and bounded format rescue address runtime faults, not model knowledge. Budget actual UTF-8 bytes rather than character counts.
Illustrative example: Example: Creating a file does not satisfy a task that also requires a test report. Re-read the original artifact list.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What do domain routing and flattened schemas trade off against showing all original tools?
Mingbird: A Local-First Agent Harness Enabling Small Open Models to Complete Real Tasks
Show answer and example
Answer: Routing narrows the tool domain. Presenting required arguments when schemas are large reduces formatting burden and irrelevant interfaces. Optional arguments can still matter, and user constraints cannot be dropped. This changes harness input and recovery, not base architecture.
Illustrative example: Example: A tool has ten parameters and two required ones. Start with a simplified schema but still honor a user-requested optional filter.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
How are duplicate-call signatures and prefill budget computed?
Mingbird: A Local-First Agent Harness Enabling Small Open Models to Complete Real Tasks
Show answer and example
Answer: Use tool name and canonical JSON arguments, so key order does not distinguish calls. Block the sixth repeat before execution and correct after fifteen consecutive no-output actions. Prefill counts UTF-8 bytes. JSON rescue parses registered tools only without eval; this is not a full GUI product or sandbox.
Illustrative example: Example: Reversed key order cannot evade duplicate detection. A CJK character can use multiple UTF-8 bytes, so character counts understate input.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does CERA-MoA assign samples to experts familiar with them?
CERA-MoA: Co-Evolving Router and Agents for Mixture-of-Agents
Show answer and example
Answer: Calling the same number and set of models on all questions can waste resources and hinder specialization. Familiarity guides selection and training allocation. It is a routing signal, not proof of a correct answer; verify outcomes and total compute.
Illustrative example: Example: Code and math experts may join different samples. Role names alone do not establish effective division of labor.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why use familiarity-based expert selection and assign training samples back to experts?
CERA-MoA: Co-Evolving Router and Agents for Mixture-of-Agents
Show answer and example
Answer: Routing choices and training assignments feed back: assignments shape future expertise. Middle-layer representations estimate familiarity, a cumulative threshold chooses how many experts to use, and targeted training reinforces specialization. Changing only routing while training everyone identically may not sustain distinct expertise.
Illustrative example: Example: Send code cases toward a code-familiar expert and language cases elsewhere. Ambiguous samples may activate more experts rather than use one fixed team.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does a cumulative threshold differ from fixed Top-2 expert selection?
CERA-MoA: Co-Evolving Router and Agents for Mixture-of-Agents
Show answer and example
Answer: Top-2 uses the same number per task. Cumulative selection adapts to score concentration: easy cases can use fewer experts and uncertain cases more. Variable counts change cost, so compare quality with total compute rather than infer efficiency from average routed count.
Illustrative example: Example: Use one clearly dominant expert or several with similar scores instead of always calling two.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
What does directed training assignment update beyond inference-only routing?
CERA-MoA: Co-Evolving Router and Agents for Mixture-of-Agents
Show answer and example
Answer: CERA-MoA also sends training samples to designated experts, letting routing and capability co-evolve. Selection masks alone train nothing. Local tests cover familiarity routing and a directed-update reference, not paper-scale expert training. Three-seed state statistics do not establish capability evolution.
Illustrative example: Example: A sample assignment to expert A does not show A received a gradient update. Verify parameter changes and independent task results.
Sections in the Chinese source: 核心公式, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
What map does RepoAtlas build first for an unfamiliar large repository?
RepoAtlas: Guiding Coding Agents via Evolving Multimodal Repository Views
Show answer and example
Answer: Reading files one at a time can lose global structure, while a broad overview cannot locate symbols. RepoAtlas combines topology and precise source entry points so agents can understand dependencies and inspect code. Navigation does not replace source evidence, and stale structure can misdirect later edits.
Illustrative example: Example: For login bugs, trace authentication and API dependencies before opening the validation function. Module names do not reveal the real conditions.
Sections in the Chinese source: 背景与主要改动, 核心公式与实现对应. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why refresh visual topology and the precise text index together?
RepoAtlas: Guiding Coding Agents via Evolving Multimodal Repository Views
Show answer and example
Answer: Topology shows module dependencies, and text locates actual editable symbols. If views disagree, a correct graph can point to an obsolete file. Select–project–refresh chooses task-related subgraphs under budget and keeps both views grounded in common sources. A diagram does not replace source evidence.
Illustrative example: Example: After moving a function, update its graph edges and indexed location; refreshing only one can leave nonexistent paths.
Sections in the Chinese source: 背景与主要改动, 核心公式与实现对应. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What is the trade-off between a task-related code subgraph and a whole-repository summary?
RepoAtlas: Guiding Coding Agents via Evolving Multimodal Repository Views
Show answer and example
Answer: A subgraph keeps relevant relations within budget but can miss remote dependencies. A whole summary covers more at lower detail. Refresh selection as implementation and feedback change. A one-time snapshot or visible graph is not improved code understanding.
Illustrative example: Example: Editing authentication needs callers and configuration. If initially omitted, failed tests can justify expanding the subgraph.
Sections in the Chinese source: 背景与主要改动, 核心公式与实现对应. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Does the local bounded text view implement a real multimodal SWE-bench repository environment?
RepoAtlas: Guiding Coding Agents via Evolving Multimodal Repository Views
Show answer and example
Answer: No. Public observations produce a budgeted text view and selection/refresh state. It does not claim real browser or SWE-bench integration. Indexes, edges, and budgets are checkable; visual topology generation, model consumption, and repair outcomes need separate execution evidence.
Illustrative example: Example: Ten nodes and source locations show view data exists, not that a model viewed a graph and fixed an issue.
Sections in the Chinese source: 核心公式与实现对应, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why identify parent dependencies before migrating callers?
Show answer and example
Answer: Parent classes, imports, and called interfaces shape assumptions in dependent code. Migrating resolvable parents first stabilizes context. HCRG extracts AST structure up to three hops. Static graphs cannot cover all dynamic calls, and unresolved symbols should not be matched to arbitrary same-name definitions.
Illustrative example: Example: Migrating a superclass constructor signature first makes it easier to update subclasses consistently.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why can't a cyclic dependency graph have a node-wise parents-first topological order?
Show answer and example
Answer: Nodes in a directed cycle depend on one another, so no linear order satisfies all edges. Identify strongly connected components and separate ordering across components from migration within them. AST context reveals this limit, but it does not invent a cycle-breaking method the paper never defines.
Illustrative example: Example: A calls B and B imports A. Analyze them as a cycle, not as though migrating A first satisfies all parent dependencies.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does three-hop structural context differ from vector retrieval over 800-character chunks?
Show answer and example
Answer: Vector chunks return textually similar fragments. Structural retrieval follows inheritance, calls, and imports, potentially finding related code with different words. Both miss things. Some paper metrics on a single repository decline, so structure does not uniformly improve migrations.
Illustrative example: Example: A utility's name has little lexical overlap with a migration issue, but a call edge still brings it into context.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
How should static graphs handle local-variable shadowing and unresolved symbols?
Show answer and example
Answer: Same names can denote different definitions, and local binding hides globals. Do not connect unresolved calls to arbitrary same-name repository nodes. Retain scope and unresolved status, then retrieve only known structure. Local support is bounded Python AST, not all dynamic calls or other paper languages.
Illustrative example: Example: If a function assigns a local object to a global tool's name, later calls use the local binding, not a global node with the same text.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why are fully unguided exploration and always giving answers both difficult for weaker long-horizon agents?
Environments as Scaffold: Enriching Feedback to Bootstrap Self-Evolving Agents in Long-Horizon Tasks
Show answer and example
Answer: Unguided exploration may yield too few successful experiences. Always providing correct actions can teach reliance on help. Feedback Scaffold changes support during training so early learning starts and later decisions are independent. Evaluate capability after removing the scaffold rather than count guided success as autonomy.
Illustrative example: Example: Demonstrate the next step at first, later give observations only. Continuing to choose actions during tests hides independent ability.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why start with action guidance and shift to observation enrichment later?
Environments as Scaffold: Enriching Feedback to Bootstrap Self-Evolving Agents in Long-Horizon Tasks
Show answer and example
Answer: Direct hints lower early exploration difficulty and yield learnable traces, but continued demonstration can make policy dependent. Later enriched observations retain evidence support while returning decisions to the agent, gradually reducing scaffolding. The phases serve different purposes and should not share constant strong hints.
Illustrative example: Example: Tell a beginner to find a key first. Later describe the lock and let the agent choose, rather than reveal the whole sequence.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why evaluate scaffolded completion separately from autonomous completion after removing support?
Environments as Scaffold: Enriching Feedback to Bootstrap Self-Evolving Agents in Long-Horizon Tasks
Show answer and example
Answer: Scaffolding can simplify decisions or add evidence, so success reflects both policy and support. Removal tests whether training left transferable decisions. Report visible help and do not pool different information conditions. A phase-scheduling diagnostic does not replace real transfer after training.
Illustrative example: Example: If testing still tells the model to read config first, it measures following the hint. Autonomous evaluation requires discovering that action.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Can the local first-step workflow be read from hidden AgentTask.plan?
Environments as Scaffold: Enriching Feedback to Bootstrap Self-Evolving Agents in Long-Horizon Tasks
Show answer and example
Answer: No. Use only a workflow explicitly supplied in public observation, then state summaries. Hidden plans never reach policy. No LLM training or real rollouts ran. The controlled path verifies isolation and schedules, not long-task learning from oracle-induced perfect scores.
Illustrative example: Example: A three-step reference plan in a fixture must not be disguised as an environment hint; that leaks the answer rather than enriches observation.
Sections in the Chinese source: 本地复现与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why might a successful trajectory still be a poor full SFT target?
SWE-Prime: Fewer Trajectories, Better Performance
Show answer and example
Answer: Success can include redundant exploration, risky commands, or steps the current model cannot learn. SWE-Prime filters trajectories by process, outcome, and representativeness, then selects segments by contribution, learnability, and risk. Outcome success does not endorse every token.
Illustrative example: Example: A bug fix ultimately passes after accidentally deleting and restoring a file. Do not teach deletion as a good action.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why retain complete context but apply SFT loss only to selected semantic segments?
SWE-Prime: Fewer Trajectories, Better Performance
Show answer and example
Answer: Unselected spans may be necessary causal context for later behavior even if redundant, dangerous, or unhelpful to imitate. Masking separates readable context from training targets. The model sees the real process while learning useful, learnable actions; not every token in a successful trajectory deserves supervision.
Illustrative example: Example: Keep a failed dangerous command to explain a repair, without rewarding the model for generating that command.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What different data-quality problems do whole-trajectory and within-trajectory segment selection solve?
SWE-Prime: Fewer Trajectories, Better Performance
Show answer and example
Answer: Trajectory selection chooses useful complete experiences by outcome, process, and representativeness. Segment selection chooses contributing, learnable, lower-risk behavior within them. Good traces can contain redundancy, and good fragments can come from failed overall runs. Sample selection and supervision are distinct.
Illustrative example: Example: Keep a passing repair's complete execution as context, but exclude irrelevant dependency installation from imitation targets.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Do local filtering results show a code LLM was trained or SWE-bench ran?
SWE-Prime: Fewer Trajectories, Better Performance
Show answer and example
Answer: No. Local filtering strategies share an observation and tool interface without training a code model or running official SWE-bench. Verify that loss masks cover only selected spans, context stays complete, and data splits remain isolated. Small tool-routing metrics are not code-repair gains.
Illustrative example: Example: More stable local routes after removing risky segments do not reproduce the paper's outcome with one tenth of its code traces.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does TraceML record the whole human ML development process rather than just the highest-scoring model?
TraceML: An Empirical Analysis of Human-Agent Planning in Machine Learning Development
Show answer and example
Answer: Final code and scores hide exploration, abandonment, revisiting, and budget allocation. TraceML records decisions and versions as planning evidence. Observed human behavior is not proof of optimality; downstream use requires independent tasks.
Illustrative example: Example: A small final model conceals the failed larger-model experiment that identified the bottleneck and motivated the pivot.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why do versions, action intent, and edit size teach planning patterns better than score curves alone?
TraceML: An Empirical Analysis of Human-Agent Planning in Machine Learning Development
Show answer and example
Answer: Scores show outcomes but cannot distinguish architecture exploration, tuning, or returning to an old approach. Linking edits to intent and effect reveals stage changes and reopened approaches for a prior. Patterns in human traces still need agent validation and are not optimal by default.
Illustrative example: Example: Two score drops can come from trying a feature or accidentally deleting configuration. Version and action records tell whether to continue or revert.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How do human stage alternation and revisiting old ideas differ from a monotonic plan?
TraceML: An Empirical Analysis of Human-Agent Planning in Machine Learning Development
Show answer and example
Answer: Humans move among analysis, implementation, and evaluation and revisit hypotheses after new evidence. A monotonic plan can discard abandoned paths permanently. A prior can encourage useful revisits, not enforce cycles on every task. Closer behavior does not guarantee better scores.
Illustrative example: Example: New validation identifies a data problem, making a previously abandoned simple model worth reconsidering instead of increasing complexity.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Can TraceML's failure-reflection prior keep reading hidden routes on validation or test?
TraceML: An Empirical Analysis of Human-Agent Planning in Machine Learning Development
Show answer and example
Answer: No. Learn the prior on train, then freeze it and act on actual tool feedback without hidden answers or routes. PlanBench stage and reopen counts are mechanism diagnostics, and ToolRoute is not the full Kaggle experiment. They are different evidence.
Illustrative example: Example: Adjust after a public test error, but do not reopen a solution by reading the reference plan.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does TOPAS consider the workflow's longest remaining path rather than only individual progress?
TOPAS: Workflow-Aware Prefix-State Scheduling for Multi-Agent LLM Serving
Show answer and example
Answer: One request can block downstream work, so local priority can increase tail waiting. Critical-path estimates include dependencies and remaining work, then trade them against prefix reuse, transfer, and preemption. Optimize completion time, not cache hits alone.
Illustrative example: Example: A short request unblocks five later nodes and may deserve priority over a long request that has already run extensively.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why not optimize shared-cache scheduling for prefix hit rate alone?
TOPAS: Workflow-Aware Prefix-State Scheduling for Multi-Agent LLM Serving
Show answer and example
Answer: Hits improve local reuse but can delay critical workflow paths and incur expensive transfers or preemption. TOPAS combines longest remaining path, downstream reuse, and movement cost, with aging against starvation. Hit rate is an intermediate measure, not whole-task completion time.
Illustrative example: Example: Serving many high-hit small requests can block a nearly finished main workflow. Sacrificing hits to unblock the critical path can deliver sooner.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What latency risks do critical-path priority and aging address?
TOPAS: Workflow-Aware Prefix-State Scheduling for Multi-Agent LLM Serving
Show answer and example
Answer: Critical-path priority identifies requests delaying whole workflows. Aging raises priority with wait time so tasks are not repeatedly starved. These address dependencies and fairness, alongside cache reuse and movement. No single priority makes every task fastest.
Illustrative example: Example: Aging eventually helps a short chain skipped for low cache reuse, while a long chain's blocked node still matters for critical-path latency.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Do simulated prefix hits and ToolRoute results prove real LLM serving speedup?
TOPAS: Workflow-Aware Prefix-State Scheduling for Multi-Agent LLM Serving
Show answer and example
Answer: No. The mini-suite simulates prefix reuse, critical path, and aging. Stateful tools do not exercise real KV serving kernels. Paper mean/p99 JCT comes from real system experiments requiring requests, memory, movement, and wall-clock timing. Proxy costs and hit counts are not convertible directly.
Illustrative example: Example: Three extra hits do not save three identical prefill intervals. Prefix lengths and scheduling overhead matter.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does ProgRouter track changing model needs during one task?
Show answer and example
Answer: Reasoning requirements vary by stage. Always using a strong model is costly; a weak model can stall. ProgRouter routes each next call by current progress. Static rankings do not quantify help now, and real gains depend on time and call budgets.
Illustrative example: Example: A cheap model locates a file, then a stronger model handles complex inference. Overall rank alone does not justify using it for both.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why predict marginal progress for routing instead of comparing average model accuracy?
Show answer and example
Answer: A stronger model may offer little progress in one state but unblock another. Marginal progress uses completion, trend, and quality to value the next call against time and long-run budget. Average accuracy misses stage differences, and predictions still require execution feedback.
Illustrative example: Example: A cheap model can repair formatting while a difficult proof needs stronger reasoning. Calling the average best on every step wastes budget.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does a quality, time, and long-run-cost meta-gate compare with always choosing the cheapest model?
Show answer and example
Answer: Cheap calls can accumulate retries and cost more overall. A meta-gate trades predicted progress, call price, and budget pressure, sometimes paying more for a better candidate. Report delivery quality, time, and total budget instead of just per-call cost.
Illustrative example: Example: Three cheap calls stall while one expensive call solves it. If the expensive call also stalls, execution must override the prediction.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Does the local frozen program router have the same scope as the paper's multi-model progress predictor?
Show answer and example
Answer: No. Local work compiles verified tool choices into routes, freezes them for validation and test, and executes. Mini-suite checks cover progress, meta-gating, and downgrade, not paper models, serving resources, or full benchmarks. Proxy costs and program selection are not measured joules or citation precision.
Illustrative example: Example: Reading two fewer candidates does not imply the same energy saving on HumanEval without actual model and hardware measurements.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why judge tool necessity relative to the target model's capabilities?
AdaVDR: Adaptive Tool Use and Reflection for Video Deep Research
Show answer and example
Answer: Do not repeat external calls for things the model already handles; use tools for missing information. Necessity depends on model and evidence, not an unconditional prohibition. Reflect when intermediate evidence is unreliable rather than minimize calls at the cost of needed checks.
Illustrative example: Example: Clear colors can be read directly, but small text may need zoom or retrieval. A weaker vision model changes that boundary.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why separate tool necessity from fallback reflection on unreliable evidence?
AdaVDR: Adaptive Tool Use and Reflection for Video Deep Research
Show answer and example
Answer: Necessity decides whether to gather external evidence; reflection decides whether existing evidence needs another check. Capability-based filtering saves unnecessary calls and redundancy penalties guide training. Ignoring unreliable evidence merely to call less can hurt video research, so minimum call count is not optimal by itself.
Illustrative example: Example: Do not search to confirm visible running. If identity clues disagree, recheck rather than keep the first conclusion.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does a redundancy-aware reward differ from penalizing every call?
AdaVDR: Adaptive Tool Use and Reflection for Video Deep Research
Show answer and example
Answer: Redundancy penalties target unnecessary or repeated calls while preserving useful evidence gathering. A flat penalty can deter necessary tools. Evaluate answer reward and reflection as well, since recovery and verification may require justified extra cost.
Illustrative example: Example: Repeating a search with no new information can be redundant, while checking conflicting sources may be essential.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
How should local ToolRoute success be reported alongside cost and video scope?
AdaVDR: Adaptive Tool Use and Reflection for Video Deep Research
Show answer and example
Answer: Retain added verifier cost and state that local runs use an oracle-free stateful tool environment, not the paper's video data or full VDR system. Perfect PlanBench is a mechanism diagnostic. Fallback counts or success under another protocol are not video research gains.
Illustrative example: Example: Report that an extra verification step bought local success rather than claim higher success and fewer video calls from the same result.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does SMITH learn to create reusable tools rather than only use existing ones?
SMITH: Self-Improving Tool-Using Agents through Multi-Aspect Verification
Show answer and example
Answer: Fixed tools may not cover new tasks, and rewriting one-off code wastes effort. Building and later using tools links interface and implementation to real use. Code generation does not establish usefulness; format, execution, and downstream answers can fail independently.
Illustrative example: Example: Repeated cleaning needs can justify a dedicated tool. Keep it only if later tasks can call it correctly and finish cleaning.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why jointly train tool creation and use in one policy?
SMITH: Self-Improving Tool-Using Agents through Multi-Aspect Verification
Show answer and example
Answer: Rewarding runnable code alone can produce awkward tools or tools that fail new tasks. Training only use cannot improve design. Mixed build and held-out use connect schema, execution, and outcome signals to encourage reusable abstractions. Passing examples is not independent problem solving.
Illustrative example: Example: A tool hard-codes a training constant and earns execution reward, but held-out calls expose the lack of reuse.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why aren't schema, code execution, and final answer rewards interchangeable?
SMITH: Self-Improving Tool-Using Agents through Multi-Aspect Verification
Show answer and example
Answer: A schema only needs to parse. Code execution only needs to run without crashing. The final result tests whether the task was solved. Separate signals expose different faults. Harder problems should encourage abstraction, not more hard-coded examples passed off as generalization.
Illustrative example: Example: A function has a valid signature and returns a number using the wrong formula. It passes the first two checks but fails the answer check.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Is the local structured-plan tool equivalent to a Python execution sandbox?
SMITH: Self-Improving Tool-Using Agents through Multi-Aspect Verification
Show answer and example
Answer: No. Local work separates build and use and runs three verifiers, but uses controlled plans without Qwen3-4B, a Python sandbox, or Reasoning-Gym. Generation and reuse counts verify control flow, not paper code-tool training effects.
Illustrative example: Example: A rule interpreter can execute an add node without safely compiling or running arbitrary model-generated Python.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
What reusable experience does PMCoder retain across locating, fixing, and testing an issue?
Coupling Planning with Episodic Memory in LLM Agents for Software Issue Resolution
Show answer and example
Answer: A long fix yields clues, failed attempts, and test conclusions. Restarting from the issue repeats searches and mistakes. Phase-organized plans and reads give each step the right history. Memory supports execution but current code and tests still decide if the new issue is fixed.
Illustrative example: Example: Remember the parser location and failing boundary input rather than search the whole repo again.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why condition episodic retrieval on the current phase instead of querying the original issue every step?
Coupling Planning with Episodic Memory in LLM Agents for Software Issue Resolution
Show answer and example
Answer: Localization, editing, and verification need different evidence. Static retrieval can repeat topically related but phase-inappropriate traces. Hierarchical planning constrains retrieval by phase, detects stalls from behavior, and replans. Real execution verdicts decide whether repair succeeded, not phase changes.
Illustrative example: Example: Localization needs files and verification needs regression tests. Repeatedly searching issue text can keep returning localization experiences.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What is the trade-off between trace-based stall detection and rewriting the whole plan after any failure?
Coupling Planning with Episodic Memory in LLM Agents for Software Issue Resolution
Show answer and example
Answer: Trace statistics recognize repeated nonprogress and allow targeted replanning. One failure can be useful evidence rather than a bad direction. Full rewrites repeat work, while never changing can stall indefinitely. Use actual verdicts rather than self-reported recovery.
Illustrative example: Example: The same test error after two identical patches suggests another approach. A new first-time error can be normal progress.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Can perfect local phase/retrieval scores be compared with solving 25 more SWE-bench issues?
Coupling Planning with Episodic Memory in LLM Agents for Software Issue Resolution
Show answer and example
Answer: No. Deterministic PlanBench tests phase-conditioned retrieval, stalls, and replanning without repository containers or paper models. Proxy cost is not tool tokens. Report traces and branch evidence rather than call saturation issue-resolution capability.
Illustrative example: Example: Selecting a phase template and completing a three-step fixture does not establish locating, editing, and testing an unknown repository.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does CodeGrep treat evidence gathering in large repositories as a learned multi-step task?
CodeGrep: An RL-Trained Retrieval Agent for LLM Coding Agents
Show answer and example
Answer: Before repair, relevant files, symbols, and dependencies may be unknown. One search can retrieve only similar wording. CodeGrep searches, reads, and updates queries from new clues, serving downstream repair. Actual execution determines whether the evidence helped.
Illustrative example: Example: grep finds a config entry, but reading it reveals the default is elsewhere. Follow that dependency instead of guessing a local patch.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why reward code retrieval by downstream repair value rather than correct-file hits alone?
CodeGrep: An RL-Trained Retrieval Agent for LLM Coding Agents
Show answer and example
Answer: The right file may lack call chains or constraints, and retrieval may be too expensive. Pass evidence to a frozen coding agent and measure actual repair with costs. Freezing the executor reduces co-changing confounds, though one failed repair does not prove a given clue useless.
Illustrative example: Example: Finding an erroring function without its caller constraints can still lead to a bad patch. Related files and test context may enable real repair.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does multi-turn grep, glob, and read differ from one vector Top-K?
CodeGrep: An RL-Trained Retrieval Agent for LLM Coding Agents
Show answer and example
Answer: grep and glob narrow symbols and paths; reading results informs later queries. This interactive evidence collection differs from fixing candidates by initial embedding similarity. Adaptation costs calls and context, so compare exploration resources as well as file hits.
Illustrative example: Example: Glob test directories, grep the error symbol, read a caller, then search dependencies based on actual code.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
What evidence separates local retrieval operators from actual 14B GRPO training?
CodeGrep: An RL-Trained Retrieval Agent for LLM Coding Agents
Show answer and example
Answer: Local public mini-suites check bounded selection and state without training a 14B retriever, running SWE-bench, or using the full downstream fixer. Token and turn penalties need real measurements. Registration or simulated search is not executed RL or end-to-end speedup.
Illustrative example: Example: Two fewer fixture reads are a proxy reduction, not a 1.2-point improvement in actual repairs without real files and generation.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
How can poor communication waste opportunities in a multi-agent team?
MANTA: Multi-Agent Network Topology Adaptation for Self-Evolving Multi-Agent Systems
Show answer and example
Answer: More roles do not help if results reach the wrong people, dependencies miss key messages, or ordering is wrong. MANTA adapts communication from execution rather than fixing a roster. Topology changes still cost coordination; evaluate visibility, results, and resources.
Illustrative example: Example: A verifier spots a constraint error but tells an unrelated role. The executor continues on a stale plan; adjust information flow rather than add another agent.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why adjust topology edges, ordering, and visibility rather than merely add agents?
MANTA: Multi-Agent Network Topology Adaptation for Self-Evolving Multi-Agent Systems
Show answer and example
Answer: Failure can come from missing information, duplicate roles, or absent verification. More agents do not fix these. Trajectories guide bounded changes to relationships and information flow. Budget projection limits communication and execution, and only task feedback confirms gains.
Illustrative example: Example: If reviewers never see current code, fix message visibility rather than add three reviewers of the same stale material.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What is the trade-off between online topology adaptation and picking a team once at the start?
MANTA: Multi-Agent Network Topology Adaptation for Self-Evolving Multi-Agent Systems
Show answer and example
Answer: An initial team uses task priors. Online changes respond to observed bottlenecks, failures, and duplication but can add instability and cost. Project changes onto budgets and permission boundaries rather than add unlimited agents or expose private histories.
Illustrative example: Example: Merge duplicate source-checking roles or alter edges, but never let evaluator references reach executors as part of the change.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
What does Π_budget do in topology updates, and what does local evidence establish?
MANTA: Multi-Agent Network Topology Adaptation for Self-Evolving Multi-Agent Systems
Show answer and example
Answer: Project proposed roles, edges, and order changes into allowed resources before execution rather than running an oversized team and accounting for only part of it. The deterministic suite checks state and scheduling without real multi-agent models or environments. Topology change counts are not five-benchmark generalization.
Illustrative example: Example: If a proposal asks for ten roles but only four fit, construct an executable bounded graph before running, not after omitting six costs.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why decide how many tools to expose after ranking them?
Show answer and example
Answer: Rank order does not identify a sufficient set. Too many tools add cost and distraction, while too few miss interfaces. CAM-DF compares virtual prefixes and heterogeneous costs before execution. It controls exposure, not dynamic stopping after actual calls.
Illustrative example: Example: If the first two tools only query and the third modifies, a modification task may need the third regardless of the earlier scores.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why derive stop labels from the payoff gap between the current prefix and best later prefix?
Show answer and example
Answer: Relevance ranking does not say how many exposed tools are sufficient. Early stop can miss capability and late stop costs resources. Virtual payoff subtracts cost from sufficiency; the difference sets stop or continue and its magnitude gives regret. This happens before execution, so virtual payoff is not tool success.
Illustrative example: Example: Two tools already suffice, while a related but expensive third reduces payoff. Stop labels should reflect that cost rather than rank alone.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How is regret weighting different from ordinary stop/continue labels?
Show answer and example
Answer: Error costs can differ. Gap sign supplies the class and magnitude represents lost payoff. Equal weights treat near ties like missed essential tools. A best later prefix is a comparison estimate that depends on sufficiency scoring, not hidden deployment truth.
Illustrative example: Example: Exposing one cheap extra tool has little cost. Stopping before an essential refund interface is a large error that deserves greater weight.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Can local required-tools sufficiency be a general deployment scorer?
Show answer and example
Answer: No. Required-tools lists in the auditable mini-suite diagnose prefix choices rather than act as a learned semantic scorer. Do not reveal hidden requirements to an evaluated policy. Lower exposure is not live τ-bench token or success improvement.
Illustrative example: Example: Knowing the third tool is required is useful for offline payoff, but a runtime router reading that list bypasses the learned sufficiency problem.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why isn't formalizing a whole textbook independent translation of each statement into Lean?
Formalizing Mathematics at Scale
Show answer and example
Answer: Later theorems use earlier definitions and lemmas, and work must preserve shared repository state, compilation, and source meaning. AutoFormBot coordinates workers through these dependencies and merges local results into global goals. Compilation only establishes acceptance by the formal system, not faithfulness.
Illustrative example: Example: A changed foundation can break other proofs even if their branches compiled earlier. Recheck after merging.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why do formalization workers need separate worktrees and a merge queue before checking the global goal?
Formalizing Mathematics at Scale
Show answer and example
Answer: Isolation reduces concurrent file conflicts, the dependency DAG identifies available declarations, and merge review preserves shared consistency. Local Lean success does not cover the entire textbook. The supervisor checks overall progress and replans. Failed experience can become skills, but a branch is not a merged proof.
Illustrative example: Example: Two workers prove separate lemmas. Check name collisions and main theorem dependencies after integration before claiming full formalization.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why isn't mechanical compilation a substitute for independent fidelity review?
Formalizing Mathematics at Scale
Show answer and example
Answer: The Lean kernel checks proofs of formal statements. Added axioms, sorry, weakened claims, or hidden dependencies can bypass the intended problem. Compilation is necessary but not sufficient; verify the original statement, dependencies, and independent review. Completed scheduling is not mathematical fidelity.
Illustrative example: Example: Replacing all natural numbers with zero can make a theorem easy to prove while failing to formalize the original.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Did the local run execute textbook-scale Lean agents or only record the protocol?
Formalizing Mathematics at Scale
Show answer and example
Answer: It records the paper's methods, dependencies, and costs without Lean jobs, paid calls, training, or GPU runs. A DAG state machine cannot reproduce days and huge token budgets per book. Over forty thousand declarations are author results, and not every book finished.
Illustrative example: Example: Scheduling forty goals does not mean forty Lean proofs compiled and passed fidelity review.
Sections in the Chinese source: 本地复现与成本决策. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does PROMPTS treat model-parallel partitioning as iterative measured optimization?
PROMPTS: Performance Optimization via Multi-Agent Planning for LLM Training and Serving
Show answer and example
Answer: Training bottlenecks vary by hardware and configuration among compute, memory, and communication. Agents use profiler evidence to propose partitioning and observe effects rather than apply stock settings. A recommendation is not a speedup until measured for runtime, resources, and feasibility on target hardware.
Illustrative example: Example: More sharding may save memory but slow cross-device communication. Profiling distinguishes the bottleneck.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why ground sharding proposals in profiling rather than retrieving a common best configuration?
PROMPTS: Performance Optimization via Multi-Agent Planning for LLM Training and Serving
Show answer and example
Answer: Optimal parallelism depends on measured compute, communication, and memory constraints. The knowledge base offers options; Analyzer locates bottlenecks, Proposal generates explainable candidates, and Coordinator organizes verification. A config or formula check does not run training or measure speedup.
Illustrative example: Example: A configuration is fast on a model card, but local profiling shows all-reduce dominates. Compare options that address communication.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does separating Coordinator, Analyzer, and Proposal differ from configuration-table search?
PROMPTS: Performance Optimization via Multi-Agent Planning for LLM Training and Serving
Show answer and example
Answer: Separate roles coordinate work, explain bottlenecks, and propose targeted settings from evidence. Table search mainly enumerates predefined options. Multiple agents have their own cost; real training or serving results determine benefit, not explanation length or votes.
Illustrative example: Example: Analyzer identifies communication as dominant, then Proposal changes sharding accordingly instead of testing every dimension randomly.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Do local profiler ranking and bounded proposals include TPU/GSPMD measurements?
PROMPTS: Performance Optimization via Multi-Agent Planning for LLM Training and Serving
Show answer and example
Answer: No. Local reference tests cover evidence ranking and proposal constraints without Google TPU profiling, GSPMD, or a production workload matrix. Top-three hits and peak gains are author measurements, not consequences of local candidate ordering.
Illustrative example: Example: Synthetic profiling can recommend less communication. Until compiling and running that configuration, there is no observed training speed.
Sections in the Chinese source: 核心公式或操作, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does PaperOrchestra organize actual experiment material into an argument instead of just writing fluent prose?
PaperOrchestra: A Multi-Agent Framework for Automated AI Research Paper Writing
Show answer and example
Answer: Scientific writing connects question, method, evidence, and citations. Fluent text can conceal missing tests or unsupported conclusions. PaperOrchestra coordinates roles to write, verify, and revise from ideas and logs. Automation cannot supply absent validation, and a citation may not support the claim.
Illustrative example: Example: With logs for two datasets, explain those two. Stronger wording cannot create a third experiment or generalization result.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why can't citation checks and revision acceptance replace real experiments and research arguments?
PaperOrchestra: A Multi-Agent Framework for Automated AI Research Paper Writing
Show answer and example
Answer: Citation identity, abstracts, and cutoff checks verify sources and time eligibility. Revision scores constrain edits to existing content. Five writing roles organize actual ideas and logs; they do not create results. Mechanical BibTeX checks and judges are not full literature synthesis or research capability.
Illustrative example: Example: A chart agent can plot real logs, but cannot invent metrics to complete a manuscript. Authentic citations do not make fabricated results true.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why aren't automated judging and human preferences equivalent evidence of writing quality?
PaperOrchestra: A Multi-Agent Framework for Automated AI Research Paper Writing
Show answer and example
Answer: Automated judges can favor form and fluency, while people assess literature reviews differently. The paper reports weak correlation. Higher revision score still needs factual and dimension-specific checks. One judge improvement does not verify real paper quality or scientific correctness.
Illustrative example: Example: More topical vocabulary may boost automatic scores while misaligned citations and overstated results make experts rate a review worse.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
What conditions govern citation verification and revision rollback, and what was completed locally?
PaperOrchestra: A Multi-Agent Framework for Automated AI Research Paper Writing
Show answer and example
Answer: Citations must match real entities, include abstracts, predate the cutoff strictly, and deduplicate by paper ID. Revert revisions when scores fall or ties regress across subdimensions, at most three rounds. Local work reviews literature and costs without five agents, writing models, or metrics. A BibTeX checker is not literature synthesis.
Illustrative example: Example: Deduplicate two URLs for one paper and exclude post-cutoff research. Valid formatting does not mean the citation supports a sentence.
Sections in the Chinese source: 核心公式, 本地复现. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why is automated ML research also an experiment scheduling problem in AIR-A2?
AIRA2: Overcoming Bottlenecks in AI Research Agents
Show answer and example
Answer: Agents can propose many candidates, but experiments vary in runtime and devices and evaluation are finite. Proposal quality and execution throughput both affect progress. AIR-A2 keeps experiments flowing and manages feedback. Busy workers do not establish research gains; verify selected proposals on isolated evaluation.
Illustrative example: Example: Waiting for a two-hour experiment can leave devices idle after a ten-minute one finishes.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why does a steady-state worker pool use compute better than waiting for every experiment in a generation?
AIRA2: Overcoming Bottlenecks in AI Research Agents
Show answer and example
Answer: Experiment lengths differ, so a barrier makes quick workers wait for the slowest. A steady pool assigns the next candidate immediately. Throughput must not alter evaluation isolation: search uses fixed search scores, then untouched validation picks a winner afterward. Do not peek mid-search.
Illustrative example: Example: Three experiments finish in ten minutes and one takes an hour. Reuse idle slots while keeping the predefined data splits.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why separate the search split and final validation?
AIRA2: Overcoming Bottlenecks in AI Research Agents
Show answer and example
Answer: Search repeatedly uses scores and can overfit by hill climbing. Untouched validation chooses a winner only after search, reducing selection overfitting. Neither is training data, and repeatedly tuning search on validation undermines it. Hidden test stays out of the interface.
Illustrative example: Example: Explore 100 candidates by search ranking, then use the held-out validation once to choose the final model rather than inspect it after every proposal.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Can 80/10/10 be randomly resplit for every candidate?
AIRA2: Overcoming Bottlenecks in AI Research Agents
Show answer and example
Answer: No. One split must be shared so data difficulty does not confound score comparisons. Local tests verify asynchronous scheduling and signal isolation, not multi-H200, Apptainer, or long-running research agents. Rank-based selection probabilities are search rules, not actual performance.
Illustrative example: Example: Identical models can rank differently if one gets easier search samples. A fixed split controls that difference.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why is an executable bug-reproduction test valuable before automated repair?
Dynamic Cogeneration of Bug Reproduction Test in Agentic Program Repair
Show answer and example
Answer: Text issues can be ambiguous. A test makes failure observable and checks whether a patch changes the intended behavior. Dynamic BRT generates and selects tests during repair search. They are local evidence and may lack coverage or overfit a bad patch; they cannot replace full correctness checks.
Illustrative example: Example: Reproduce an empty-list crash with a fixed input. After that test passes, independently check other inputs.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why doesn't failing on the original bug and passing on a generated patch prove the patch correct?
Dynamic Cogeneration of Bug Reproduction Test in Agentic Program Repair
Show answer and example
Answer: A self-generated test can cover only a local behavior the patch happens to satisfy. Agreement does not establish full semantics. This defines a candidate BRT; stronger evidence needs isolated reference repairs and other verification. Grouping votes by non-test patch keeps different tests from splitting the same fix.
Illustrative example: Example: A patch returns a constant and its test checks only one matching input. Both conditions pass, but other inputs remain wrong.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why group candidates by non-test patch instead of counting each generated test separately?
Dynamic Cogeneration of Bug Reproduction Test in Agentic Program Repair
Show answer and example
Answer: One fix can pair with several tests. Pairwise votes can split or inflate support for the same code. Group by non-test changes, then choose a test within the majority fix group. Identifier normalization is a heuristic, not a proof of semantic equivalence.
Illustrative example: Example: Ten traces with the same code and different assertions are one repair group, not ten independent fixes.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Can any execution exception count as a successful bug reproduction?
Dynamic Cogeneration of Bug Reproduction Test in Agentic Program Repair
Show answer and example
Answer: No. A nonempty assertion must raise assertion_failed on the original, then pass on the fix with acceptable regression results. Syntax errors and unrelated exceptions do not qualify. Execution uses a bounded AST allowlist and timed isolated process, not an arbitrary hostile-code sandbox. Real LLM reviewers and private Google bugs are not run.
Illustrative example: Example: An import error does not reproduce a business-logic bug just because the patched run imports normally.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射与边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why use online tutorial videos rather than rely only on expensive action annotations?
Watch and Learn: Learning to Use Computers from Online Videos
Show answer and example
Answer: Tutorials contain genuine software behavior without machine-readable click coordinates, keys, and actions. Converting visible demonstrations broadens training sources. Frames are not action ground truth: occlusion, edits, and missing typed text can harm conversion and execution.
Illustrative example: Example: A file moves across windows, but training data needs to distinguish dragging from a copy command rather than invent a click.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why learn inverse dynamics from tutorials instead of treating before/after pixel differences as mouse actions?
Watch and Learn: Learning to Use Computers from Online Videos
Show answer and example
Answer: Screen changes may come from scrolling, keystrokes, or program responses, so pixels do not identify actions uniquely. The inverse model predicts action type, coordinates, and text from screen pairs, then assembles trajectories. These are estimated labels, not rule guesses or proof an IDM was trained locally.
Illustrative example: Example: A screen can move down from a wheel or a key. Use visual context and supervision instead of labeling every downward shift as a click.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What changes when retrieving video examples versus training on annotated trajectories?
Watch and Learn: Learning to Use Computers from Online Videos
Show answer and example
Answer: Retrieval puts a relevant demonstration in context without updating the executor. SFT writes trajectory patterns into weights. Both rely on IDM label quality, so video count is not correct action count. Similar titles do not establish actual desktop learning.
Illustrative example: Example: Use one tutorial as a prompt example or offline training input. Inference cost and how errors propagate differ.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Why can't one simple rule head replace action, coordinate, and text prediction?
Watch and Learn: Learning to Use Computers from Online Videos
Show answer and example
Answer: The paper uses action classification, coordinates discretized into 0–1000 classes, and a GPT-2 small autoregressive text head with SigLIP-2 and a four-layer Transformer. Do not invent loss weights. Local work is literature and cost review, not IDM training, corpus download, or desktop evaluation.
Illustrative example: Example: A cursor-difference click rule cannot recover typed text from two frames or replace joint IDM training.
Sections in the Chinese source: 核心公式, 本地复现. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does ToolGrad target the cost of high-quality tool trajectories?
ToolGrad: Efficient Tool-Use Dataset Generation with Textual Gradients
Show answer and example
Answer: Multi-step calls need correct interfaces, arguments, and linked results. Human demos cost time and direct model generation can accumulate errors. ToolGrad uses target feedback during dataset construction to repair executable traces. Construction targets must not leak to evaluated agents.
Illustrative example: Example: During data creation, verify queries reach a known result and fix parameters. At test, gather evidence without reading the answer first.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why use answer-conditioned trajectory construction only in data generation, not as evaluated agent input?
ToolGrad: Efficient Tool-Use Dataset Generation with Textual Gradients
Show answer and example
Answer: Known answers support backward construction of tool chains and textual-gradient repair to reduce training annotation. Revealing the target value in evaluation leaks the solution and prevents measuring independent evidence gathering. Training construction information must remain separate from deployed inputs.
Illustrative example: Example: Use known population to construct API traces for training. At test, give the population question without the reference number.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does textual gradient differ from a numerical gradient when repairing failed calls?
ToolGrad: Efficient Tool-Use Dataset Generation with Textual Gradients
Show answer and example
Answer: Textual feedback identifies bad arguments, tools, or order and suggests edits; it is not differentiable backpropagation through discrete calls. It depends on feedback quality and execution verification. The name does not imply end-to-end parameter updates, and an edit is not a rerun.
Illustrative example: Example: Changing a date format from feedback is text editing. Reinvoke the tool and check its response to verify repair.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Do local answer-first and deduplicated edits cover ToolGrad-12B and BFCL?
ToolGrad: Efficient Tool-Use Dataset Generation with Textual Gradients
Show answer and example
Answer: No. Local references execute backward route construction and deduplicated text repair, without training 12B or running BFCL. Answers stay training-only, execution outcomes must be real, and failures are not backfilled. State transitions do not establish generated-data quality or downstream skill.
Illustrative example: Example: Deduplicating two corrections of the same bad argument verifies the edit rule, not automatic correct traces for unknown APIs.
Sections in the Chinese source: 核心公式或操作, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why doesn't checking only ToolRL's final answer establish a good tool policy?
Show answer and example
Answer: The result conflates choosing tools, generating arguments, executing, and using outputs. Granular feedback constrains each behavior. Calibrate rewards without letting format or execution hide wrong answers. Local reward computation is not large-model RL.
Illustrative example: Example: A weather tool can be correct but use the wrong city. A single answer score cannot identify argument versus selection failure.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why dynamically scale rewards by tool when their reward difficulties differ?
Show answer and example
Answer: High raw rewards from easy tools can dominate updates, burying improvements on harder tools. Center and scale by tool distribution to compare relative performance while retaining selection, argument, execution, and answer signals. Normalization does not fix wrong rewards or equalize actual difficulty.
Illustrative example: Example: Calculator successes are common and database queries often fail. Normalize separately so easy calculator rewards do not monopolize learning.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why are tool-selection, execution, and answer rewards not substitutes?
Show answer and example
Answer: Selection checks task fit, execution checks whether a call runs, and answer reward checks final goal. Correct tools can fail from bad arguments, and successful calls can return irrelevant data. Separate signals expose different errors; any one high score does not establish end-to-end ability.
Illustrative example: Example: A database query runs with the wrong month. Selection and execution pass without deserving answer reward.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Do local reward and state updates prove full multi-tool RL training?
Show answer and example
Answer: No. Local tests cover paper objectives, transitions, and budgets without the original large model, multi-GPU RL, or full real-tool benchmark. Correct reward arithmetic still needs policy sampling, real external execution, and parameter updates. Registration and perfect mini-suites cannot fill those gaps.
Illustrative example: Example: Computing advantage from four reward dimensions tests an objective, not learned argument generation.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does ReTool learn calling, correction, and stopping together?
Show answer and example
Answer: Tools can help but fail and cost resources. A policy must decide when to call, how to respond to errors, and when evidence suffices. Tool syntax alone does not control a full trajectory. Early stopping and repeated unnecessary calls can both hurt.
Illustrative example: Example: Run code to check a calculation, fix arguments after an error, then stop once results agree rather than loop or submit unchecked.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why not learn to avoid tools entirely when calls carry penalties?
Show answer and example
Answer: The objective also rewards correct answers. Fewer calls matter only if quality does not suffer. Alternating reasoning and actual feedback teaches when to outsource, recover, and stop. Optimizing call count alone may replace needed computation with fluent guesses.
Illustrative example: Example: Mental arithmetic can avoid calls, but complex statistics need code. One reliable result can be worth more than saving a call and answering incorrectly.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does outcome reward minus call cost compare with one fixed call per task?
Show answer and example
Answer: Fixed counts ignore difficulty and evidence, wasting calls on simple tasks and starving complex ones. Costed rewards adapt counts to value but can suppress needed tools if penalties are excessive. Report correctness and total call costs, not reductions alone.
Illustrative example: Example: Mental arithmetic can use zero calls, while multi-stage calculation may need two checks. One call does not fit both.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Can the model fill in a tool observation to complete a reasoning/action trajectory?
Show answer and example
Answer: No. Actual tool or environment execution must supply feedback. The model generates its reasoning and actions only. Fabricated outputs remove learning evidence for calls and corrections. Local controlled state/budget tests do not train the paper model or run real math benchmarks.
Illustrative example: Example: Writing 'Python output: 42' without running code is neither tool success nor grounds for execution reward.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why is OpenHands a software-agent work platform for editing, execution, and browsing?
Show answer and example
Answer: Real software tasks require inspecting files, commands, pages, and continuing long workflows, not only generating code. OpenHands connects operations to feedback in a consistent environment. Platform support and a controller's ability are separate evidence; tools alone do not make policies reliable.
Illustrative example: Example: After editing a frontend, start the service, inspect the page, and return to code when it fails. Code generation alone misses that loop.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why does a unified event stream make editor, terminal, and browser workflows auditable?
Show answer and example
Answer: Actions and sandbox returns enter one timeline. Policies continue from observed results and reviewers can trace changes and validation. Shared events do not erase tool-specific semantics or establish code safety and correctness. Isolation, permissions, and tests have distinct roles.
Illustrative example: Example: Editor events change a file, terminal events run tests, and browser events check a page. The stream shows whether tests preceded or followed edits.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why are platform runtime and agent controller distinct contributions?
Show answer and example
Answer: The runtime supplies actions, observations, and isolation. A controller chooses plans and tool usage; different policies can share one platform. Running editor and terminal verifies execution paths, not full model reasoning or official SWE-bench resolution.
Illustrative example: Example: A script and LLM may use the same sandbox without equal issue understanding or repair ability.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Does a local browser interface mean real web interaction is connected?
Show answer and example
Answer: No. Local work emits editor events and runs fixed regressions in an isolated temp directory. Browser action semantics are retained without a live environment or full controller. Claim only observed events and outcomes, not real navigation from a type definition.
Illustrative example: Example: Recording browser_open does not open a page, fetch its DOM, or click an element. Those require real browser evidence.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does a GitHub issue agent need a convenient repository viewing and editing interface?
Show answer and example
Answer: The model must locate unknown code, read needed context, make small edits, and verify. Raw terminal output can be long or fragile. SWE-agent's interface better fits that workflow without replacing issue understanding or tests. A successful command does not mean resolution.
Illustrative example: Example: Open matching files and relevant lines rather than printing the repository, then run the target tests after edits.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why can a specialized ACI work better than an unrestricted shell?
Show answer and example
Answer: Broad actions and verbose output increase selection and localization load. An ACI makes search, viewing, precise edits, and tests easier to act on and interpret. This improves the repository interaction contract, not hidden patch access. Real tests still verify completion.
Illustrative example: Example: Showing nearby lines and an exact replacement makes editing easier than printing a whole file, but regression tests must validate the patch.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why compare ACI with raw shell using the same model and tasks?
Show answer and example
Answer: Otherwise stronger models or easier tasks confound interface effects. ACI changes action and observation boundaries, so control other conditions and assess actual patches and tests. One good edit or valid command syntax cannot establish broad repair ability.
Illustrative example: Example: Give the same model the same bug with a narrow editor versus a raw shell to isolate differences in localization and editing.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
What do the initial failure and fixed unittest prove in local swebench-local?
Show answer and example
Answer: A real initial failure shows a problem exists. The exit code after editing verifies the covered regression. Local tools only read files, write solution.py, and run fixed tests. This is executable micro-benchmark evidence, not official SWE-bench Lite or broader coverage.
Illustrative example: Example: Fixing arithmetic until one suite passes verifies the edit-and-run path, not official GitHub issue resolved rate.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does AutoGen organize multi-agent applications as programmable conversations?
Show answer and example
Answer: Models, execution tools, and people may need repeated feedback beyond one question and answer. Configurable roles and messages let tool results or replies trigger later steps. Role names are not collaboration ability; specify responders, handoff, stop conditions, and actual artifact checks.
Illustrative example: Example: An assistant proposes code, an executor returns an error, and the assistant revises under a protocol rather than endless chat.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why does conversation programming need explicit termination instead of endless role replies?
Show answer and example
Answer: Messages can keep triggering responses. Without responsibilities, tool boundaries, and stopping rules, collaboration can repeat or loop. Conversation programming composes these controls for group and nested chats. More roles do not guarantee effective division; completion still needs verified artifacts.
Illustrative example: Example: A writer and reviewer repeatedly suggest improvements. Define a stop after verification passes or budget ends.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does message-driven orchestration differ from a fixed linear script?
Show answer and example
Answer: A linear script predefines one order. Message policies choose recipients, nested conversations, and stopping based on state or content. Flexibility helps tools and humans collaborate but can add useless chatter and loops. More messages or roles do not prove gains; count their costs.
Illustrative example: Example: A failed review can trigger one nested repair, while a pass ends immediately instead of always running five turns.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Does the local planner/executor/critic protocol run the full AutoGen runtime?
Show answer and example
Answer: No. It implements deterministic handoff, message logs, and stopping without full runtime, real LLM group chat, or container execution. Round counts verify the protocol; perfect scores are not the paper's multi-application ability or development efficiency.
Illustrative example: Example: One rule-based message per role can pass a protocol without solving an open software task.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does MetaGPT organize agents around software roles and deliverables?
Show answer and example
Answer: Requirements, design, implementation, and testing depend on each other. Free chat can distort handoffs. MetaGPT gives roles explicit responsibilities and checkable artifacts. Organization helps but complete documents are not correct code; run verification.
Illustrative example: Example: An architect defines the interface, engineers implement it, and testers check it. Chat-only definitions can lead to inconsistent parameters.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why can structured artifacts reduce hallucination cascades compared with free role chat?
Show answer and example
Answer: Downstream roles consume requirements, designs, and test contracts whose fields and constraints can be checked instead of trusting verbal promises. SOPs define order and dependencies so faults are easier to locate. Valid format does not ensure correct content or usable software; verify and execute.
Illustrative example: Example: An architect's interface lets engineers check signatures. 'The design is done' lets every role imagine a different contract.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How is PM, Architect, Engineer, and QA specialization different from repeated self-paraphrase?
Show answer and example
Answer: Each stage has distinct inputs, outputs, and artifacts: requirements, design, implementation, and tests. Gains depend on contracts and feedback, not labels that merely sound independent. Shared wrong assumptions can still break every stage.
Illustrative example: Example: QA should run tests rather than rephrase the engineer's claim that the code looks correct.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
How does the local temporary-repository test differ from a full MetaGPT LLM team?
Show answer and example
Answer: Four roles leave structured artifacts; engineering actually edits Python and QA runs fixed unittest. Full LLM collaboration and official SWE-bench are absent. This supports an auditable execution path, not HumanEval, MBPP, or real team delivery rates.
Illustrative example: Example: A file hash and test output verify one change and run, not autonomous architecture for unknown requirements.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why teach a model multiple tools rather than handwrite calls for each ToolBench task?
Show answer and example
Answer: Real catalogs have varied interfaces and parameters. A model must understand intent, find relevant demonstrations, and generate executable calls. ToolBench studies data and constraints for transferable tool use. Format is one step; verify API behavior, outputs, and final answers rather than synthetic success alone.
Illustrative example: Example: Weather and map tools require different fields. Use each contract instead of copying one fixed template.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why constrain format and check real execution in addition to retrieving usage examples?
Show answer and example
Answer: Examples show when and how to call tools but cannot guarantee schema or argument meaning. Format constraints ensure parseability; execution tests whether the goal is achieved. Experience, contracts, and observed results are distinct. JSON-like text is not actual tool capability.
Illustrative example: Example: A complete weather-call schema can still name the wrong city. Valid JSON does not answer the requested forecast.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does retrieving in-context demonstrations differ from always using one fixed example set?
Show answer and example
Answer: Retrieval chooses examples for the current task, avoiding irrelevant context and broader coverage gaps of fixed examples. It can still choose badly or encourage copied arguments. Reuse procedures, not answers. Compare fixed models and tasks and include example-reading cost.
Illustrative example: Example: SQL examples help database queries more than weather samples, but their table names cannot be reused unverified.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Does local planbench-mini tool success equal the paper's eight tasks or live API success?
Show answer and example
Answer: No. Local work tests demonstration, constraint, or state protocols without paper-scale models, training, or the full real tool matrix. Tool results and scoring require independent execution. Perfect controlled results are not public benchmark scores, and similarly named ToolBench datasets must not be conflated.
Illustrative example: Example: A preset plan can parse and execute without proving the model can call an unseen service from documentation.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does CRITIC try to find and fix errors after the model has already written an answer?
Show answer and example
Answer: Drafts can contain factual, reasoning, or code errors despite confidence. CRITIC gathers external checks for critique and revision. Observable evidence helps, but tools have limited coverage and edits can add errors. Evaluate checks and final outcomes separately.
Illustrative example: Example: Execute code on a boundary input, observe an exception, and revise. Rereading the same explanation gives no equivalent evidence.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why can external tool feedback reveal persistent errors that rereading an answer misses?
Show answer and example
Answer: Self-critique may inherit the original model's assumptions. Search facts or code outputs provide independently observable constraints. Evidence guides revision in a loop. Tools can fail or return nothing; no feedback is not verification, and success must not be fabricated.
Illustrative example: Example: A wrong product may still look right to the model. A calculator result provides a concrete contradiction for revision.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What evidence does code execution provide for critique versus web retrieval?
Show answer and example
Answer: Execution shows outputs or exceptions for a specific input. Web retrieval supplies external text whose source and support must be assessed. Both extend self-evaluation, with different limits: untested code can still fail, and a search hit need not support the answer.
Illustrative example: Example: Division by zero proves one run failed. A related web result still needs its actual passage read, not just its title.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
What feedback does the local real-traceback loop cover?
Show answer and example
Answer: It writes a defective patch, runs unittest, edits from observed feedback, reruns, and records commands and exit codes each round. This verifies controlled code feedback and iteration, not search engines, toxicity classifiers, or a general LLM critic. Running tests does not validate all paper tasks.
Illustrative example: Example: A second patch turning a failed test into a pass verifies this code instance, not open-domain QA or harmlessness.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does CAMEL study role collaboration instead of only a single model answer?
Show answer and example
Answer: Some tasks need requests, actions, and feedback over time. Two constrained roles can produce a longer collaboration process and data. Dialogue length and role division do not prove quality; roles can misunderstand goals, repeat, or drift. Inspect outcomes.
Illustrative example: Example: One role requests analysis and another implements with feedback. Repeating the request across turns does not complete the analysis.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why is inception prompting with roles, goals, and boundaries more than naming two models?
Show answer and example
Answer: Prompts define responsibilities, permitted requests, and cooperation. Alternating messages advance a common task under constraints. Renaming without capability or boundary differences can produce duplicates rather than collaboration. A social trace does not prove goal achievement; check deliverables separately.
Illustrative example: Example: One role specifies implementation and the other proposes solutions without changing the overall goal. Mutual praise does not move the task forward.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What does alternating two-role cooperation trade off against one complete model response?
Show answer and example
Answer: Dialogue can clarify and divide reasoning, but adds turns, communication, and error propagation. Models sharing biases cannot validate one another by agreement. Evaluate task outcomes and total cost rather than natural-sounding social messages.
Illustrative example: Example: An executor can ask for missing input. If both roles misread the goal, more turns only extend the mistake.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Does the local collaboration state machine match the full paper's multi-agent instruction-following scope?
Show answer and example
Answer: No. It tests role messages, state updates, and budget without full large-model social traces or benchmarks. Scripted lines can verify handoffs but not autonomous cooperation or general open-task success.
Illustrative example: Example: Two templated replies show alternation works, not that models maintain role and goal boundaries on unfamiliar tasks.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does HuggingGPT use expert model descriptions as a searchable capability catalog?
Show answer and example
Answer: The controller matches subtasks to model-card descriptions and invokes experts instead of implementing all vision and speech itself. Descriptions guide selection, not guarantee capability. Verify versions, input/output types, and availability.
Illustrative example: Example: Object recognition calls detection; audio-to-text calls ASR. Their media and output contracts differ.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why obey subtask dependencies instead of calling all multimodal experts simultaneously?
Show answer and example
Answer: A later expert may require actual outputs from detection, recognition, or transcription. Build a DAG, select compatible experts, run in topological order, then synthesize. Similar names do not imply compatible interfaces. Parallelize independent work, not dependencies.
Illustrative example: Example: Translate only after receiving real speech transcription. Starting translation concurrently and guessing the transcript breaks provenance.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What does the language controller do versus a specialist multimodal model?
Show answer and example
Answer: The controller interprets requests, selects specialists, and schedules subtasks. Specialists process vision or audio and the controller synthesizes results. Correct routing does not ensure correct predictions, and individual predictions do not guarantee a correct final answer. Verify selection, I/O, and interpretation separately.
Illustrative example: Example: A controller schedules image recognition before speech generation. The image and speech models execute their roles; the controller does not acquire their parameters.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Do the local capability registry and dependency edges run downloaded expert models?
Show answer and example
Answer: No. Local tool descriptions replace the model catalog to check matching and topological execution. No hundreds of Hugging Face checkpoints or ChatGPT calls ran. Edge counts verify flow, not cross-modal quality or real costs.
Illustrative example: Example: A detection node's rule-generated output can reach the answer node without establishing actual vision recognition.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does ART reuse reasoning and tool demonstrations for new tasks?
Show answer and example
Answer: Handwriting full CoT and tool flows for each task is costly. Prior examples offer transferable structure. ART retrieves examples and generates workflows using external computation. Validate current inputs and actual outputs; copying old answers or assuming cross-domain transfer is invalid.
Illustrative example: Example: Reuse a calculator-based cost comparison procedure for a new bill, but obtain new numbers and execution results.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why pause at a tool marker and resume after execution instead of generating a whole program with results at once?
Show answer and example
Answer: Pausing conditions later text on real tool returns rather than imagined outcomes. Retrieved reasoning/tool examples reduce manual prompts, but the runner must detect markers and inject observations. Frozen weights do not prevent tool feedback changing context and future output.
Illustrative example: Example: Execute a database query at its marker, then summarize the three returned rows rather than claim ten and add an unrun query.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What is the trade-off between retrieving examples automatically and hand-writing CoT for each task?
Show answer and example
Answer: Retrieval reuses library patterns and reduces human authoring, but similar examples may miss current constraints. Human revisions can extend the library, and new programs still need verification. Copying an example does not solve a new task or eliminate maintenance.
Illustrative example: Example: Reuse search-then-compute structure, but use queries and arguments from the new problem rather than copy the old answer.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
How does the local tool-signature task bank differ from program generation by a frozen LLM?
Show answer and example
Answer: Local tests check small-library retrieval, per-tool pause/resume, and updates without a frozen large model or BIG-Bench/MMLU. Pause counts show branches ran, not model-generated program semantics. Proxy costs are not paper tokens.
Illustrative example: Example: Three pauses from a structured template test the runner, not automatic programming for arbitrary natural language.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why learn when to use external tools from text training in Toolformer?
Show answer and example
Answer: Fluent models may still struggle with arithmetic, fresh facts, or retrieval. Toolformer inserts helpful API calls into training so the model learns timing, arguments, and return usage. Screening supplies learning signals, not guaranteed usefulness. A local filter does not train the model.
Illustrative example: Example: Insert a calculator call when a multiplication result helps complete the sentence, not after every number.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why compare later loss with the API return visible, hidden, and without a call?
Show answer and example
Answer: Call syntax alone can look useful without tool information. Counterfactual return conditions test whether actual output lowers later prediction loss. Keep calls beating the threshold for training to learn utility. This self-supervised proxy is not universal task accuracy or business gain.
Illustrative example: Example: Calculator syntax does not reveal the product. If the real return improves subsequent prediction, keep that call.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How does Toolformer construct call data differently from manually labeled tool trajectories?
Show answer and example
Answer: Human examples directly demonstrate actions. Toolformer starts with a few demonstrations, samples calls, filters by how much returns improve subsequent text prediction, then trains on retained data. This reduces per-call annotation without eliminating demonstrations, tools, or filtering requirements.
Illustrative example: Example: Instead of manually tagging each calculator call, generate candidates and filter by loss. Some bad candidates still need rejection.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Why isn't local utility-loss filtering completed GPT-J continued training?
Show answer and example
Answer: Local loss comes from deterministic utility. It preserves the candidate rule without GPT-J token likelihood, 6.7B training, or five real API classes. Candidate and acceptance counts show filtering ran, not learned timing or paper zero-shot capability.
Illustrative example: Example: A preset useful tool lowering rule-based loss verifies screening, not discovery of tool value in real training text.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does PAL generate programs and leave calculation to an interpreter?
Show answer and example
Answer: Word problems require both interpreting relationships and exact computation. Models turn interpretation into runnable code and the interpreter handles arithmetic. This reduces manual calculation burden, assuming the program captures the task. Execution cannot detect omitted conditions.
Illustrative example: Example: Assign people and prices to variables, but forgetting a half-price child means accurate execution of an incorrect total.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why can PAL still answer incorrectly after delegating arithmetic to Python?
Show answer and example
Answer: A deterministic runtime executes the given program, not the intended problem. The model still represents variables, relations, and control flow. Wrong units or discount order yield precisely wrong results. PAL reduces arithmetic errors without eliminating modeling mistakes.
Illustrative example: Example: The task discounts the subtotal before shipping, but code discounts both. Execution is correct for the wrong formula.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
How do error sources differ in PAL and manual chain-of-thought arithmetic?
Show answer and example
Answer: CoT handles understanding, steps, and arithmetic together. PAL gives exact arithmetic to programs, reducing numerical mistakes but introducing code and interface errors. Inspect intermediates and verify inputs and formulas. Determinism alone cannot predict accuracy or cost.
Illustrative example: Example: An interpreter avoids multiplication mistakes, but treating a tax rate as a monetary amount remains a modeling error.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Is the local CALL/RETURN intermediate representation arbitrary Python execution?
Show answer and example
Answer: No. A controlled interpreter verifies program construction and execution separation without Codex or paper GSM8K. Narrow actions help check contracts but do not establish open Python synthesis or a general security sandbox.
Illustrative example: Example: Predefined CALL nodes do not cover arbitrary loops, files, or external dependencies in a real runtime.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does MRKL combine an LLM with several external experts?
Show answer and example
Answer: Open questions can need language understanding, precise calculation, database access, or specialized knowledge. The LLM routes work and integrates results. Modularity separates capability sources but introduces routing and interface risks. One reliable module does not make the whole system reliable.
Illustrative example: Example: Fetch a balance from a database, calculate the difference, then explain it. Querying the wrong account invalidates even exact arithmetic.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why doesn't routing to deterministic modules guarantee a correct system answer?
Show answer and example
Answer: Calculators and databases are reliable only within their contracts. Routers may choose the wrong module or inputs, and language synthesis can misread outputs. MRKL separates precise capabilities from generation. Local determinism and end-to-end correctness are different guarantees.
Illustrative example: Example: A calculator receives an incorrect tax rate. Its result is precise and reproducible but wrong for the user.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What do modular experts trade off against one LLM doing everything?
Show answer and example
Answer: Experts can improve control of exact computation or fresh knowledge. One LLM has simpler interfaces but can rely on stale internal guesses. Routing, conversions, and errors add modular costs and depend on expert coverage. A calculator does not confer provable whole-system correctness.
Illustrative example: Example: A calendar computes the date difference; explaining why something was delayed still needs language and evidence.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Do local specialist call counts include Jurassic-X or a real knowledge base?
Show answer and example
Answer: No. Deterministic calculator and calendar specialists test routing and counts without Jurassic-X, search, or private databases. Proxy cost is not online latency. Symbolic call counts do not establish open QA or fresh knowledge quality.
Illustrative example: Example: A fixture database record tests scheduling, not real permissions, failures, or data updates.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why can't a robot directly execute a plausible language-model plan?
Show answer and example
Answer: Language reasoning may not know robot position, skill limits, or physical conditions. SayCan connects task meaning to affordance, selecting related and feasible next steps. Feasibility estimates can err, so report simulated plans separately from real completion.
Illustrative example: Example: Getting a cup is semantically right for a drink request, but the robot may need an executable approach step if it cannot reach the cup.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why multiply language relevance by affordance to filter plausible but impossible actions?
Show answer and example
Answer: Language scoring measures fit to instructions and history; the value function estimates execution success in the current world. Both need to be high. Language alone can suggest unreachable objects, and feasibility alone can pick irrelevant skills. Coverage and value estimates still limit selection.
Illustrative example: Example: A cup in a locked cabinet is relevant but not directly graspable. Opening the cabinet first can score better.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
Why are plan success and execution success different robot metrics?
Show answer and example
Answer: A sound plan can fail through perception, grasp, or control errors. Execution includes physical risk. SayCan reports both; higher planning rates are not completion rates. A deterministic local gate does not cover real control failures.
Illustrative example: Example: Picking up a cup and placing it on a table is a valid plan. A slipping gripper still makes execution fail.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Do local affordance checks validate real value-function training?
Show answer and example
Answer: No. Deterministic feasibility filters required and distractor skills while preserving two-score step selection. No vision, robot policy, or value network was trained. Check counts show execution paths, not calibrated success predictions or physical task results.
Illustrative example: Example: A rule can block grasping with a full hand without estimating reachability from images or grasp probability.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Basics
Why does WebGPT include browsing and source support in long-form QA rather than rely on memory?
Show answer and example
Answer: Open questions can need current facts and multiple sources. Browsing collects evidence for cited answers, and human feedback rates quality. Retrieved text still needs interpretation. Citation count neither proves support for individual claims nor covers all material facts.
Illustrative example: Example: Comparing two policies requires both primary descriptions. One related link cannot support every figure in the paragraph.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Core mechanism
Why rank citation-bearing browsing trajectories by human preference instead of simply requiring links?
Show answer and example
Answer: A URL does not guarantee support or answer quality. Behavior cloning learns browser actions, then preference reward selects better trajectories. Citations are checkable entry points, but selective quoting or unvisited sources are not reliable and must map to claims.
Illustrative example: Example: Two answers cite the same article; one reports the date correctly and one overstates its conclusion. Link counts cannot distinguish them.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Method comparison
What roles do behavior cloning and human-preference rejection sampling play?
Show answer and example
Answer: Cloning learns search, browsing, and answering from demonstrations. A preference model ranks and selects among candidate trajectories. Selection does not create facts, and can incur judge bias and sampling cost. Best-of-64 is not a single-call efficiency comparison.
Illustrative example: Example: Choosing one of 64 responses may improve preference scores while paying for multiple browsing and generation runs.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Tools and collaboration: turning plans into inspectable actions
Implementation details
Is choosing between two local trajectories by evidence coverage equivalent to live browsing and a reward model?
Show answer and example
Answer: No. Local checks retain browse actions, citation constraints, and candidate selection without live web, GPT-3 training, or a human preference model. Controlled coverage cannot be renamed human win rate, TruthfulQA, or real web fact verification.
Illustrative example: Example: Selecting a preset trace with broader evidence tests rejection sampling, not the full system without real pages and preference scoring.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Topic guide and reading order
Start with this question¶
With a plan in hand, how does an agent choose tools, interpret results, and share reliable execution state across roles?
Takeaway¶
Tool calls need a contract: when to call, parameters, how outputs affect next actions, and how failures are recorded. Toolformer uses later prediction loss to filter useful API calls. CRITIC uses external feedback to revise answers. Collaboration adds ownership, state handoffs, and artifact verification. Role count is organizational; information flow, responsibility, and actual tool execution determine results.
Example¶
For a repository fix, a search role locates code, an execution role edits and tests, and a reviewer reads the real diff and test output. A timed-out command is not success. Separate environment failure from an incorrect fix. Three roles saying it looks right do not replace an executable check.
Common pitfall¶
Tool output is evidence to verify and may be stale, injected, or incomplete. Limit permissions, keep failures and unknowns, and avoid repeating actions with side effects. Local interfaces, candidate filtering, and small environments do not establish full browser, production, or software benchmark capability.
Reading order¶
Read Toolformer for deciding when a call helps, CRITIC for evidence-driven revision, and SWE-agent for stateful repository actions and test loops.
Check your understanding¶
One role writes a patch, another agrees, and a third declares success. With no test execution record, is verification complete?
Show suggested answer
No. Roles can share one error. Define acceptance conditions, run relevant checks, and read the results. Keep unrun and interrupted checks separate. If execution is unavailable, report static review only; role discussion is not a passing test.