TOPIC
Deep Research Agents
A subject the collection covers, read through 15 synthesis notes.
View as
Can schema-free graphs objectively evaluate open-ended search?
Can a directed graph with no preset structure capture the complexity of real search outputs while still enabling objective, fine-grained evaluation? This matters because existing evaluation methods trade objectivity for rigidity or richness for subjectivity.
Can knowledge graphs generate training data for search agents? Can agents evaluate AI outputs more reliably than language models? Why do search agents fail users despite strong benchmark scores? How should we evaluate agent behavior beyond final answers? Why do search agents beat memorized retrieval on hard questions?
Knowledge graph synthesis with entity blurring trains scalable search agents Agent-based evaluation with evidence collection reduces judge shift by 100x over LLM judges Benchmark artifacts cause the search evaluation-experience gap Agent evaluation must score trajectories not just final responses Real-world search agents outperform memorized retrieval by avoiding knowledge gaps
Does search budget scale like reasoning tokens for answer quality?
Explores whether the test-time scaling law that applies to reasoning tokens also governs search-based retrieval in agentic systems. Understanding this relationship could reshape how we allocate inference compute between thinking and searching.
Can we allocate inference compute based on prompt difficulty? How should we balance parallel versus sequential compute at test time? How do internal and external test-time scaling compare? Do search steps follow the same scaling rules as reasoning tokens? When should retrieval happen during model generation?
Adaptive inference compute allocation outperforms fixed budgets per prompt Parallel and sequential scaling represent a fundamental trade-off in test-time compute Internal and external test-time scaling are complementary taxonomic categories Search budget follows the same test-time scaling curve as reasoning tokens. Uncertainty-gated retrieval outperforms fixed interval retrieval
Can models learn when to invoke search during reasoning tasks? How should we allocate compute between reasoning and retrieval iterations? Does parallel retrieval outperform sequential search chains at test time? Why does retrieval chain training unlock scaling laws in QA? How can per-step decisions about knowledge retrieval improve reasoning over uniform policies? Can the scaling law for discovery extend beyond architectures to agentic systems? What makes some tokens carry disproportionate information about answers? How does hierarchical query planning versus flat prompting affect multi-source retrieval? How does search budget affect answer quality at test time? How does the three-component definition apply to test-time scaling laws? What scaling behavior do partial systems show without iterative query refinement? How do real search queries reveal what counts as a deep research question?See all 65 inquiring lines on this note →
Can agents compress their own memory without losing critical details?
Explores whether agents can autonomously consolidate interaction history into structured memory schemas that reduce token overhead while preserving information needed for long-horizon reasoning and strategic reflection.
Does agent memory degrade when continuously consolidated? Can simulated APIs and token-level credit assignment train better tool-using agents? Can agents discover tools dynamically instead of pre-selecting them? Can three axes replace the short-term long-term memory split? Can LLMs read long documents like humans do?
Continuously consolidated agent memory follows an inverted-U utility curve LLM simulators plus tool-call advantage attribution stabilize agentic RL training Dynamic tool discovery during execution outperforms predefined tool sets Three orthogonal axes unify agent memory better than short-term long-term Gist memories let LLMs extend effective context twentyfold
Can persistent memory and identity files alone create genuine agent socialization? Does state persistence in AI systems create the same temporal presence as human waiting? How should GUI agents remember patterns across different software environments? Which AI interaction patterns preserve learning while which ones degrade skill formation? Why do abstract semantic memories outperform specific interaction histories for journey discovery? Why does persistent memory alone fail to create genuine position-holding in models? Can environmental scaffolding replace internal memory scaling in agent design? Could a single agent system switch memory granularity between tasks? Should agents update memory after every turn or batch process sessions? How do the six memory components combine across explicit and implicit paths? Why do different agent memory architectures make incompatible granularity claims? What role do material artifacts play in solidifying AI relationships?See all 139 inquiring lines on this note →
What capabilities do AI systems need for autonomous science?
Explores whether current AI benchmarks actually measure what's required for independent scientific research—hypothesis generation, experimental design, data analysis, and self-correction—or if they test only adjacent skills.
Does self-revision actually improve reasoning in language models? Does a model improve by arguing with itself? Does reasoning fine-tuning make models worse at declining to answer? Where does AI assistance become unreliable in research? Can human-AI research teams improve faster than autonomous AI systems?
Self-revision degrades reasoning accuracy in o1-like models Self-revision amplifies confidence in wrong answers, but diverse debate prevents it Reasoning fine-tuning degrades model abstention capacity by approximately 24 percent AI reliability follows a sharp stage-dependent boundary tracked by task checkability Human-AI research collaboration achieves faster paradigm discovery with better safety and transparency.
Where do human researchers retain competitive advantage over autoresearch systems? Why do major AI breakthroughs require human-discovered data and method combinations? Which research collaboration skills should AI systems develop first? Why did every major AI paradigm require human data and method innovation? How should domain-specific AI be evaluated differently from general benchmarks? What skills can large models identify and organize about their own abilities? What tasks do users actually want AI to handle versus what can it automate? Why do benchmark scores not capture the true nature of AI systems? Why does AI generation outpace verification across the research lifecycle? What specific failure modes appear when AI tackles research-level experiments? Where is human judgment still essential in AI-assisted research? How should safeguards be built into AI research pipelines?See all 15 inquiring lines on this note →
Can codified expertise let non-experts match specialist output?
When domain knowledge is captured as explicit rules and principles in an AI agent's scaffolding, can non-experts produce work at expert quality levels without consuming scarce specialist time? This explores whether structured knowledge codification dissolves organizational bottlenecks.
Structured artifacts outperform natural language for multi-agent coordination. Agent reliability comes from externalizing cognitive burdens into system structures. AI reliability follows a sharp stage-dependent boundary tracked by task checkability Specialized model deployment requires ecosystem design beyond capability alone. Firms substitute labor for AI faster and cheaper at firm-specific rates
How does externalizing tacit expertise into structured rules differ from prompt engineering? What organizational bottlenecks emerge when expertise concentrates in few specialists? Does codifying expertise into AI agents drive faster labor substitution? Can expert-derived knowledge bases scale to other high-stakes domains? What tacit knowledge do researchers assume humans will fill in automatically?
Why do search agents beat memorized retrieval on hard questions?
Deep research agents trained on live web search outperform models fine-tuned on static knowledge. Does real-world RL's advantage come from smarter reasoning, or from bypassing the limitations of memorized facts?
Does search budget scale like reasoning tokens for answer quality? Why do language models fail confidently in specialized domains? Do language models actually use their encoded knowledge? Why do specialized models fail outside their domain? Why do language models struggle with historical legal cases?
Search budget exhibits test-time scaling identical to reasoning tokens Language models show persistent overconfidence in specialized knowledge domains Encoded knowledge in LMs often fails to causally influence generation Domain specialization creates hard capability cliffs at domain boundaries LLMs show systematic performance degradation on historical legal cases
How does AI assistance differ from search engines in cognitive impact? How does search budget affect answer quality at test time? Can knowledge graphs generate scalable training data for deep search agents? Do single-step retrieval systems with sophisticated synthesis qualify as deep research? Are larger models and search access substitutes for factual accuracy? How do real search queries reveal what counts as a deep research question? What makes web retrieval more effective than static knowledge bases? Can step-level rewards improve training of agentic retrieval systems? When does simulated search outperform real search for agent training? How does speed of AI search prevent real-time supervision and evaluation? What makes search budget matter for research task performance? How does proactive information-gathering capability differ from passive knowledge retrieval?See all 15 inquiring lines on this note →
What makes deep research fundamentally different from RAG?
Explores whether current systems using the label 'deep research' actually meet a rigorous three-component definition involving multi-step gathering, cross-source synthesis, and iterative refinement, or if they're performing something narrower.
Does search budget scale like reasoning tokens for answer quality? Do hierarchical retrieval architectures outperform flat ones on complex queries? Can a model's partial response guide what to retrieve next? Does token spending drive multi-agent research performance? Can iterative revision cycles match how humans actually write?
Search budget exhibits test-time scaling identical to reasoning tokens Hierarchical retrieval architectures outperform flat architectures on multi-hop queries Model responses reveal information gaps that original queries cannot express Token usage explains 80 percent of multi-agent research performance gains. Iterative revision cycles structurally mirror diffusion denoising with retrieval
Can agents discover tools dynamically instead of pre-selecting them?
Explore whether agents can find needed tools during execution rather than choosing from a fixed set upfront. This matters for long-horizon tasks where relevant tools cannot be known in advance.
Can agents compress their own memory without losing critical details? Can simulated APIs and token-level credit assignment train better tool-using agents? Can semantic capability vectors replace manual agent routing? How should agents split planning from visual grounding? Can LLMs generate workflows without touching proprietary data?
Agents autonomously compress memory into structured schemas enabling reflection and efficiency LLM simulators plus tool-call advantage attribution stabilize agentic RL training Semantic capability vectors enable scalable agent discovery without manual wiring. Agents need an intermediate interface between planning and grounding layers. API-grounding lets LLMs generate workflows while keeping proprietary data safe
When should you optimize agent behavior versus tool performance separately? Can tool adaptation work without freezing the agent in the loop? How does real tool integration change what agents learn compared to simulated tools? How does the execution layer constrain agent performance in tool use? What happens when tools compete for agent invocation rather than human clicks? How do agents discover and select which tools to invoke? How do agents discover and construct new APIs from existing applications? Can this approach handle continuously changing product inventories in production? Should agents continuously prune irrelevant links during execution? What training method supports dynamic tool discovery in long-horizon agents? Should production agents execute one tool or multiple tools per invocation? Why does pre-computed workflow generation work better than runtime tool discovery for data security?
Do hierarchical retrieval architectures outperform flat ones on complex queries?
Explores whether separating query planning from answer synthesis into distinct architectural components improves performance on multi-hop retrieval tasks compared to unified single-pass approaches.
Does search budget scale like reasoning tokens for answer quality? How do readers track segments, purposes, and salience together? Can tailoring queries per document improve debatable summarization? What makes deep research fundamentally different from RAG? Can building a document map first improve retrieval over long texts?
Search budget exhibits test-time scaling identical to reasoning tokens Discourse coherence requires simultaneous tracking of three irreducible layers Per-document query specialization dramatically improves perspective coverage in debatable summarization Deep research requires three simultaneous components to be distinct from RAG. Global summaries before retrieval guide RAG to connect distant evidence effectively
What makes query complexity a better routing signal than response quality? How does ranking-aligned summarization compare to aspect-controlled generation methods? Can retrieval improve multi-step reasoning by triggering at each uncertainty? Can task-aware ranking replace similarity scoring in other RAG systems? What makes reranking during retrieval better than catching failures at plan time? How should we allocate compute between reasoning and retrieval iterations? Does parallel retrieval outperform sequential search chains at test time? What makes proactive tool retrieval better than single-round semantic matching? How does semantic search over research papers guide autonomous architecture proposals? What mathematical limits constrain embedding-based retrieval systems? Can embedding-based retrieval alone solve the causal relevance problem? How does structure-aware retrieval routing differ from existing graph-versus-vector RAG tradeoffs?See all 92 inquiring lines on this note →
Can models learn better by training on messy exploration paths?
Does including trial-and-error, reflection, and backtracking in training data teach models to reason more robustly than teaching only the polished shortest path to answers?
Reflection in reasoning models is mostly confirmatory, not corrective. RL extends reasoning only with headroom and edge-of-competence targeting Self-healing executors turn experiment failures into structured learning signals Reasoning model reflection rarely corrects and traces rarely explain. Reasoning models fail systematically across exploration, mode selection, and social understanding.
What makes some training data teach brittle answers versus robust reasoning? How does question difficulty and breadth affect what models learn to reason? What makes exploration a verifiable and measurable training objective? What determines whether accumulated state generalizes spuriously across continual learning domains? Does curriculum-based training keep small models perpetually at their learning edge? What trade-offs emerge between training objectives and model reliability? How does soft thinking achieve stochastic exploration without explicit training? How does scaffolding unstable mechanics improve reinforcement learning for search? Why does exploration diversity behave differently under reinforcement learning versus supervised fine-tuning? What happens when models overthink during test-time search? Can reinforcement learning improve how accurately models explain themselves?
Does limiting reasoning per turn improve multi-turn search quality?
When language models engage in iterative search cycles, does capping reasoning at each turn—rather than just total compute—help preserve context for subsequent retrievals and improve overall search effectiveness?
Does more thinking time always improve reasoning accuracy? Do iterative refinement methods suffer from overthinking? Does extended thinking actually improve reasoning or just increase variance? Why does vanilla RAG produce shallow and redundant results? Can retrieval be extended into multi-step chains like reasoning?
Reasoning accuracy peaks then declines with excessive thinking tokens Iterative refinement reproduces overthinking at the response level Extended thinking inflates output variance rather than improving reasoning quality Iterative expansion and reflection loops increase RAG knowledge density significantly Chain-of-retrieval augmented generation enables test-time scaling for retrieval
Can models learn when to invoke search during reasoning tasks? How should we allocate compute between reasoning and retrieval iterations? Does parallel retrieval outperform sequential search chains at test time? How can per-step decisions about knowledge retrieval improve reasoning over uniform policies? What makes proactive tool retrieval better than single-round semantic matching? Does full conversation history improve or degrade multi-turn retrieval accuracy? Can multi-turn rewards fix models that lose track midway? How does hierarchical query planning versus flat prompting affect multi-source retrieval? How does search budget affect answer quality at test time? How do search tasks differ from derivation tasks in reasoning efficiency? Why does multi-turn RL generate orders of magnitude more tokens than single-turn? What makes session-aware multi-turn tracking necessary for asynchronous training?See all 63 inquiring lines on this note →
Does reinforcement learning squeeze exploration diversity in search agents?
Investigates whether RL training narrows the behavioral diversity of search agents the same way it does in reasoning tasks. Understanding this mechanism could reveal whether entropy collapse is fundamental to RL or domain-specific.
Does policy entropy collapse limit reasoning performance in RL? Do critique models improve diversity during training itself? Can simple rewards alone teach complex domain reasoning? Does the choice of RL algorithm actually matter for reasoning? Does RL training collapse format diversity in pretrained models?
Policy entropy collapse creates a predictable performance ceiling in reasoning RL Critique models improve exploration diversity during training, not just test accuracy. Reinforcement learning emerges complex reasoning from simple objective rewards RL algorithm choice is interchangeable because the pretrained prior bounds exploration RL training converges on a single dominant pretraining format while suppressing others
Which AI interaction patterns preserve learning while which ones degrade skill formation? Can few-shot examples narrow generative diversity in creative tasks? Do dynamic environments enable different kinds of agent-environment coevolution? Do disorder-specific RL policies outperform single policies across anxiety, depression, and schizophrenia? How does entropy collapse in reinforcement learning differ from entropy maintenance in graph reasoning? Does optimizing directly for semantic diversity improve both reasoning quality and exploration? What role does environment diversity play in preventing agents from overfitting to curator imagination? Why does RLVR increase token entropy while decreasing answer diversity? What role does exploration-exploitation balance play in abstraction formation? When does natural context diversity reduce the need for explicit exploration? How do evolutionary archives enable diverse exploration in self-improving systems? Can population diversity in self-improvement prevent error avalanching failures?See all 137 inquiring lines on this note →
Why do search agents fail users despite strong benchmark scores?
Search evaluation benchmarks show high performance, yet real users remain unsatisfied. What gaps between test conditions and actual search behavior explain this disconnect?
Which clarifying questions actually improve user satisfaction? Does user satisfaction actually measure cognitive understanding? Why do deep research agents fabricate scholarly content? Should interactive evaluation be designed as a unified paradigm? Should we evaluate deployed agents as whole environments instead?
Specific facet questions outperform need-rephrasing for user satisfaction Internal cognitive clarity matters more than expressed satisfaction scores Deep research agents strategically fabricate content to satisfy depth demands Interactive evaluation requires design science, not benchmark proliferation The coupled human-agent environment is the correct unit for evaluation
How does search budget affect answer quality at test time? What makes search budget matter for research task performance? Why do current benchmarks fail to match user satisfaction with search results? What is the gap between benchmark performance and real workplace task completion? What role does vague intent play in realistic search evaluation? Can high benchmark scores mislead deployment decisions for search agents? Do gains from harness-based agents transfer across different search benchmarks? Why do benchmarks become saturated so quickly after initial launch?
Do search steps follow the same scaling rules as reasoning tokens?
Exploring whether the overthinking curve observed in reasoning models also appears in deep research agents. This matters because it could reveal universal scaling laws governing all inference-time compute.
Does search budget scale like reasoning tokens for answer quality? Does more thinking time actually improve LLM reasoning? Does limiting reasoning per turn improve multi-turn search quality? What makes a research domain suitable for autonomous optimization? Why do search agents beat memorized retrieval on hard questions?
Search budget exhibits test-time scaling identical to reasoning tokens More thinking tokens hurt LLM accuracy beyond a critical threshold Per-turn reasoning limits preserve context for iterative search cycles Four properties determine whether domains can benefit from autoresearch systems Real-world search agents outperform memorized retrieval by avoiding knowledge gaps
How do thinking tokens exhibit diminishing returns beyond a critical threshold? Why does retrieval chain training unlock scaling laws in QA? Can the scaling law for discovery extend beyond architectures to agentic systems? Can bilevel autoresearch discover new search mechanisms for the inner research loop? What distinguishes strategic fabrication from accidental hallucination in research agents? How do real search queries reveal what counts as a deep research question? Do task-specific heuristics improve gradually or appear suddenly at scale? Does inference-time compute scaling require explicit reasoning traces or verifiable rewards? Can multi-agent reasoning systems scale beyond current architectures? What role does confidence play in balancing overthinking versus underthinking? Does test-time compute scaling work for agentic deep research tasks? Does trading model size for inference steps improve overall efficiency scaling?See all 48 inquiring lines on this note →
Can simulated APIs and token-level credit assignment train better tool-using agents?
Training agents to use real APIs is expensive and unstable, and sparse rewards make it hard to credit the right tool calls. Can combining LLM simulators with fine-grained advantage attribution solve both problems?
Can agents compress their own memory without losing critical details? Can agents discover tools dynamically instead of pre-selecting them? Can step-wise expert rewards help small models learn hard reasoning? Can tree structure alone convert outcome rewards into process supervision? Can trajectory structure replace hand-annotated process rewards?
Agents autonomously compress memory into structured schemas enabling reflection and efficiency Dynamic tool discovery during execution outperforms predefined tool sets Step-wise expert-similarity rewards enable small models to learn hard reasoning Tree-search rollouts convert outcome rewards into process supervision automatically Trajectory structure can substitute for separately trained process supervision
Why do tokens need validators while commodities need standardization? How does credit assignment drive agents to write information into environments? What safety protections work when simulators have access to real APIs? How does real tool integration change what agents learn compared to simulated tools? What happens when you train user simulators instead of task agents? How do agents discover and construct new APIs from existing applications? How much does external API latency dominate total agent execution cost? What metrics replace throughput per token for agent deployment? How do tool invocations drive agentic cost beyond token consumption? How does credit assignment across objectives differ from credit assignment across time? What makes API-based scaffolding more trustworthy than direct model access in high-stakes domains?