# The Same Claude Model Gives You 60 Days' Notice on One Platform and 184 on Another > Source: > Published: 2026-08-13 12:00:00+00:00 I run [ AI Change Watch](https://aichangewatch.com), a small independent project that Running it turned up something I did not expect, and then a few more things that were stranger still. The one that started it: **when Anthropic retires a model, it promises at least 60 days' notice.** It keeps that promise — barely. Across the 19 retirements listed on its own page the median notice is 63 days, and the five most recent came in at 60, 61, 62, 62 and 62. Run the same model on AWS Bedrock and you get 184. Not because anyone is late or wrong — because the two platforms publish different retirement policies for the same weights, and neither page mentions the other. I originally thought tracking model deprecations would be straightforward: find the vendor's lifecycle page, extract the model name and retirement date, and keep it updated. It wasn't. Here are some things I found while trying to make the data comparable. How long do you get between "this model is going away" and "this model stops answering"? Two vendors publish the answer as policy. Anthropic: Anthropic notifies customers with active deployments for models with upcoming retirements, providing at least 60 days' noticebefore model retirement for publicly released models. AWS Bedrock: A model will be in the Legacy state for at least 6 monthsbefore the EOL date. Both of them also publish the dates you need to check it. Anthropic dates each retirement announcement in its deprecation history ("On June 5, 2026, Anthropic notified developers…") and gives the retirement date in the table under it. AWS puts a `Legacy date` next to the `EOL date` . So the notice period here is one subtraction, and both ends of it come from the vendor: **start = the date the vendor says it announced the retirement (Anthropic) or moved the model to Legacy (AWS); end = the retirement or EOL date it published.** No estimate, no first-seen date of my own. | Retirements with both dates | Observed notice | | |---|---|---| | Anthropic | 19 | 60–189 days, median 63 | | AWS Bedrock | 17 (every row) | 181–185 days, median 184 | Anthropic's spread is worth a second look: seven of the 19 ran 63 days, five ran 60–62, and the long tail (181, 181, 181, 189) is all from 2025. The five most recent are 60, 61, 62, 62 and 62 — the stated floor, near enough exactly. AWS lands on six months in every single row, across five different model providers — AI21, Amazon, Anthropic, Cohere and TwelveLabs. That's a platform-wide rule, not a coincidence. Now look at the models that appear on both: | Model | Notice from Anthropic | Notice from AWS Bedrock | Ratio | |---|---|---|---| | Claude Opus 4.1 | 61 days | 184 days | 3.0× | | Claude Sonnet 4 | 62 days | 183 days | 3.0× | | Claude 3 Haiku | 60 days | 184 days | 3.1× | | Claude 3.7 Sonnet | 114 days | 181 days | 1.6× | Same model, same retirement, three times the runway — depending on which endpoint your code calls. Two things before concluding that Bedrock is simply more generous. AWS also guarantees a model stays available **at least 12 months from launch**, which Anthropic doesn't publish at all. But the back half of that six-month window isn't free: During this public extended access period, active users of a Legacy model can continue to use it until the EOL date (for a minimum of 3 months), but you should expect higher pricing, which will be set by the model provider. So part of the longer grace period is a paid extension. And the other two vendors can't be measured. **OpenAI and Google publish a shutdown date and no announcement date**, so there's no start of the clock to subtract from. Google's table does carry a `Release date` , but that's when the model launched, not when it was marked for retirement. Whatever notice they give, their own pages don't say. On July 28, Google's Gemini API deprecation page listed: `gemini-2.5-pro` `gemini-2.5-flash` `gemini-2.5-flash-lite` All three had a shutdown date of October 16, 2026, along with replacement models. On August 3, the entries changed. Here is the `gemini-2.5-pro` row: | July 28 | August 3 | | |---|---|---| | Shutdown date | October 16, 2026 | No shutdown date announced | | Replacement | `gemini-3.1-pro-preview` | — | | Status | deprecated | unknown | The other two rows changed the same way, each losing its own replacement (`gemini-3.6-flash` for `gemini-2.5-flash` , `gemini-3.1-flash-lite` for `gemini-2.5-flash-lite` ). The current page doesn't show that October 16 was ever announced. There is no change history and no note saying the date was withdrawn. The only signal is the `Last updated` stamp at the foot of the page, which moved from `2026-07-30 UTC` to `2026-08-03 UTC` . It tells you *that* something changed, not *what*. You don't have to take my word for the earlier state — the Internet Archive holds both sides: `Last updated 2026-07-30 UTC` ): all three rows read `October 16, 2026` , each with a replacement.`Last updated 2026-08-03 UTC` ): all three read `No shutdown date announced` , replacement column empty.In the same table, `gemini-2.5-flash-image` reads `October 2, 2026` in both captures. Three rows changed; the page wasn't rebuilt. The deprecation page itself says where to look: Deprecation announcements are made on the Release notes page, and the announced earliest shutdown dates are tracked on this page. The [Gemini API release notes](https://ai.google.dev/gemini-api/docs/changelog) are current — `Last updated 2026-08-11` , most recent entry July 30 — and mention neither October 16 nor its withdrawal. There is another place to look. Google serves these same models through Google Cloud as well, where the Vertex AI documentation has moved to Gemini Enterprise Agent Platform. **That lifecycle table never withdrew the date.** As of August 12 it still reads: | Model | Retirement date | |---|---| `gemini-2.5-pro` | October 20, 2026 | `gemini-2.5-flash` | October 20, 2026 | `gemini-2.5-flash-lite` | October 20, 2026 | Not October 16. October **20**. Archive captures of the two pages put that shift a few days ahead of the withdrawal: | Capture date | | |---| `Not before October 16, 2026` `October 16, 2026` `October 16, 2026` `October 16, 2026` `October 20, 2026` `October 16, 2026` `October 20, 2026` `No shutdown date announced` So Google Cloud moved the date by four days, and days later the Gemini API page dropped it altogether. I could not find either change announced. The Agent Platform release notes are actively maintained — most recent entry August 4 — and don't mention it. The only announcement of October 16 I found anywhere is an April 2, 2026 entry in the *old* Vertex AI release notes ("The retirement dates for Gemini 2.5 Pro, Gemini 2.5 Flash-Lite, and Gemini 2.5 Flash have been updated to October 16, 2026") — on a page that now carries the banner **"Vertex AI documentation is no longer being updated"** and whose most recent entry is May 26. That leaves two live answers for the same three models. Read the Gemini API docs: no shutdown date. Read Google Cloud: October 20, 2026. Which is section 1's problem again — two platforms, two lifecycles, each page correct about its own endpoint — except this time it's one vendor. That's a defensible way to run it. It's still two answers, and neither page tells you it isn't the only one. I noticed this because I had captured the earlier state. That changed how I thought about the problem. A deprecation page isn't just documentation. **It's changing data.** If you only store the current page, you can lose the fact that a vendor previously announced something. That's why AI Change Watch stores observations over time rather than only the latest value. Suppose a model is being deprecated. The next obvious question is: "What should I migrate to?" There is no common answer format. AWS Bedrock's lifecycle table has: Model provider | Model name | Model ID | Regions | Legacy date | EOL date | Public extended access start date There is no replacement-model column. The page tells developers to migrate to the latest model before EOL, but doesn't identify a specific replacement in that table. Other vendors do provide replacement information: | Vendor | Rows checked | Rows with replacement | |---|---|---| | OpenAI | 140 | 134 (the other 6 print "—") | | 42 with shutdown dates | 42 | | | Anthropic | 20 | 20 | | AWS | 17 with EOL dates | No replacement field | This isn't necessarily a criticism of AWS. AWS hosts models from other providers, so recommending a particular successor can be a different product decision. But the three that do publish it don't agree on where it goes. **OpenAI** puts it in the deprecation table itself. **Google** puts it in the deprecation table too — but only fills it in for rows that have a shutdown date. Rows marked `No shutdown date announced` mostly leave it empty, so "deprecated" and "scheduled" are separate states and only the second one tells you anything. **Anthropic** doesn't put it in the model status table at all; that table has no such column. It's in separate tables further down the same page, one per announcement. **AWS** has no field for it. And even OpenAI isn't consistent with itself. On the same page, two different column names are used: `Recommended replacement` and `Substitute model` A human reading that page understands immediately that these are the same thing. A parser has to be told. Mine wasn't. It matched several variants — `replacement` , `successor` , `recommended` , `alternative` — but not `substitute` , so it silently missed replacement information for 26 models. The rows still had shutdown dates, so nothing looked broken; my site just showed retirements with no migration target. **That was my bug, not OpenAI's.** Four vendors, four structures, and one of them uses two inside a single document. And it isn't just the lifecycle information that moves. The tooling wrapped around these models moves too, and while I was arguing with deprecation tables I went and measured that as well. I counted GitHub releases of each vendor's official Python client over the same 90-day window for every project, from May 13 through August 11, 2026. | SDK | Releases | Average interval | |---|---|---| `anthropic-sdk-python` | 21 | 4.3 days | `openai-python` | 18 | 5.0 days | `python-genai` (Google) | 14 | 6.4 days | `huggingface_hub` | 13 | 6.9 days | `mistralai/client-python` | 6 | 15 days | `xai-sdk-python` | 6 | 15 days | `cohere-python` | 4 | 23 days | `groq-python` | 3 | 30 days | That's a **7x difference** between the fastest and slowest projects in this sample. This doesn't mean Anthropic users need to upgrade every 4.3 days. The count includes patch releases, and release frequency isn't the same thing as breaking-change frequency. But it does illustrate how quickly the AI tooling layer is moving. I excluded Claude Code because it's a CLI rather than a Python SDK, and excluded AWS, Qwen, and Perplexity because I wasn't monitoring comparable official Python client repositories for them. So this is a release-frequency comparison of the projects listed above, not a ranking of vendor development speed. Before building this, I thought the difficult part would be collecting the data. It isn't. Collecting it is a crawler and a parser. A model can have a different amount of notice depending on the platform. A shutdown date can be announced and later disappear from the current page. A replacement model might be published—or not. It might be in a different table, under a different field name, or only appear after another lifecycle state changes. And the documentation itself changes while you're trying to monitor it. The result is that answering a seemingly simple question— "When does this model stop working, and what should I use instead?" —can require multiple pages, vendor-specific parsing, and historical state. That's what AI Change Watch is trying to automate. It continuously checks the original vendor documentation, preserves changes over time, and normalizes the information into a common dataset. The numbers in this article are a snapshot taken on August 11, 2026. The cross-vendor comparisons describe what was publicly documented at that point, not a complete historical record. For the Google example, I have been continuously monitoring the relevant page since July 28. I also deliberately left out figures where I couldn't distinguish between: I've already had cases where the second explanation turned out to be true. That was a useful lesson too. **The hard part wasn't collecting the data. It was making the data comparable.** AI Change Watch: [https://aichangewatch.com/deprecations](https://aichangewatch.com/deprecations)