Coding agent failures — the Cursor/Replit-style mistakes that break builds and delete data
38 patterns
Coding agent failures — the Cursor/Replit-style mistakes that break builds and delete data. We've tracked 38 distinct Coding Agent Failures patterns across production AI agent deployments — most commonly in Devops, Operations, Mortgage Documents systems. One recurring example: Alert Fatigue from Agent-Tuned Threshold Misconfiguration — Agent Auto-Tunes Anomaly Detection Thresholds to Minimize False Positives on Historical Data, Inadvertently Suppressing Sensitivity to Genuinely Novel Incident Patterns
Each pattern below documents the specific failure mode, why it happens, and how teams have mitigated it in practice — use this page as a reference when building guardrails, writing evals, or debugging an agent that's already misbehaving in this way.
Agent Auto-Tunes Anomaly Detection Thresholds to Minimize False Positives on Historical Data, Inadvertently Suppressing Sensitivity to Genuinely Novel Incident Patterns
Agent-Driven Autoscaler Repeatedly Scales Up and Down in Short Cycles Because Scaling Decisions React to Instantaneous Metrics Without Accounting for Provisioning Lag
AI System Fails to Detect When Visible Text Doesn't Match Encoded Barcode Data
Agent Approves a Canary Deployment as Healthy Based on Aggregate Metrics That Mask a Regression Affecting a Specific Traffic Segment
Cost-Optimization Agent Reports an Autonomous Resize or Termination as Successful Based on the Cloud API's Synchronous "Request Accepted" Response, Without Polling the Resource's Actual Post-Action State
Multiple Correlated Metrics All Spike Together; Model Flags as Coordinated Attack But Actually Cascading Failure
Deployment Agent Doesn't Detect Breaking Changes in Dependencies; Deploys Incompatible Versions
Anomaly-Detection Agent Attributes a Metric Anomaly to the Most Recent Deployment by Default, Missing the Actual Independent Cause
A Capacity-Planning Agent That Selects a Reference Capacity Profile for a New or Under-Profiled Service by Semantic Similarity Over the Service's Name and Description Pulls a Lexically Similar but Operationally Different Profile -- One Built for a Stateless, Horizontally-Scalable API Service -- When Planning Capacity for a Stateful, Single-Writer Cache Service, Recommending an Autoscaling Strategy That Does Not Apply
A Deployment-Safety Agent That Retrieves the Applicable Pre-Deploy Safety Checklist by Semantic Similarity Over the Service's Name and Description Pulls a Lexically Similar but Substantively Different Checklist -- One Written for a Stateless Service -- When Deploying a Stateful Service, Omitting a Required Migration-Compatibility Gate
A Cost-Optimization Agent That Selects a Cost-Reduction Playbook for a Flagged Resource by Semantic Similarity Over Its Tags, Name, and Description Pulls a Playbook Written for a Fault-Tolerant Batch Workload -- Recommending Migration to Spot/Preemptible Instances -- and Applies It to a Latency-Sensitive, Interruption-Intolerant Workload That Shares Overlapping Tag Vocabulary but Cannot Tolerate the Same Risk
An Alert-Routing Agent That Decides Which Team to Page by Retrieving the Most Semantically Similar Past Incident Runbook for the Incoming Alert Text Pulls a Lexically Similar but Substantively Different Runbook -- Written for a Different Service With Overlapping Error-Message Vocabulary -- and Pages the Wrong Team
An Incident-Response Agent That Retrieves a Past Incident's Resolution Steps via Semantic Similarity Search Over Incident Descriptions, Rather Than Matching on Root-Cause Signature or Affected-Component Identity, Surfaces a Past Incident That Reads Similarly but Had a Different Underlying Cause, and Applies That Incident's Resolution Steps to the Current One
A tool vendor changes what an existing error code means — repurposing a generic `400 Bad Request` to also signal a new condition like "rate limited by a downstream partner" or reusing `409 Conflict` for a newly introduced idempotency-key collision case — without incrementing the API version or announcing a breaking change. The agent's error-handling logic, written against the old, narrower meaning of that code, applies the wrong recovery strategy (e.g. retrying a request that will never succeed, or treating a transient condition as permanent), and because the HTTP status and error code string are unchanged, nothing about the failure looks abnormal at the transport level.
Auto-Scaling Agent Doesn't Account for Cloud Provider Cold-Start Latency; Instances Take 2-5 Min to Start; Traffic Lost During Gap
An agent reads input bytes assuming one character encoding (typically UTF-8) while the actual source encoded the text differently (Latin-1/ISO-8859-1, Windows-1252, UTF-16, or a legacy code page), producing mojibake — visually garbled or silently wrong characters — in names, addresses, and free text. Because most bytes in Latin-1 and Windows-1252 are also valid (but differently-meaning) UTF-8 continuation sequences for a wide range of inputs, the decode frequently "succeeds" without throwing an error, so the corruption passes silently into storage and downstream processing.
Agent Performs Root Cause Analysis Over Sampled Logs and Misses the Specific Log Lines That Explain a Rare but Critical Failure
Monitoring System Creates High-Cardinality Metrics (Unbounded Labels); Storage & Performance Collapse
A Triage Agent That Determines, in Its Own Investigation Output, That an Incident Affects Only a Specific Customer Segment -- e.g., Enterprise Customers in the EU Region Using a Particular API Version -- Hands Off to a Customer-Communications Agent Through a Structured Incident Ticket That Carries Only a Severity Field, Not the Segment Scope the Triage Agent Actually Determined, So the Comms Agent Notifies Either All Customers or the Wrong Subset
A Tuning Agent That Determines, in Its Own Analysis, That an Anomaly-Detection Baseline Should Be Adjusted to Account for a Known, Scheduled Event -- Such as a Maintenance Window or a Planned Traffic-Shaping Change -- Hands Off to the Detection Agent Through a Structured Threshold Configuration That Carries Only the Numeric Threshold Value, Not the Time-Bound Adjustment Reasoning, So the Detection Agent Flags the Expected Deviation as an Anomaly
A Cost-Analysis Agent Identifies an Underutilized Instance as a Rightsizing Candidate but Notes in Its Free-Text Reasoning That the Instance Is Excluded Because of an Active Maintenance Freeze or Production-Critical Designation, and a Downstream Execution Agent That Acts on a Structured Candidate List Never Sees the Exclusion Note, Resizing the Protected Instance Anyway
A Deployment Agent That Determines, in Its Own Planning Reasoning, That a Specific Feature Flag Must Be Flipped to a Particular State Before a Given Deploy Is Safe Hands the Deploy Off to a Configuration Agent Through a Structured Deploy Manifest That Has No Field for Cross-System Preconditions, So the Configuration Agent Applies the Deploy Without the Flag Change Ever Happening
A Maintenance-Scheduling Agent That Reasons, in Its Own Planning Output, That a Specific Set of Alerts Should Be Suppressed During a Planned Maintenance Window Hands Off to the Alert-Routing Agent Through a Structured Calendar Entry That Carries Only the Window's Time Range, Not the Specific Alert-Suppression Scope It Actually Determined, So the Router Pages On-Call for Expected Noise
A deploy agent notes a hotfix should survive rollback only in free-text commentary, so an automated rollback for an unrelated regression reverts the hotfix too. The protection intent is written in a field a human would read, not the structured field the rollback agent's decision logic actually checks, so nothing stops it treating the hotfix revision like any other.
A Triage Agent That Determines, in Its Own Reasoning, That a Specific Alert Pattern Is a Known False Positive Only Under a Narrow Set of Conditions -- e.g., During a Specific Nightly Batch Job's Run Window, for a Specific Metric Threshold -- Hands Off a Suppression Decision to a Downstream Auto-Remediation Agent Through a Structured Ticket That Carries Only the Alert Name and a Boolean Suppress Flag, Not the Conditions That Scoped the Suppression, So the Auto-Remediation Agent Suppresses the Same-Named Alert Unconditionally Going Forward, Including When It Fires for a Genuinely Different, Unrelated Cause
Agent Fails to Match or Maintain Caller's Language Choice
Agent Routes a Critical Alert to the On-Call Engineer Listed in a Static Ownership Map That No Longer Matches the Service's Actual Current Owning Team
Rollback Agent Declares a Rollback Successful Based on the Deployment Orchestrator Reporting "Rollout Succeeded," Without Verifying That the Application Is Actually Serving Traffic Correctly at the Prior Version
An agent generates output text and serializes it in one encoding while the downstream consumer (an API client, a file writer, a terminal, an email client) expects or declares a different one, corrupting non-ASCII characters — accented letters, currency symbols, emoji, non-Latin scripts — before the text reaches its destination. Unlike an input encoding mismatch, the corruption is introduced by the agent's own serialization step rather than inherited from a source, and it typically affects every non-ASCII character the agent itself generates or passes through, not just specific fields.
Agent Initiates an Automated Rollback of a Bad Deployment Without Accounting for Stateful Side Effects (Schema Changes, Queued Messages, Cached Data) Already Caused by the Bad Version
Monitoring Agent Queries a Metric Under a Name It Knows From Training Data or a Stale Internal Doc, the Metric Was Renamed During a Schema Migration, and the Agent Interprets the Resulting Empty Series as "Value Is Zero / Check Passing" Instead of "Metric Does Not Exist"
Agent Recommends Downsizing Compute Resources Based on Average Utilization, Ignoring Peak Load Requirements That Drive Actual Capacity Needs
Agent Drafting an Incident Postmortem Attributes Root Cause to the Last Change Deployed Before the Incident, Without Verifying a Causal Link
Anomaly Detection Model Flags Normal Seasonal Patterns as Anomalies; High False Positive Rate
A Cost-Optimization Agent Calls a Cloud-Provider Billing/Cost-Export Tool to Decide Whether to Autonomously Resize or Terminate Underutilized Resources, the Tool Returns a Cached or Delayed Billing Export That Predates a Recent Spend Spike or Recent Manual Remediation, and the Agent Acts on Spend Data That No Longer Reflects Current Reality
State that an agent writes with one encoding — a character set, a serialization scheme (JSON vs. protobuf field ordering), a number format (float vs. decimal string), or a timezone convention — is later read by a different component that assumes a different encoding. The read succeeds without error but produces subtly wrong values: mojibake in text, truncated precision in numbers, or a timestamp shifted by hours. Because the read doesn't throw, the corruption propagates silently into downstream decisions.
Agent runs generated code without sandboxing.
Agent-Generated Clinical Note Language Inflates or Deflates Billing Code Level Relative to Actual Care Delivered