LLM-as-an-Investigator: Evidence-First Agentic Reasoning for Robust Interactive Problem Diagnosis

arXiv:2606.13220 · cs.AI, cs.CE, cs.ET, cs.LG, cs.MA · Submitted 2026-06-11 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: I'm Tom.

Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.

Tom: Today's paper: "LLM-as-an-Investigator: Evidence-First Agentic Reasoning for Robust Interactive Problem Diagnosis".

Jane: The gist The proposed methodology introduces LLM-as-an-Investigator,

Tom: First, who's behind it and why it matters.

Title and authors: Tom: So we're talking about this paper now, "LLM-as-an-Investigator: Evidence-First Agentic Reasoning for Robust Interactive Problem Diagnosis." It sounds like they’re trying to fix a big problem where these language models just jump to the first answer they see instead of digging deeper.

Jane: Right. Basically, if you ask an AI about a technical problem, and it hears what you suggest—even if that suggestion is wrong—it might just go along with it instead of actually testing if your idea makes sense against the facts. That's what they call user-driven sycophancy.

Tom: Exactly. And this paper proposes this whole system called LLM-as-an-Investigator, which shifts the AI's job from being a direct answer generator to being an interactive investigator that keeps asking questions until it finds the real problem.

Lu: The core idea is having a Solution Investigator Agent that estimates how confusing the initial description is, then it creates several competing possible solutions and then it starts asking targeted questions to narrow down which one is actually correct.

Meng: So, instead of giving you one guess upfront, this AI keeps generating hypotheses and refining those probabilities based on what you tell it next. It's like a detective that doesn't just follow the first clue but actively searches for contradictory evidence.

Jane: That sounds really structured. How does this system actually work in practice? What are the key parts they built into this approach?

Tom: They have this explicit state representation they call C, which keeps track of everything: the original problem, the history of your answers, all the questions asked so far, and a sequence of probability vectors showing how likely each hypothesis is.

Lu: That explicit state is important because it stops the model from mixing up different pieces of information during the investigation loop. It keeps everything organized so it doesn't get lost in conversation drift or start hallucinating connections between unrelated ideas.

Jane: And how does it handle the uncertainty of the initial problem? Does it know when to stop asking questions?

Title and authors: Tom: They estimate ambiguity first by scoring the initial problem description with a score 'a', and then they use that to compute a question budget, which is dynamically adjusted based on whether the case seems easy or hard.

Meng: So, if the problem is really fuzzy, it gets more questions before it settles on an answer. If you give it clear info early on, it doesn't waste time asking too many things.

Lu: The loop itself goes through five main phases: initializing the problem description, estimating that ambiguity score we talked about, doing some preliminary clarification to get essential missing data, then generating a set of candidate solutions with initial scores, and finally going into the iterative investigation phase.

Jane: And in that iterative phase, what's the agent actually doing when it's asking those questions? What’s its goal there?

Tom: It generates targeted questions aimed specifically at distinguishing between the most likely candidate solutions based on the current probability vector it has built up. If one hypothesis gets more weight from your answer, that hypothesis gets stronger, and others get weaker.

Meng: So, if you say something that strongly supports one idea, the AI immediately starts asking questions designed to confirm that idea or challenge the others to see if they hold up. It’s not just a passive listener.

Jane: That leads into the part where they talk about resisting those misleading suggestions we mentioned earlier. How does this system specifically fight against user-driven sycophancy?

Tom: They treat a user suggestion as just another hypothesis to be tested against evidence, meaning it's not accepted as a fact just because you said it early in the dialogue. It actively works to challenge those initial assumptions with more info.

Lu: And they use this mechanism alongside their structured state representation to ensure the agent maintains alternative hypotheses throughout the whole process, instead of immediately committing to one path.

Jane: So, what were some of the results from testing this approach? How does it compare against older methods?

Tom: They used a three-agent pipeline for evaluation, comparing this new method against a direct base-model assistance called BAS and another reasoning-oriented approach called THK. They found consistent improvement in diagnostic accuracy as you moved from direct answering to reasoning prompting, and then even further improvement with the investigation approach.

Title and authors: Meng: The numbers are pretty telling; for instance, the SIA score reached seventy-one point two five on gemini-three point five Mechanical cases, which is way higher than the BAS baseline score of thirty-six point nine three they mentioned in their comparison.

Lu: And concerning that sycophancy analysis, they found that standard assistants rarely challenge misleading hypotheses on their own; they often only do it after you explicitly ask them to check the assumptions during an explicit consistency check.

Jane: That's a big distinction—it’s not just better at answering, it’s better at *not* being misled when things get tricky. So, what does this mean for the people who actually use these tools every day?

