Anthropic’s “Elevated errors on claude.ai, Claude Code, and platform.claude.com” incident on 2026-11-13 should bound your investigation, not close it. Attribute failures run by run: error-rate and latency spikes across many runs during the incident window point toward a provider-side cause, while failures confined to a tool or deterministic code step point toward your stack. Missing or partial traces support no verdict.
That taxonomy is an inference from LangSmith’s documented telemetry capabilities, not an independently tested attribution method. Its practical consequence is uncomfortable but useful: if you did not capture usable evidence before the incident, the status page cannot supply it afterward.
A status page defines the window, not the culprit
Anthropic’s incident entry is vendor-reported and component-level. It states: “This incident affected: claude.ai, Claude Console (platform.claude.com), Claude Code, and Claude Cowork.” That establishes which Claude surfaces Anthropic associated with the incident. It does not establish that every request to those surfaces failed, or that a particular agent run failed because of Claude rather than because of its own code or a downstream tool.
The incident page posts a full timeline. Anthropic opened with Investigating at 09:58 UTC on Nov 13, 2026, moved to Monitoring at 11:05 UTC, and marked the incident Resolved at 11:58 UTC, bounding the provider-reported window to about two hours. The investigating update describes “an issue with users authenticating to Claude.ai and Claude Code,” which is narrower than the incident title’s “Elevated errors” and worth matching against your own failure signatures. Confirm the timestamps on the live page before quoting exact times in a postmortem.
This distinction matters because a postmortem and an SLA conversation require different evidence from a status update. “Anthropic reported an incident while our agent was failing” is a supportable statement when the timing is confirmed. “Anthropic caused these failed runs” requires run-level evidence and consideration of alternative causes.
Step 0: prove trace coverage before you need it
LangGraph workflows combine shared state, nodes and edges, mixing deterministic steps with LLM-driven steps, according to the LangGraph overview. One failed run can therefore contain both provider-domain and code-domain failure points. Tracing the graph is valuable precisely because it can preserve that sequence rather than reducing the run to a final exception.
The coverage rules are vendor-doc-sourced and have an important boundary:
- The LangGraph tracing documentation says LangSmith integrates with LangGraph in Python and JavaScript, whether agents use LangChain modules or other SDKs.
- The same page says other SDKs and custom functions must be wrapped or decorated appropriately for their traces to nest automatically. It names
@traceablein Python,traceablein JavaScript, andwrap_openaias an SDK example. - The LangSmith observability page says applications built with the Anthropic SDK can be traced, alongside OpenAI SDK, Vercel AI SDK, LlamaIndex and custom implementations.
“Supports the Anthropic SDK” is therefore not proof that every Anthropic call inside your graph is already visible. Nor should wrap_openai be read as an Anthropic-specific wrapper merely because the documentation offers it as an example.
For a mixed-framework agent, I would make the preflight concrete: run a path that includes the Anthropic SDK call and each custom tool, then confirm that their spans appear where you expect within the larger trace. That inspection is a recommended verification practice, not a tested result from the documentation. If a call is absent or disconnected, adding an aggregate error dashboard will not recover the missing step-level evidence.
The LangChain tracing documentation also describes distributed tracing that links runs across services and agents. That documented capability matters when an apparent agent failure crosses a service boundary: the failing component may not be the service that ultimately returned an error to the user.
Read failure signatures, not just the incident headline
LangSmith’s observability documentation says custom dashboards track error rates and P50/P99 latency, as well as token usage, cost breakdowns and feedback scores. Alerts can be sent through webhooks or PagerDuty when metrics cross thresholds. P50 describes the median latency; P99 exposes the slower tail. Those metrics can show that conditions changed, but they do not identify a root cause by themselves.
The useful comparison is scope and location. Did errors rise across many runs in the confirmed incident window, alongside worsening latency? Or did model calls remain healthy while one tool or deterministic node failed repeatedly? A common pattern across runs is consistent with a shared provider condition. A step-local pattern is consistent with a code or tool problem. Neither pattern is conclusive without examining the affected runs.
There is also a documentation gap in the workflow itself. The LangSmith documentation establishes dashboards and trace capture, but not time-window filtering. Treat “filter traces to the outage window” as a step to verify in your current workspace and current documentation, not as a guaranteed click path. Restrict your conclusions to runs you can actually place within the confirmed window using the tooling available to you.
A signature-to-failure-class taxonomy
The table below is an attribution heuristic assembled from the documented metrics and tracing boundaries. It is not a LangSmith-provided diagnosis engine or a universal protocol rule.
| Observed signature | Most defensible classification | What still needs checking |
|---|---|---|
| Error rates and P50/P99 latency rise across many runs within the confirmed provider incident window | Provider-side common cause is plausible | A deployment, configuration change or shared dependency could produce a broad pattern too; inspect the failing steps |
| Repeated errors at model-call steps, while other runs or steps continue normally | Failure is localized to the model-call path | This identifies the failed step, not by itself the root cause or an SLA breach |
| Errors remain confined to a particular tool or deterministic node while model calls are healthy | Code-side or tool-side failure is more likely | Check whether an upstream model output supplied the input that triggered the tool error |
| Latency deteriorates without a corresponding error pattern | Performance degradation; attribution remains open | Aggregate latency alone cannot distinguish provider conditions from queueing or other application behavior |
| Traces are absent, partial or disconnected for the affected runs | Insufficient evidence | Check wrapping, process termination, retention and sampling before assigning blame |
| A failed run later resumes or completes | Recovery occurred; the original cause remains separate | Recovery does not prove that the provider call succeeded or that no failure occurred |
The last distinction prevents a common postmortem error: classifying a recovered run as a healthy run. Recovery and attribution answer different questions.
Where evidence silently disappears
Automatic capture does not guarantee durable capture. In LangChain Python, LangSmith’s tracing posts traces from a background thread so tracing does not obstruct the production agent. The documentation warns that “your process may end before all traces are successfully posted to LangSmith,” and says this is especially prevalent in serverless environments where the VM may terminate immediately after the chain or agent completes.
That creates a difficult failure mode during an incident: tracing was enabled, but the evidence needed for attribution never arrived. An absent trace cannot be treated as an absent failure.
The same page supplies two concrete mitigations. Setting the LANGCHAIN_CALLBACKS_BACKGROUND environment variable to “false” makes callbacks synchronous, and for both Python and JavaScript LangChain “exposes methods to wait for traces to be submitted before your process exits.” For serverless agents, configure one of those two and confirm that traces actually arrive under your runtime’s real shutdown behavior before you depend on them as incident evidence.
LangChain separately says the LangSmith SDK uses an async callback handler sending traces to a distributed collector. The vendor claims application performance is never impacted and that an agent keeps running normally if LangSmith has an incident. Those are vendor assurances, not independently verified measurements. Even taken at face value, they address application continuity, not proof that every trace was retained and remains retrievable.
From diagnosis to evidence you can defend
For the code side of the investigation, the LangGraph overview says LangSmith Engine detects issues in LangGraph agent traces and proposes fixes, with a pull request available from the Engine tab. Treat such a finding as a code-side lead to review, not proof that it caused the incident-window failures.
Recovery needs the same caution. The LangGraph project README describes durable execution, saying agents can persist through failures and resume from where they left off. That is a project-source claim rather than an independent test. If it describes your run accurately, the resumption belongs in the timeline; it does not explain the original failure.
Before promising trace evidence to a customer or using it in an SLA discussion, verify four undocumented points against current LangSmith documentation and your own deployment:
- Whether the relevant per-run errors are displayed with enough detail to support your conclusion.
- Whether retention still covers the incident period.
- Whether sampling could have omitted relevant runs, and what sampling defaults applied.
- Whether you can export an artifact suitable for the conversation, rather than merely viewing a dashboard.
None of those mechanics is established by the LangSmith pages cited here, so check that the guidance you rely on matches the documentation current at your incident date.
The attribution checklist
For the next provider incident, the repeatable procedure is:
- Confirm the provider window. Record the incident title, affected components, start and end from the current status page. Keep vendor-reported scope separate from your conclusions.
- Inventory trace coverage by stack. Using the documented coverage rules, identify LangChain-module steps, other-SDK calls and custom functions. Check the required
@traceable,traceableor appropriate SDK wrapping rather than assuming automatic coverage. - Verify nesting with a real execution path. Confirm that model calls, tools and cross-service steps appear in the traces you expect.
- Check evidence durability. For background-thread and serverless deployments, set
LANGCHAIN_CALLBACKS_BACKGROUNDto “false” for synchronous callbacks, or call the documented wait-for-trace-submission methods before your process exits. - Bound and classify the failures. Use whatever time selection your current deployment demonstrably supports, then apply the signature taxonomy without turning aggregate trends into per-run verdicts.
- Separate missing evidence from negative evidence. An absent trace is not proof that a call succeeded or never happened.
- Verify retention, sampling and export before making external promises. If those checks fail, narrow the report accordingly.
If tracing was off, relevant SDK calls were unwrapped, traces were lost at process termination, or retention or sampling removed the evidence, the honest postmortem for those runs is cause undetermined. Anthropic’s status page may establish that a provider incident coincided with your failures; it cannot, by itself, establish causation for each run. I would make that limitation explicit, then fix coverage before the next incident rather than filling the evidentiary gap with a more confident narrative.
Frequently Asked Questions
What was the duration of the Anthropic incident on November 13, 2026?
Anthropic opened with Investigating at 09:58 UTC on Nov 13, 2026, moved to Monitoring at 11:05 UTC, and marked the incident Resolved at 11:58 UTC, bounding the provider-reported window to about two hours.
How can I prevent traces from being lost when a serverless process terminates?
Setting the LANGCHAIN_CALLBACKS_BACKGROUND environment variable to “false” makes callbacks synchronous, and for both Python and JavaScript LangChain “exposes methods to wait for traces to be submitted before your process exits.”
What does the Anthropic incident page state about affected components?
It states: “This incident affected: claude.ai, Claude Console (platform.claude.com), Claude Code, and Claude Cowork.”

Join the discussion
Share a useful perspective or ask a question about this article.