What happened
Pydantic AI’s GitHub release page lists v2.65.0, dated 2026-11-02. Among its compatibility notes and features, the release says ModelFallback now falls back to the next model when a model refuses. It also says ContentFilterError can match refusals in the fallback_on setting. The release page does not give a code example or describe the exact configuration syntax beyond naming that setting.
In practical terms, this separates a refusal from the narrower set of failures commonly treated as transient infrastructure problems. A team that has configured several models in a fallback chain can now make a refusal eligible for the same next-model transition. The release does not say that all refusals should be retried, nor does it prescribe a default policy for deciding which ones should end a request. It announces framework behavior that an application must still configure and govern.
The behavior arrives with several other additions. Pydantic AI adds a WebSocket transport for OpenAI Responses and a ConversationStore, which keeps a conversation as a log of messages stored once. It also adds Conversation.revision, intended to catch conflicting saves. These changes concern distinct layers of an agent application: a transport option for a provider API and a mechanism for managing persistence conflicts in stored conversations.
The release adds support for 12-hour prompt-cache retention on the OpenAI Responses API for GPT-5.6 and later. It also adds native mid-conversation system prompts on OpenRouter OpenAI routes and Claude models that support them. For Anthropic web tools, Pydantic AI adds anthropic_web_tools_allowed_callers, a setting for specifying allowed_callers. The notes also mention multimodal notes in AskUserAnswer and name replacement APIs when code imports a name removed in V2, including OpenAIModel or MCPServerStdio.
Error classification and retry behavior receive attention elsewhere in v2.65.0. Pydantic AI now raises ModelQuotaExceededError instead of ModelRateLimitError for Z.ai balance and plan-limit 429 responses. For Bedrock errors on AsyncAnthropicBedrock, the release names ModelContextWindowExceededError and ModelQuotaExceededError. The notes say Temporal will avoid retrying model errors that cannot succeed on retry by default, using non_retryable_model_errors, including subclasses of non-retryable errors.
Provider-specific operational changes are also included. Pydantic AI says Google requests receive a server deadline of at least 20 minutes rather than the client read timeout, and it warns about httpx’s five-second default. The release says BrowserUse model calls count toward the host run’s usage and UsageLimits. It also changes OpenRouter Gemini message-cache breakpoint placement so the final message no longer doubles the billed prompt, and forwards cache='1h' to Claude Haiku 5.5 on Bedrock rather than reducing it to five minutes.
The announcement is a release changelog, not a walkthrough. It identifies the refusal-related behavior but does not state which models or refusal categories trigger it, whether fallback requires a particular setup, or how applications should handle a refusal that is itself the correct safety outcome. It gives no adoption, reliability, latency, cost, or performance measurements. The other changes span transports, persistence, caching, provider behavior, and bug fixes, and the changelog does not rank them by expected impact.
What the archive adds
New Runtime covered Pydantic AI v2.61.0 on October 24, v2.62.0 on October 28, and v2.63.0 on October 31. This is a new release in an ongoing sequence, with refusal-aware fallback as a new fact rather than a restatement of those releases.
Trend signal
This release modestly supports harness architecture outlives model choice. Pydantic AI’s fallback logic lets the framework’s orchestration layer determine what happens when a particular model refuses, rather than leaving that decision solely to the model endpoint. The changelog establishes a capability, not evidence that teams are adopting it, that providers expose comparable refusal signals, or that the behavior improves production outcomes.
Why it matters
A refusal can interrupt a workflow even when an application has another model configured. Making refusals eligible for fallback gives builders a way to encode a recovery path in the framework instead of treating every refusal as equivalent to a transport error, context-window failure, or exhausted quota. That can matter when models have different coverage, tool access, or provider-specific behavior and the application has a legitimate policy for trying another provider.
The distinction needs care. A refusal may signal that the request should not be fulfilled, not merely that one model failed. Blindly moving to another model can obscure the reason an interaction stopped and can turn a policy boundary into a provider-shopping loop. A fallback chain should therefore distinguish operationally recoverable refusals from requests that must remain blocked. Logging both the original refusal and the selected fallback outcome gives reviewers an auditable record of that decision.
The rest of the release reinforces the same operational concern: agent frameworks are increasingly responsible for classifying outcomes, persisting state, enforcing usage limits, and deciding whether retry is sensible. Features such as non_retryable_model_errors, quota-specific exceptions, conversation revisions, and refusal-aware fallback do not make an application safe by themselves. They give the application clearer control points at which to express its own policy.
Limits and uncertainty
Pydantic AI’s release notes do not explain the configuration syntax, the refusal signals recognized by each provider, or whether all model integrations behave consistently. They provide no benchmark of how often fallback succeeds after a refusal, nor measurements of latency, cost, or effects on safety. It is also unclear from the changelog how the framework distinguishes an eligible refusal from one that should terminate the request. Teams should verify the behavior against their installed version and provider combination before relying on it in production.
Skill to build now
Review one existing Pydantic AI fallback chain this week. Write down which conditions may proceed to the next model: for example, a capacity-related failure or an application-approved refusal category. Separately mark conditions that must terminate the request, especially refusals tied to your product’s own safety or authorization rules. Then test the chain with a refusal case and confirm that your logs preserve the first model’s outcome, the fallback decision, and the final result.
Reader takeaway
Pydantic AI v2.65.0 adds refusal-aware model fallback, a focused improvement for applications already using its fallback machinery. Treat it as an orchestration option, not permission to retry every refusal: define which cases can move to another model, preserve the decision trail, and verify that policy in your own provider setup.