The agent failure modes nobody warns you about

When you read about AI agents, you read about the wins. Demo videos. Customer success stories. Saved hours and dollar amounts.

What you rarely read about: the specific ways agents fail in production, even when configured carefully.

We've watched a lot of agents in production. Including our own. Including our customers'. Here are the failure modes we see consistently — and what to do about each one.

Failure mode 1: Silent quality drift

What it looks like: The agent worked well for the first 4-6 weeks. Then output quality slowly degrades. No one notices for a while because there's no specific failure event.

Why it happens: Real-world inputs slowly diverge from the configuration assumptions. New types of inquiries, new edge cases, new product features the agent wasn't trained on. The drift is gradual.

How to catch it: Periodic sampling. Pick 10-20 recent agent outputs every week. Have a human reviewer rate them. Track the rating over time. Drift shows up as a slow decline in the rating.

How Avery NXR helps: The audit ledger captures every output. Sampling is straightforward — query the ledger, pull recent entries, review. We've added a "quality check" capability that you can schedule weekly to surface samples to a reviewer.

Failure mode 2: Confident wrongness

What it looks like: Agent produces an output that's confidently presented but factually wrong. Because it's confident, the human reader doesn't second-guess it.

Why it happens: LLMs are calibrated for fluency, not accuracy. When uncertain, they often produce plausible-sounding answers rather than expressing uncertainty.

How to catch it: Spot-check claims that have specific facts (numbers, names, dates, attributions). When the agent says "X person said Y," verify Y was actually said. When the agent says "the data shows Z," verify Z is in the data.

How Avery NXR helps: We've added confidence scoring to agent outputs by default. Agents flag low-confidence outputs explicitly. Reviewers can prioritize those for verification.

Failure mode 3: The cascading misclassification

What it looks like: Agent misclassifies a single input early in a workflow. Subsequent steps process based on the wrong classification. The output is technically correct given the misclassification — but the original classification was wrong.

Why it happens: Multi-step agents propagate errors. The error gets harder to detect downstream because the agent is doing the "right" thing given the wrong starting point.

How to catch it: Test agents on edge cases of classification, not just typical cases. Have a human review classifications periodically. Notice when downstream actions feel wrong — that's often a classification problem one step back.

How Avery NXR helps: The audit ledger captures each step separately. When something looks wrong, you can trace back to find where the chain broke. Sub-agent boundaries make this even cleaner.

Failure mode 4: The configuration drift

What it looks like: Agent worked well at setup. Over time, the underlying systems change — new data fields in CRM, new email categories, updated knowledge base — and the agent doesn't notice. Configuration becomes stale.

Why it happens: Agents don't auto-update their configurations when their data sources change. Drift is invisible until something breaks visibly.

How to catch it: Periodic configuration reviews. Once a quarter, walk through each agent's configuration and check it still matches reality. Update prompts, refresh KB references, validate connector permissions.

How Avery NXR helps: We've started building configuration health checks that surface when an agent's KB hasn't been updated in N days or when its CRM field references look stale. Not perfect but catches the common cases.

Failure mode 5: The cost surprise (on cloud-LLM agents)

What it looks like: Agent works well for a month. Then a usage spike (new product launch, viral moment, seasonal increase) triggers agent volume that wasn't anticipated. Cloud-LLM bill jumps 5-10x. CFO asks why.

Why it happens: Cloud-LLM costs scale with usage. Many teams budget based on average usage. Spikes break the budget.

How to catch it: Set up cost alerting on cloud-LLM platform. Build models that predict cost based on activity volume. Have a budget conversation with whoever owns the spend.

How Avery NXR helps: This is the one failure mode local-first solves architecturally. Marginal cost of local agent execution is effectively zero. Spikes don't trigger bills. The whole failure mode is engineered out.

Failure mode 6: The "feature creep" agent

What it looks like: Started as a simple agent doing one thing. Over time, requests added: "can it also do X?" → yes → "and also Y?" → yes → "and also Z?" → yes. Eventually it's doing five things, all of them less well.

Why it happens: Configurations are easy to extend. Each extension feels small. The cumulative weight degrades quality.

How to catch it: Once a quarter, look at each agent and ask "is this still doing one thing well?" If not, split it into multiple agents. Resist the temptation to make one agent do everything.

How Avery NXR helps: Sub-agent capability makes splitting cheap. You can take one bloated agent and refactor it into a coordinator + several specialists. The agents talk to each other via agent-to-agent triggers.

Failure mode 7: The unreviewed exception

What it looks like: Agent has a clear happy path and a fallback for exceptions. The fallback gets used. Nobody reviews what the fallback did. Issues compound silently.

Why it happens: Reviewers focus on the happy path. Fallbacks feel like "the system handled it." Sometimes the fallback handled it poorly.

How to catch it: Separate metric for fallback frequency. If the fallback is firing more than expected, investigate. Each fallback execution should land in a review queue, not the success bucket.

How Avery NXR helps: The audit ledger distinguishes successful flow vs. exception flow. You can query for exception executions specifically.

Failure mode 8: The "looks correct" but missed context

What it looks like: Agent produces an output that looks reasonable in isolation. In context, it's the wrong response — but context is something the agent didn't have access to.

(We covered a specific example of this in [post 173] — the agent that drafted a response to a sensitive investor email without knowing the strategic context.)

Why it happens: Context lives in human heads or in places the agent can't read. The agent doesn't know what it doesn't know.

How to catch it: Design agents to defer rather than confidently act on ambiguous high-stakes inputs. Use confidence levels. Build review gates for the high-stakes cases.

How Avery NXR helps: Default "draft for human review" rather than "send automatically." Confidence scoring. The architecture for high-stakes work involves humans by default.

Failure mode 9: The unintended privacy leak

What it looks like: Agent processes data that includes PII or sensitive information. The agent's output reveals more than intended — names appear in summaries that should have been anonymized, customer details show up in shared dashboards.

Why it happens: PII handling isn't automatic. Agents handle what they're given. If the configuration doesn't redact, the output won't either.

How to catch it: Audit agent outputs specifically for PII leakage. Use redaction tools at the data ingestion layer. Make redaction the default, not opt-in.

How Avery NXR helps: PII redaction in audit ledger is on by default. We've added PII detection capabilities to agent outputs to flag potential leakage. Local processing also means leakage stays inside your infrastructure even if it happens.

Failure mode 10: The agent that's just... worse than before

What it looks like: Process worked fine before automation. Agent automated it. Output is technically faster but qualitatively worse. Customers / coworkers / users prefer the pre-agent version.

Why it happens: Not every workflow benefits from automation. Some processes work BECAUSE they involve humans paying attention. Removing the human reduces quality even when the AI output is "good enough" on average.

How to catch it: Talk to the people affected by the agent's output. Ask "was this better or worse than before?" Listen to qualitative feedback.

How Avery NXR helps: No specific feature. This is a judgment call we coach customers on. Sometimes the right answer is to retire an agent, not to "fix" it.

The general lesson

Agents fail. Not just at first — at any point. The teams that get long-term value from agents are the ones that:

→ Build review and sampling into the workflow → Treat agents as software that needs maintenance, not "set and forget" → Accept that some agents will be retired → Architect for safety from day 1 → Use audit transparency as a tool, not just a feature

This is what reliable production AI looks like in 2026. It's less glamorous than the demo videos. It's also what actually works.

→ avery.software — Free Desktop tier. The platform that takes failure modes seriously.