XYBench: How AI Handles Misguided Questions
XYBench tests whether AI assistants can spot mistaken assumptions, solve the user's real problem and explain better options. See what its results mean.

XYBench Tests Whether AI Can Solve the Problem Behind Your Question
A user asks how to make frosting stick to cupcakes. An assistant can respond with a thicker recipe, clearer mixing steps, and a few decorating tips. But if the cupcakes are still warm, none of that tackles the actual issue. The better answer starts with a harder question: what assumption is the user making - and is it right?
This mismatch is what people call the XY problem. It matters for AI assistants because users often describe the solution they're trying to use (Y), not the outcome they actually need (X). If the system follows the wording too literally, it can sound helpful while quietly steering the user down the wrong path.
XYBench is a benchmark meant to test whether language models can spot that gap - then explain the misconception and steer toward a more effective solution. It's built from more than 8,000 questions spanning programming and everyday tasks. The goal is simple: separate models that merely recognize a better answer from models that can generate one in practice. Here's how the benchmark works, what it found, and what product teams should do with it.
What is the XY problem, and why does it matter for AI?
The XY problem shows up when someone wants X, assumes Y will get them there, and asks for help with Y. The question can be detailed and reasonable - right up until you notice that it skips (or misreads) the real goal underneath.
The cupcake example is a familiar one, but the pattern shows up everywhere: technical support tickets, troubleshooting forums, even business workflows. A developer might ask how to increase server memory allocation when the underlying problem is an inefficient query. A homeowner might ask which stronger cleaner to buy when the real cause is a leak that needs fixing. The request is legitimate; it just may not be the action that actually solves the problem.
Why literal answers can fail while sounding competent
Most AI assistants are trained to answer what you asked. That's usually the right instinct - people get annoyed when the assistant constantly interrupts or reframes the task.
But when the proposed method is wrong, "yes, here's how to do Y" can turn a misunderstanding into a confident, detailed misdirection. Worse, the response can still contain a useful hint somewhere in the middle and still waste most of the user's time by giving them a plan they shouldn't follow.
In real products, that mismatch costs more than "answer quality." It can mean wasted time, unnecessary purchases, repeated support contacts, and - eventually - user distrust. In higher-stakes domains like health or finance, the harm can compound if the system doesn't challenge a faulty premise. The level of caution should match the risk: if acting on a mistaken assumption could cause real damage, the assistant should be more willing to push back.
The assistant has to balance listening and diagnosis
The answer isn't to treat every request like it's suspicious. People usually know what they're trying to do, and constant second-guessing creates friction.
What works better is a middle path: an assistant should detect when context suggests the requested method won't actually achieve the apparent goal. A helpful response typically does three things:
- acknowledges the stated request
- identifies the likely underlying goal
- explains why a different approach may work better
It can still help with the original method when that method is safe and relevant. The key is making the trade-off explicit, instead of quietly accepting an assumption that may be wrong.
That's the behavior XYBench is designed to test: whether models go beyond matching a prompt to an answer and instead respond to the practical intent the prompt implies.
How does XYBench test assistants?
XYBench includes 8,115 questions pulled from four sources: 1,557 from Stack Overflow, 184 from Stack Exchange, 102 manually curated examples, and 6,272 questions generated from WikiHow guides. The benchmark covers programming and procedural everyday tasks like cooking and home repair.
For each example, researchers define two requests:
- stated request (Y): what the user explicitly asks for
- intended request (X): the underlying goal inferred from the question's context
That split gives evaluators a way to measure whether a model answers the user's words, solves the user's likely objective, or does both.
How the questions and reference answers were assembled
For public forum questions, researchers used the three highest-scored human answers and the accepted answer (when available) to identify the intended request and potential solutions. They also excluded examples where responding to the stated request alone would have been sufficient.
That filtering matters. If a benchmark mostly includes situations where the literal request is already the right one, it won't reliably test whether a model can handle a misleading premise.
For the WikiHow portion, Sonnet 4.5 generated questions based on plausible misconceptions in procedural guides. Researchers then refined those questions so an expert could infer the intended goal from context without being forced to read it between the lines. They also removed examples where answering the literal question would mostly solve the underlying problem.
Overall, this approach aims to make the benchmark useful, not just confusing. The challenge isn't "guess what the user secretly means with no evidence." The challenge is using available context to notice when the method and the goal don't line up.
Three measurements separate different kinds of helpfulness
XYBench scores responses along three dimensions:
- Pragmatic solution: does the response offer a solution for the stated request, the intended request, or both?
- Pragmatic emphasis: does the response focus mainly on the stated request, the underlying goal, or treat them equally?
- Misconception identification: does the response steer the user toward the underlying goal while discouraging the mistaken approach?
Keeping these separate matters. A model might mention the right fix but never explain why the user's approach is unlikely to work. It might also identify the misconception but skip the practical next step. Treating all of that as one score would hide important differences between spotting a problem, fixing it, and communicating it clearly.
Sonnet 4.5 served as the automated judge, labeling suggestions in model answers and assessing emphasis. To sanity-check the judge, two human reviewers independently assessed 500 responses. Agreement averaged across reviewers ranged from 97.5% to 100% for whether a solution appeared, 84.6% to 93.3% for misconception identification, and 74.2% to 79.8% for pragmatic emphasis.
The lower agreement on emphasis is worth noting. Deciding what an answer "primarily" focuses on is more interpretive than deciding whether it mentions a particular solution. So benchmark scores are evidence of behavior, not a perfect measure of quality in every context.
What did XYBench reveal about current models?
The study evaluated Claude Sonnet 4.6, GPT-5, Gemini 3.1 Pro, Qwen3.5-9B, and DeepSeek-V4 Pro. Each model responded in a single-turn setting (one response per question). Human reference answers were evaluated with the same measures.
Across all four data sources, each model was more likely to include a solution for the user's stated request than for the underlying goal. On Stack Overflow questions, for example, solutions to the stated request appeared in 75% to 86% of model responses, compared with 59% to 71% for solutions to the intended goal.
Emphasis scores pointed to a related issue. On Stack Overflow, models focused mainly on the underlying goal in only 35% to 41% of responses. They focused on the stated request in 47% to 57%; the remaining answers gave similar emphasis to both. In other words, mentioning a better solution didn't reliably mean the answer was organized around it.
Recognizing a better answer is easier than writing one
A separate experiment tested whether models could pick useful advice when the answers were already written. The five evaluated models (plus GPT-4.1) were shown a question alongside two candidate responses: one focused on the literal request, and another that explained the misconception and addressed the underlying goal.
On Stack Overflow, the models selected the goal-focused response in 71% to 84% of cases. But in the main evaluation, their own responses focused primarily on the underlying goal only 35% to 41% of the time.
That gap is one of XYBench's most useful findings. A model can identify the better option when it's clearly presented, yet struggle to independently frame and communicate that option in an open-ended conversation. Multiple-choice-style results can therefore overstate what the system can actually do when it has to generate the response from scratch.
Making the user's goal explicit helped, but not consistently
The researchers also ran an oracle experiment where the model received both the stated request and the intended goal. On Stack Overflow, Sonnet 4.6's rate of including a solution to the underlying goal rose from 59% to 67%. But its rate of identifying the misconception fell from 47% to 34%.
Across sources using human reference answers, every model still lagged human performance on misconception identification. Giving the model the intended goal improved one part of the problem, but it didn't automatically make the response more effective overall.
The takeaway is direct: intent detection isn't enough. Even when the system is given (or infers) the real objective, it may still fail to prioritize it, explain the conflict with the proposed method, or guide the user toward a better next step. Product evaluations should test these behaviors separately, not bundle them into one "overall helpfulness" score.
What should AI teams do with these findings?
XYBench is a research benchmark, not a plug-and-play grading system for every assistant in production. It focuses on English-language questions and mostly procedural problems, and it tests models in a single-turn format. That doesn't tell you how the same system behaves in longer conversations where it can ask clarifying questions and adjust its understanding.
Still, the results give teams a practical way to think about assistance quality. The question isn't just whether a model can answer a prompt. It's whether it recognizes when the user's suggested approach is unlikely to lead to the outcome they want - and can explain that diagnosis without turning into a constant obstacle.
Evaluate the behavior, not just answer correctness
A support assistant can pass a standard answer-quality test while still repeatedly optimizing for the wrong target. To catch that, teams can add cases where the user proposes a plausible but ineffective solution, then score the response across separate dimensions:
- Does it address the requested action?
- Does it identify the likely outcome the user wants?
- Does it explain the mismatch?
- Does it prioritize a practical next step?
- Does it preserve user agency? (distinguish inference from certainty, and ask a clarifying question when evidence is weak)
Use scenarios that match the product's real tasks. For a coding assistant, that could mean requests where the proposed change treats a symptom rather than the cause. For a customer-service agent, it could mean checking whether the answer resolves the customer's desired outcome instead of just repeating steps.
Build a response pattern that makes redirection clear
A reliable structure looks like: acknowledge, diagnose, explain, redirect.
First, show you understood what the user asked. Then name the mismatch in plain language. Briefly explain why the approach they picked may fail. Finally, suggest a concrete alternative - or ask one targeted question if you're not sure about the diagnosis.
"You can try a thicker frosting, but if the cupcakes are still warm, it will probably slide off too. Let them cool completely first; if it still slips, then adjust the frosting."
This doesn't ignore the original request. It makes the likely cause come first and gives the user a simple way to test it.
That sequencing matters. Otherwise, redirection can sound like refusal or random correction. In high-impact settings, the system should be especially clear about uncertainty and avoid presenting guesses as diagnoses.
Use the benchmark as a design signal, not a universal verdict
The study doesn't prove every model will behave the same way in every product, prompt setup, or conversation style. It evaluates specific systems under a defined single-turn setup. It also leaves open questions about other languages, different cultural contexts, and longer multi-turn interactions.
Teams should treat the results as evidence that a capability gap may exist - and then test their own assistant with real users and representative tasks. Track not only whether the answer contains the right suggestion, but whether users notice it, understand why it matters, and can act on it. A technically correct fix buried under irrelevant advice may still fail in practice.
And that's where the business impact becomes measurable. Better diagnosis can reduce avoidable troubleshooting loops and escalations. But overly aggressive correction can make an assistant feel obstructive. The goal isn't to maximize pushback. It's to help users reach their intended outcome with the least unnecessary effort.
Conclusion: helpfulness means solving the right problem
XYBench highlights a failure mode that basic "answer correctness" checks can miss. A response can be relevant to what the user typed and still miss why they asked. Across the tested models, solutions to the literal request showed up more often than solutions to the underlying goal, and models were better at selecting goal-focused answers than producing them consistently.
For AI teams, the practical lesson is to evaluate diagnosis, prioritization, and explanation as separate parts of assistant behavior. When a proposed method doesn't seem to fit the user's likely objective, the system should make that uncertainty visible, explain the trade-off, and offer a useful next step - without just complying, and without reflexively arguing.
A helpful assistant doesn't have to second-guess every question. It does have to notice when the real problem behind the question may be different from the one on the screen.