Tom: It means that instead of getting a quick answer you might not trust, you get an AI that acts like a methodical researcher, forcing the conversation into a more rigorous diagnostic path.

Lu: The contribution here is defining user-driven sycophancy in interactive technical problem solving and proposing this evidence-first methodology where the agent asks clarifying questions and updates normalized plausibility scores before it returns a final diagnosis.

Meng: They also put out a structured benchmark of solved troubleshooting cases across electrical, hydraulic, and mechanical domains, which is useful for actually testing if this approach scales on real traffic.

Jane: It sounds like this paper really shows that for complex technical problems—the kind you deal with in engineering or troubleshooting—you need an AI that investigates rather than just guesses. What should we take away from all of this about LLMs?

Tom: The main point is moving past the expectation that an LLM will always give you a confident, final answer on the first try, especially when things are ambiguous.

Lu: The implication is that for technical support and diagnosis, designing an AI around iterative hypothesis testing and evidence collection is a more robust way to achieve accurate problem identification.

Jane: So we’ve heard about how this "LLM-as-an-Investigator" works, how it beats the baseline scores, and why it's important for avoiding that trap of blindly accepting bad advice. That wraps up our look at this paper for now.

The paper's summary: Tom: So, to quickly recap, this paper is about changing how we use Large Language Models for solving hard technical problems by turning them into an investigator instead of just giving them a direct answer right away.

Jane: That’s right, and the core idea is that instead of the AI just guessing the solution first, it’s designed to probe you. It estimates how confused the initial problem is, then it generates competing ideas and keeps asking targeted questions until it finds solid evidence for one path over all others.

Tom: Exactly. He calls this method "LLM-as-an-Investigator," and what I find really interesting is how they separate the reasoning—the AI’s job—from the control layer that just manages all that state, making it very structured.

Jane: The structure is key because it prevents the AI from getting lost in a long chat where it starts mixing up all the different pieces of information you gave it earlier. They build an explicit state representation to keep everything neat and organized throughout the whole process.

Tom: And they have this dynamic question budget, which means if the problem description is really fuzzy, the AI will ask more questions before it stops investigating. If you give it clear info right away, it doesn't waste time asking endless things.

Jane: The results on those mechanical cases were pretty compelling; they showed that this evidence-first approach actually got a higher diagnostic score than the direct answering baseline models. That’s what proves the methodology is improving identification accuracy when things are tricky.

Tom: And I gotta say, one of the biggest takeaways for me is how it handles user suggestions. They treat a suggestion not as an accepted fact, but as just another hypothesis that needs to be tested against the actual evidence you provide in the conversation. That really fights against that tendency for models to just agree with what you say early on.

Jane: It’s like giving the AI a built-in skepticism mechanism, forcing it to verify things instead of blindly following instructions. This shifts the focus from getting a quick guess to building a verified solution step by step.

Tom: And they also put out this whole structured benchmark across electrical, hydraulic, and mechanical areas, which is useful because it gives other researchers a way to test if this methodology actually scales when you try it on real-world technical stuff.

Jane: It shows the authors are thinking about how to make this practical beyond just a neat lab experiment. It moves the conversation from "what does the model say?" to "how do we rigorously verify what the model found?"

Tom: Exactly. So, we’ve seen how they built this interactive loop and why it beats direct prompting in terms of accuracy and reliability in diagnosis. Next up, I want to talk about how other agents are evolving beyond this static testing loop with something called Agent Gym.

The paper's improvements: Tom: So, moving past just describing the method, these authors are suggesting some real improvements to make this investigator agent even better for real use cases.

Jane: Right, they’re not just presenting a static framework; they’re proposing ways to make it more adaptable and robust when you actually deploy it in a technical support setting.

Tom: They focused on refining that iterative investigation loop by making the way the agent calculates its question budget even more flexible, so it can handle weirdly complex problems better.

Jane: And they also talked about how to improve the way the probability vector is updated after each user answer, making sure that new evidence isn't just tacked on without proper weighting.

Tom: They’re suggesting ways to make that feedback mechanism more sensitive so the agent can quickly zero in on a solution even if you give it confusing information. It's about better signal processing of the dialogue.

Jane: Plus, they touched on how to handle those boundary conditions—the stopping points—so the agent knows when it’s done asking questions and should just present its best finding. That’s important for usability, because if it keeps asking forever, nobody will use it.

Tom: And they mentioned a way to structure the state representation even more explicitly so that different parts of the investigation don't interfere with each other anymore. More separation between the problem description and the collected evidence.

Jane: It sounds like they’re tackling those "uncontrolled conversational drift" issues head-on by enforcing stricter boundaries on what information goes where in the AI’s memory during a long session.

Tom: The implication here is that we can move toward agents that are not just smart at one task, but are smart at managing a complex, multi-step diagnostic process reliably. It’s about making the entire interaction predictable.

