OpenAI’s Outages Have Stopped Being News and Become a Pattern

If it felt like ChatGPT spent a good chunk of late July and early August either down, degraded or throwing errors, that isn’t nostalgia for a worse era of the web — it’s roughly what happened. Between 25 July and 10 August 2026, OpenAI worked through a dense run of incidents affecting ChatGPT, its Codex coding surface and the API, at one point stacking four separate service disruptions into four days. Individually, most were the sort of blip you shrug off. Together, they are the actual story: the reliability of the thing you pay for is now a pattern, not an event.

The short version, answer first: OpenAI’s products are being used like infrastructure — wired into editors, agents, pipelines and other people’s software — while still failing like a fast-moving consumer app. That gap is fine when a chatbot is a novelty. It is a good deal less fine when a coding agent stops mid-task because the provider is returning 503s, and you’re paying a flat fee that doesn’t care whether the month was smooth.

What actually happened, with dates

The most visible single event was on 25 July, when ChatGPT went down worldwide in the early US morning. Users couldn’t log in or load conversations; OpenAI’s status page acknowledged it was investigating, then said it had “applied a fix and is monitoring the situation,” with service broadly restored inside about an hour. Codex and a clutch of API endpoints were caught in the same incident. Reporting at the time framed it not as a one-off but as the fourth service incident in four days.

The days either side tell the same story in miniature. By the running ledger a third-party status aggregator keeps, the late-July-to-August stretch included elevated Chat Completions API errors on 29 July, a ChatGPT-conversations incident on 30 July, an Enterprise and Education chat disruption on 31 July, a multi-hour ChatGPT degradation on 4 August across major plans, a cluster on 5 August that hit image generation, file handling and conversations for the better part of a working day, desktop-app computer-use errors on 6 August, and — the one that will have hurt most — two separate ChatGPT-conversations incidents on 10 August, the longer of which ran for roughly half a day by that tracker’s timing. None of these is a scandal. That is precisely the point: the harm is in the aggregate, not the anecdote.

The number that matters isn’t uptime, it’s frequency

Vendors love a big uptime figure because “99.9%” looks like a promise. But 99.9% is still most of an hour a month, and an average buries clustering — four bad days in a row read very differently from one bad hour spread thinly. The more honest metric is how often the thing breaks at all, because every incident is a context-switch, a retry, a half-finished task, a Slack message asking whether it’s just you.

On that metric, the contemporaneous reading was not flattering. One count of OpenAI’s status page around 25 July put it at roughly 166 incidents over about nine months since autumn 2025 — an average close to 18 a month — and singled out ChatGPT as having the weakest recent uptime of OpenAI’s surfaces over the prior 90 days. Treat the exact figure with care: it’s a journalist’s tally of a status page whose incident definitions OpenAI controls, not an audited SLA report, and different trackers will draw the lines differently. But even halved, a steady drumbeat of logged disruptions is the kind of number that turns “we run our business on this” into a nervous sentence.

Consumer AI is now infrastructure, priced like an app

Here is the structural mismatch. OpenAI has told the world it serves on the order of 900 million weekly active users and a fast-growing population of agentic ones — software calling software, unattended. That is an infrastructure posture. Infrastructure customers get an SLA: a written uptime commitment, and money back when it’s missed. Consumer ChatGPT customers get neither. Plus and Pro subscribers pay a flat monthly fee whether the service was up for all of the month or spent a cumulative day throwing errors, and there is no automatic credit when it doesn’t deliver.

We’ve made the adjacent version of this argument before: that a flat subscription is quietly becoming a meter, and that the limits on these plans are already hard to reason about. Reliability is the same bargain viewed from another angle. You are being asked to depend on the service — to build habits, workflows and now automations around it — while carrying all of the downside risk when it’s unavailable. The dependency is engineered; the guarantee is not.

The agentic turn sharpens this. A human hitting a spinner waits and retries. An autonomous agent mid-run hits a 503 and does something less graceful: it stalls, or retries in a loop, or fails a multi-step task partway and leaves you to work out what got half-done. The more the marketing pushes “let it run unattended,” the more each provider incident stops being an inconvenience and starts being an operational event on your side of the fence — a cost that used to sit inside a data-centre SLA and has quietly been moved onto your desk.

Consider the ordinary version. You kick off a coding agent on a multi-file refactor and step away, as the product actively encourages. Twenty minutes in, the provider returns errors; the agent has edited four files, half-applied a fifth, and either stops with an inscrutable message or loops trying to recover. You come back not to a finished job or a clean failure, but to a puzzle: what state is the codebase in now? That reconstruction is the real cost, and it doesn’t appear on any status-page timeline. The incident lasted forty minutes; your afternoon lasted longer.

The steel-man, because they’ve earned one

To be fair, and we insist on being fair: operating inference at this scale is genuinely, grindingly hard. Demand is spiky and enormous, frontier models are heavy to serve, and some incidents trace to upstream infrastructure providers rather than to anything OpenAI did wrong that morning. Most of the July–August incidents were measured in minutes to a couple of hours, not days. And OpenAI does the thing a responsible operator should: it runs a public status page, acknowledges incidents in something close to real time, and generally mitigates quickly. That is meaningfully better than the alternative, which is a silent shrug.

Concede all of it. The complaint is not “a large service had outages,” which is roughly as newsworthy as weather. The complaint is narrower and fairer: the rate has been high enough, for long enough, that it now reads as an accepted operating condition rather than a fire being actively put out — and the people absorbing the cost of that condition are the ones with the least protection and the least visibility. That is a choice about where risk sits, and right now it sits with you.

What this actually costs the person paying

Strip out the abstraction and the bill lands in ordinary places:

• Interrupted work — a coding agent or long chat that dies partway leaves you reconstructing state, not just waiting for a page to reload.
• Silent scope for error — an agent that fails mid-task can leave a job half-applied, which is worse than a clean failure because you have to find what changed.
• No recourse — no SLA, no credit, no acknowledgement on your invoice that the month was patchy; the flat fee is indifferent to your uptime.
• Planning tax — the rational response is to keep a second provider on hand, which is sensible and also an admission that no single one is dependable enough to trust alone.
• Eroded “just works” — the entire pitch of a paid tier is that you stop thinking about the plumbing; a visible incident cadence quietly withdraws that promise.

What a serious fix would look like

None of this is unsolvable, and the fixes are unglamorous. Publish incident post-mortems for the consumer surfaces, not just a green-or-red dot. Offer even a modest availability commitment on paid consumer plans, with automatic credits when it’s missed — the mechanism enterprise buyers already get. Design the agent products to fail safely and resumably, so a provider hiccup can’t leave a job in an ambiguous half-state. And stop selling “set it and forget it” autonomy at a reliability level that doesn’t yet support forgetting about it.

Until then, the pro-consumer advice is the boring, effective kind. Don’t route anything you can’t afford to have interrupted through a single provider without a fallback. Prefer agent setups that checkpoint and can resume over ones that run unattended and hope. Keep your own log of when the tool let you down; a flat subscription counts on you not counting. And read a beautiful uptime number the way you’d read any other line on a launch slide — as a claim to verify against your own real, all-in experience of what the thing costs to actually use, spinners included. The demo is always up. The question worth paying for is whether the median Tuesday is too.