The Agent Won't Ask Why

The shift that matters with agents this year isn't that they read. It's that they write.

Codex, Claude Code, Claude Cowork. These don't hand you a draft you then have to slot into your workflow yourself. They go into the workflow and change it. That's the seismic line. Crossing it is going to expose a problem most product operations teams haven't built the framework for.

Six Months to Where the Bodies Are Buried

When I joined Experian, people told me the first few months would be drinking from a fire hose. That part I believed. The part that stuck: it would take about six months before I'd really understand where the bodies were buried — which infra was owned by whom, which decisions were political, which dependencies weren't written down because everyone close to the work already knew.

That timeline isn't an intelligence problem and it isn't a complexity problem. It's a context problem. You can read every doc and still spend half a year learning what the team already knows.

That same timeline is what individuals and enterprises are about to hit when they build agentic systems. Except faster, more visible, and more expensive.

Humans Get Judgment. Agents Get Prediction.

People ramp into responsibility. They get told things, they make decisions, they get corrected, and across that loop they build a skill that doesn't get named often enough: knowing when to act versus when to stop and ask for more information. The ramp produces judgment.

Agents don't operate on that framework. They predict.

That's the whole mechanism worth naming. The agent uses what you give it, and predicts forward from there. If the context is thin, it makes logic leaps to cover the gap. If the context is rich but unorganized, it infers connections between things that don't actually belong together. Square peg, round hole. Either direction, the result is the same. The agent writes its prediction into your workflow as if it were certain.

This isn't the chatbot hallucination problem dressed up. It's a context problem. The model behaved as designed given what it was handed. The mistake is upstream — in the shape and density and accuracy of what the agent was working from.

Two Failure Modes of a Prediction Machine

Two flavors of upstream mistake show up over and over.

Not enough context. Even with the full repo and the full wiki, the connective tissue is missing. Who owns this service. Which decision is in flight. Which thread settled the last argument about the schema. The agent fills the gap with a plausible-sounding default and ships it.

Too much context, badly organized. This is the failure mode the new enterprise connectors created. Copilot and ChatGPT now reach into your corpus, which sounds promising until you realize there's no real knowledge graph underneath, no semantic relationships, no curated wiki. The connector behaves like a glorified keyword search, dragging in adjacent documents that aren't actually related, and the model dutifully averages across them.

Both modes land the same way. The agent invents a relationship that isn't there, or mixes context that should never have been touching, and writes the result into your system.

Asking Is a Product Decision

By default, agents don't pause for clarification. They run forward on the context they have, because that's what they're built to do. Asking is a product decision. Scope it to the kinds of work where the cost of guessing exceeds the friction of stopping. Decide who the agent asks and how. Accept that the asking itself becomes part of the workflow the agent was supposed to remove. None of that is free. All of it is cheaper than the cleanup.

That's a framework question, not a feature question. And it's the framework product operations teams should be building for 2026. The layer above any individual agentic feature that says where prediction is allowed, where pausing is required, and how the asking gets back to a human in time to matter.

What You're Designing For

Your agent won't ask why on its own. It uses what you give it, predicts forward, and writes the result into the system. The work for product operations is two-sided: shaping the context the agent operates on, and designing the moments where the agent has to stop.

What's the part of your team's work where a confident wrong answer would cost most, and how does the agent know to pause there?