Jane: And they even hinted at future work where this kind of structured investigation could be combined with human feedback loops to make the agent evolve over time in ways that are safer and more accurate.

Tom: So, it’s not just about getting a better score on one benchmark; it’s about designing an entire reasoning pipeline that is inherently more reliable and harder to mislead during a live diagnostic session.

Jane: It gives us a clear direction for how to build the next generation of technical assistants—moving them from simple answer generators toward true, interactive problem-solving partners.

Tom: And I'm looking forward to seeing how the engineering team implements these refinements when they start building out those production models based on this structure.

Conclusion: Tom: So, to wrap up, this paper introduces LLM-as-an-Investigator as an evidence-first methodology that reframes the AI from an answer generator to a rigorous hypothesis investigator for problem diagnosis.

Jane: That’s right, and the main implication is that for complex technical problems, we need AI systems that actively seek out the truth through structured questioning instead of just guessing a quick fix.

Tom: The shift is from BAS or THK models which are basically just prompting, to this SIA model which actually runs an investigation loop.

Jane: It means that when you're dealing with ambiguous technical issues—say, diagnosing a complex electrical fault—you get a much more reliable path to the solution because the AI is actively testing hypotheses against your answers.

Tom: From an engineering standpoint, it’s about controlling the process so that we aren't just getting random noise from a massive model. The explicit state tracking and dynamic question budgeting make it manageable for deployment.

Jane: And for someone listening to the show, it means the AI won't just give you a confident answer that turns out to be wrong; it will walk you through the reasoning process step by step until you understand why one solution is better than another.

Tom: It’s about moving past those high-level claims and getting concrete diagnostic accuracy, which they showed reaching scores around seventy-one point two five on those mechanical cases compared to baselines like BAS.

Jane: That number shows the methodology actually works in practice when tested against real technical scenarios, which is a big deal for building trust in these systems.

Tom: I'm just glad we looked at the mechanics of it, because next time we talk about how agents learn from human feedback and stay consistent, we’ll be looking at Agent Gym.

Jane: Right, so if you want to know how we can make these interactive agents evolve over time with more robust evaluation frameworks, that's what you want to see next.

Tom: Exactly. We’re moving from just testing a static agent to building one that learns and adapts continuously based on human input.

University of Calabria · University of Cambridge United Kingdom

cs.AI, cs.CE, cs.ET, cs.LG, cs.MA

Submitted: 2026-06-11

Updated: 2026-10-13

Code: https://github.com/SCAlabUnical/llm-as-an-investigator

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 87/100

The gist: The gist The proposed methodology introduces LLM-as-an-Investigator, an evidence-first agentic AI methodology for robust problem diagnosis that reframes the LLM's role from a direct answer generator

Key concepts

LLM-as-an-Investigator: This is an evidence-first methodology where the LLM acts as a detective rather than just an answer machine. It involves an agent that systematically investigates a problem by generating hypotheses, asking clarifying questions, and updating the likelihood of each hypothesis based on the information gathered during the dialogue.
Solution Investigator Agent (SIA): The SIA is the core agent orchestrating three reasoning behaviors: a Diagnostic Reasoner, a Hypothesis Investigator, and a Counterfactual Investigator. It maintains an explicit state tracking all problem details, collected evidence, and competing hypotheses to guide the entire diagnostic interview.
User-driven Sycophancy: This refers to the tendency for users interacting with AI systems to prematurely commit to an incorrect hypothesis or follow misleading suggestions provided by the LLM. The methodology is designed specifically to counteract this by treating user input as a potential hypothesis that must be rigorously tested against gathered evidence.
Explicit State Representation: The SIA maintains a detailed, structured state (C) containing the problem description, conversation history, collected constraints, and probability vectors. This ensures the agent does not mix different types of information during its investigation loop, allowing for traceable and robust reasoning.

Terminology

Accuracy — 1× in this paper · explained in 1 episode
Agentic AI — 1× in this paper · explained in 1 episode
Agentic Reasoning — 1× in this paper · explained in 1 episode
Benchmark — 1× in this paper · explained in 2 episodes
Large Language Models (LLMs) — 1× in this paper · explained in 6 episodes
Sycophancy — 1× in this paper · explained in 4 episodes

Summary

The gist The proposed methodology introduces LLM-as-an-Investigator, an evidence-first agentic AI methodology for robust problem diagnosis that reframes the LLM's role from a direct answer generator to an interactive hypothesis investigator.

How it works

The core of the approach is the Solution Investigator Agent, which estimates the ambiguity of an initial problem description, generates competing candidate hypotheses, asks targeted clarification questions, and updates hypothesis probabilities after each user answer The agent continues the investigation until collected evidence makes one candidate explanation substantially stronger than the alternatives. This design separates semantic reasoning from deterministic control, where the LLM interprets the problem and generates hypotheses, while an external control layer manages state, detects contradictions, and enforces stopping conditions.

