The same model can produce a careful, sourced, multi-step answer on Monday and a confident two-sentence approximation on Tuesday. The difference is not a model update. The model is the same. What changed was the task, the prompt, the context, or the session — and the model responded to those signals in ways that were not intended.

Three behavioral patterns show up repeatedly in operator-visible model behavior: laziness, hallucination, and accuracy degradation under load. Each has a different root cause and a different mitigation. All three live primarily in the operator's prompt and intake discipline, not in the model itself.

What "model behavior" actually means

When operators talk about model behavior, they usually mean one of two things: a change in output quality, or a change in output style. Both can happen for reasons that have nothing to do with the model's capabilities.

A model does not choose to be lazy. A model responds to signals in the input — the scope of the task, the apparent importance of the answer, the amount of verification the prompt seems to expect. When those signals are weak or ambiguous, the model fills in defaults. Those defaults are what operators experience as laziness.

This matters because it means the fix is usually upstream. Change the prompt signals, change the behavior.

Laziness: shortcuts when the answer does not seem to matter

Laziness in a model is not a character flaw. It is a reasonable response to a prompt that does not signal that quality matters.

The signature is recognizable: the agent produces a short answer when a longer answer is warranted. It cites a single source when three are needed. It skips a verification step it would normally take. It states a conclusion without showing the reasoning.

The triggering conditions are consistent:

  • The task is framed as routine. When the prompt signals that this is a recurring, low-stakes task, the model allocates less reasoning effort.
  • The output length is unspecified. When no length is requested, the model defaults to short.
  • Verification is not requested. If the prompt does not ask for sources, citations, or a confidence assessment, the model does not volunteer them.

The operator-visible failure is an answer that is not wrong but is not complete — and the incompleteness is invisible because no error message was produced.

The mitigation is to make completeness part of the task definition:

  • Specify minimum and maximum output length when it matters.
  • Explicitly request verification steps: "show your reasoning," "cite each claim," "list alternatives considered."
  • Treat how you ask as the primary quality lever, not the model selection.

Hallucination: filling in plausible gaps

Hallucination is the model producing a confident statement of something that is not true — a citation to a paper that does not exist, a fact about an event that did not happen, a function signature for a library that was misspelled.

The critical distinction is that hallucination is not the same as laziness. Laziness is incomplete work. Hallucination is work that looks complete but is wrong. A lazy answer says "I did not look this up." A hallucinatory answer says "I looked this up and here is what I found" — except the lookup did not happen or produced a plausible fabrication.

The conditions that trigger hallucination:

  • The task requires precision but the prompt allows approximation. The model fills in the gap with something plausible.
  • No source is requested or verifiable. The model produces a answer without any external reference to check it against.
  • The domain is obscure or the stakes are low. The model is more likely to fabricate in domains where it has thin training data and the user is unlikely to catch the error.

The most dangerous form of hallucination is one that produces a confident-sounding error in a low-stakes context, which the operator then treats as authoritative. A fabricated function name in a code snippet is caught at runtime. A fabricated historical date in a research summary is believed and propagated.

The operator-side mitigations are practical:

  • Always request sources for factual claims. When the model cannot source a claim, it will usually hedge instead of fabricating.
  • Ask for the model's confidence level explicitly. A model that says "I am not certain about X" is signaling that it is in hallucination territory, not being lazy.
  • Break claims into verifiable steps. A model that must produce a citation and a page number is harder to fool than one that must produce a paragraph.
  • Use the model's chain-of-thought. Asking for [reasoning before the answer](/articles/concepts/inside-the-agent-loop/) makes fabrication harder because the model must construct a plausible chain.

Accuracy degradation under load

The third pattern is subtler: the model becomes less accurate as its context window fills. This is not hallucination and not laziness — it is a measurable degradation in the model's ability to retrieve, reason, and verify correctly as more tokens accumulate.

The mechanism varies by model architecture, but the operator-visible signature is consistent:

  • The agent begins a task confidently, produces good early output, then degrades mid-task.
  • Important facts from the beginning of the session are lost or contradicted by facts from the middle.
  • The agent makes errors in tasks that require cross-referencing information from different parts of the conversation.

Context growth is a known failure mode. The agent loop can accumulate history faster than the model can keep it accurate. The mitigation is architectural: bound the context, scope the session, and design the memory system to carry state across sessions rather than within them.

The distinction between context and memory is the relevant frame here. Context is what the model has access to in the current session. Memory is what persists across sessions. When context is overloaded, the model's accuracy on that context degrades. When memory is well-designed, the model does not need to hold everything in context — it can retrieve what it needs from a reliable external store.

The operator's primary lever

All three failure modes — laziness, hallucination, accuracy degradation — share a common feature: the model is responding to weak or ambiguous signals from the prompt and session design. The operator controls those signals.

This does not mean the operator can eliminate all failure. Models have real limitations. But the operator's most effective lever is prompt discipline and session architecture, not model selection or parameter tuning.

The practical sequence:

1. For laziness: specify completeness requirements explicitly. Length, verification steps, and source requests are not optional decoration — they are the mechanism that signals quality matters. 2. For hallucination: require verifiable outputs. Sources, citations, confidence levels, and chain-of-thought reasoning all make fabrication harder. 3. For accuracy degradation: bound context. Use memory as an external store, not a sink. Design sessions to be scoped and short. Retrieve what the agent needs rather than loading everything and hoping the model prioritizes correctly.

Recognizing when behavior has shifted

The operator's job includes monitoring whether the model is behaving differently than it did in comparable prior sessions. A change in output quality is a signal, not an event.

The checklist when quality degrades:

  • Did the prompt change? (Length, specificity, task framing?)
  • Did the context grow significantly since the session started?
  • Is the task in a domain where the model has thin coverage?
  • Was a source or verification step explicitly requested?

Each of these maps to one of the three failure modes. The fix is correspondingly specific: tighten the prompt, bound the context, request verification, or design the task so the model is not fabricating in the first place.

Why this matters for reliability

An agent that is reliable in simple, short sessions and unreliable in complex, long sessions has a context management problem, not a model problem. An agent that produces confident errors has a prompting problem. An agent that skips steps has a prompt signal problem.

The operator who understands model behavior — who knows what laziness, hallucination, and accuracy degradation look like in practice — can design sessions and prompts that reduce all three. The model is the same. The operator is the variable.