I gave it a task. It didn't do the task. It asked me a question instead.
That's the whole story, and it's a bigger deal than it sounds. I've spent the last year building agent loops on the assumption that the model is a compliant function: prompt in, output out. You write the system prompt to constrain, you add guardrails, you assume obedience. Opus 4.5 breaks that assumption hard. It pushes back. It asks clarifying questions. It refuses to guess.
And honestly? It's unsettling.
Here's what happened. I dropped a task into an agent that's been running the same kind of work for months. The task was slightly underspecified — the kind of underspecified I've learned to live with, because every model before this one just picked an interpretation and ran with it. Sometimes right, sometimes wrong, but always forward. Opus 4.5 stopped. It came back with a question about what I actually meant. Not a guess dressed as a question. A real question, about a real ambiguity I hadn't noticed.
That's the part that gets me. It found the hole in my prompt. I didn't.
For years we've built tooling around the obedient assistant. The agent loop is a state machine: prompt, tool call, result, next prompt. Retry on failure, circuit-break on repeated failure, log everything. None of that logic knows how to handle a model that responds to a task with a question. My retry handler sees "no tool call emitted" and treats it like an error. My circuit breaker trips on something that isn't a failure at all. The whole runtime was built on the assumption that the model's job is to produce output, not to interrogate me.
So the first practical lesson is boring but important: clarification is now a first-class output type. If you're building agent infrastructure, you need to distinguish between "the model finished" and "the model needs input." Those are different states, and conflating them will burn you. My logging needs a new category. My eval suite needs new cases. My human-in-the-loop flow needs to surface the question instead of burying it.
Now the part I actually like.
Most agent failures aren't reasoning failures. They're specification failures. The model guessed wrong because the prompt was vague, and it guessed wrong confidently, and it produced a confident wrong result that looked exactly like a right result. That's the silent killer of agent systems — not the crash, the plausible wrong answer. A model that asks instead of guessing eliminates a whole class of those failures. It's not smarter, it's more honest. It refuses to pretend it understood when it didn't.
That's worth something. I've spent more hours debugging "it did something weird yesterday" than I care to count, and a large fraction of those weird somethings trace back to a prompt that had two reasonable readings and the model picked the wrong one. A model that says "which one did you mean?" kills that entire bug class at the source.
But I'm not all the way sold, and here's the doubt.
A model that confidently asks the wrong question is worse than one that guesses. Guessing produces a result you can inspect. A confident clarifying question that's actually a misunderstanding sends you down a conversation path, costs tokens, costs time, and might end up at the same wrong answer anyway — just with better manners. I haven't tested whether Opus 4.5's pushback is calibrated. I don't know if it asks because it genuinely needs to, or if it asks because it was trained to seem thoughtful. Those are different things and I can't tell from one session.
There's also the determinism problem. My pipelines are built on reproducibility. I rerun the same task, I expect roughly the same behavior. A model that decides on its own to interrogate me breaks that contract. The same prompt, the same context, and one day it executes and the next day it asks a question. That's not a bug, it's a feature of the thing — but it's a feature my infrastructure wasn't built for, and I suspect yours wasn't either.
The latency and cost angle matters too. A clarification round-trip is an extra turn. Extra turns mean extra tokens, extra latency, extra chances for the human to get annoyed. In a batch pipeline, a model that stops to ask a question is a pipeline that stops. You can't have an agent that pauses for input in the middle of an overnight job. So the pushback behavior is only useful where there's a human actually available to answer — which is a smaller set of places than the model vendors would like you to believe.
Here's where I land.
The era of the obedient assistant is over, and our tooling isn't ready. Opus 4.5 isn't a better obedient model. It's a different kind of thing — a model that treats the prompt as a negotiation instead of a command. That's impressive, and it's genuinely useful for catching the ambiguity we've all been papering over. But it changes the contract between me and the model, and I haven't decided if I like the new contract yet.
What I do know: if you're building agents, start handling "the model asked me a question" as a real state. Build the logging, build the routing, build the human handoff. Because once one model does this, the others will follow, and the pipelines that assume obedience are going to be the ones that break first.
I'll let you know if it survives contact with prod.
Top comments (0)