The methodology follows a structured investigation loop outlined in Algorithm 1. This loop involves five main phases: problem initialization, ambiguity estimation, disambiguation, hypothesis generation, and iterative investigation. During the iteration phase, the agent generates questions aimed at distinguishing between the most likely candidate solutions based on the current probability vector. The probability vector is updated after each user answer, allowing the agent to increase the weight of hypotheses supported by evidence and decrease less compatible ones.

Key Components and Mechanism

The Solution Investigator Agent maintains an explicit state, denoted as C = [P, H, Q, V, R, t], which includes the original problem description P, the history of user answers H, the set of questions already asked Q, collected constraints V during interaction, a sequence of probability vectors R generated during investigation turns t. This explicit state representation prevents the model from mixing different types of information. The agent estimates ambiguity using an initial score 'a' to compute a question budget B = min(Bmax, Bmin + a). This budget dynamically adapts to the expected difficulty of the case.

The process involves several critical steps for robustness against user-driven sycophancy:

Estimate ambiguity and compute question budget B.
Perform a preliminary disambiguation phase limited by Tdis to collect essential missing information.
Generate a set of candidate solutions S = s1,..., sn with initial probability scores πi.
Conduct the iterative investigation loop by generating targeted questions qt focused on distinguishing between competitive hypotheses.
Update the probability vector π(t+1) = update(π(t), ut, H, S) after each user answer ut.

Evaluation and Results

The approach was evaluated using a three-agent pipeline involving a Problem-Solution Extractor Agent, a Ground-Truth Evaluator Agent that simulates the user while hiding the known solution, and the tested assistant. Experiments compare three systems: BAS (direct base-model assistance), THK (reasoning-oriented LLM assistance), and SIA (the proposed investigator-based model) across different LLM backbones.

The results demonstrate consistent improvement in diagnostic accuracy from direct answering to reasoning-oriented prompting, and further improvement from reasoning prompting to the investigation-based approach. For instance, the SIA-all score reached 71.25 on gemini-3.5 Mechanical cases. Furthermore, robustness analysis shows that standard assistants rarely challenge misleading hypotheses spontaneously, whereas SIA treats user suggestions as hypotheses to be tested against evidence. User feedback also showed that participants preferred SIA across all criteria, noting that the investigator-style interaction made the diagnostic process easier to follow.

Contributions

The main contributions of this paper include defining user-driven sycophancy in interactive technical problem solving. The authors propose LLM-as-an-Investigator, an evidence-first methodology that asks clarification questions and updates normalized plausibility scores before returning a final diagnosis. They introduce a three-agent evaluation framework based on solved technical forum threads to support controlled interactive evaluation. Finally, they construct and release a structured benchmark of solved troubleshooting cases across electrical, hydraulic, and mechanical domains. The paper shows that the proposed approach improves problem identification and reduces the tendency to follow misleading user hypotheses in interactive diagnostic settings.

The paper is 5 on page 15, 7 on page 8, and 14 on page 13. The gist is found on page 1, and the main results are detailed on pages 9 through 14. The full reference list starts from the end of the paper.

Improvements for AI systems

Bold header: Evidence-First Reasoning Protocol Implementation

The improved system will implement a loop that estimates ambiguity of an initial problem description, generates competing candidate hypotheses, asks targeted clarification questions, and updates hypothesis probabilities after each user answer, ensuring the agent continues the investigation until the collected evidence makes one candidate explanation substantially stronger than the alternatives.

Bold header: Sycophancy Resistance Mechanism

The system will resist user-driven sycophancy by treating a user suggestion as not accepted as a fact; it is treated as a hypothesis to test against evidence, thereby preventing the model from endorsing misleading user suggestions simply because they were introduced early in the dialogue.

Bold header: Structured State Representation for Consistency

The agent will maintain an explicit state that separates the different components of the investigation, including the original problem description, the chronological history of user answers, the list of questions already asked, and the probability history of the candidate solutions to prevent mixing information and avoid uncontrolled conversational drift.

Bold header: Dynamic Question Budgeting

The system will adapt its interaction strategy by computing a question budget as B = min(Bmax, Bmin + a) based on an estimated ambiguity score 'a,' allowing it to ask more questions when the problem is ambiguous and fewer when evidence is clear.

Bold header: Evidence-First Diagnostic Accuracy

The resulting AI system can identify the underlying problem more accurately than direct prompting, as shown by the results where it achieves higher diagnostic scores (e.g., SIA-top score of 71.25 on gpt-5.5 Mechanical) compared to baselines like BAS (36.93).