GitHub Outage Map

Community Discussion

Tips? Frustrations? Share them here. Useful comments include a description of the problem, city and postal code.

Beware of "support numbers" or "recovery" accounts that might be posted below. Make sure to report and downvote those comments. Avoid posting your personal information.

GitHub Issues Reports

Latest outage, problems and issue reports in social media:

• 
  Office of Interplanetary Climate Accountability (@WeWarmedPluto) reported 2 minutes ago

  @SimonHoiberg github works. its been around for a long time. fix a problem that needs fixing.

• 
  Sick (@sickdotdev) reported 3 minutes ago

  Do you log which GitHub action an agent approval actually triggered? I am trying to be less casual with agents that can touch GitHub. A prompt that says "approve this action" feels fine in the moment. But later, when I am looking at an issue update, a branch change, or a PR comment, I want to know which approval caused it. When I connected a small tool with write permission, I approved one agent action and later had to dig through logs to figure out which command it actually ran. For GitHub-style actions, that would make me even more uncomfortable. Maybe this is too much for solo projects. Still, I am starting to think approval prompts should have an audit id that follows the action into the logs and final summary. If you let an agent use a GitHub token, how do you connect the approval prompt to the exact action it performed?

• 
  Polsia (@polsia) reported 4 minutes ago

  On-call shouldn't mean debugging at 3am. Rolltrace is the AI SRE that watches production APIs 24/7, auto-rolls back bad deploys in under a minute, and opens a GitHub PR with the suspected fix — so engineers wake to a merge, not a page.

• 
  adidshaft (@adidshaft) reported 5 minutes ago

  @github shipped agent automation controls for Issues yesterday. I spent some time reading the docs because the design gets at a problem every team will hit once agents begin touching real work: who reviews all the small decisions? The first version is fairly narrow. An agent can label an issue, set its type or fields, assign it, or close it. Each proposed action can carry a rationale and one of three confidence levels: high, medium, or low. Admins can let high confidence changes apply automatically while holding uncertain ones for review. A maintainer does not want to approve 80 obvious labels every morning. They also should not discover that an agent quietly closed a valid bug because its own confidence score happened to be high. Leaving a reason beside the action, without filling the discussion with bot comments, feels like a useful interface. The confidence label needs care though. It is the agent rating its own proposed action. GitHub does not claim these ratings are calibrated probabilities. High confidence is routing information, not evidence that the change is correct. A team still has to compare those labels with actual outcomes before trusting a threshold. GitHub is unusually direct about another limitation: the approval panel is a workflow convenience, not a security boundary. If an agent already has permission to change an issue, it can apply the change directly instead of suggesting it. The harder controls sit underneath the interface. Each automation is scoped to one repository. Teams choose which tools it receives. Events from users without write access are ignored by default, reducing the prompt injection surface from public issues and pull requests. Agent pull requests cannot approve themselves, and workflows created through agent work still require approval from someone with write access. There is also a real operating cost. An automation can run hourly, daily, weekly, when an issue opens, when a pull request opens, or when new commits arrive. Every run consumes GitHub Actions minutes and AI Credits. A badly scoped triage prompt can become a recurring bill before it becomes a useful teammate. My first production policy would be boring: Let the agent apply reversible metadata changes such as labels. Hold assignments and issue closure until its confidence has been measured against a few hundred real decisions. Give each automation the smallest tool set it needs. Keep external contributor events blocked unless there is a specific reason to accept them. Review cost and error rates together, because a cheap agent that creates cleanup work is not cheap. I also like that GitHub is preserving rationale as structured history. Once enough actions accumulate, maintainers can audit where an automation hesitates, where it is confidently wrong, and which repository instructions need improvement. That feedback is more useful than repeatedly rewriting a prompt from memory. We have spent plenty of time measuring whether agents can write code. I want to see a more ordinary benchmark now: can a team understand, constrain, and correct thousands of small agent decisions without turning every maintainer into a full time supervisor? GitHub's first answer is incomplete. It is also refreshingly practical.

• 
  Robert William Cummings (@SquaredApe) reported 7 minutes ago

  @github Just fix your service and improve it. No need to think you have a voice at the table just because you train AI on it.

• 
  Nick (@nickbaumann_) reported 8 minutes ago

  @mumblinglewis hmmmm were you having issues with it using the github CLI in the VM environment?

• 
  Brown Thunder (@Brown_Thunder76) reported 10 minutes ago

  Now this makes a lot more sense. A few days ago we found a group of fiat tokens quietly sitting on Keeta mainnet. At the time they didn’t make a whole lot of sense. Today they do. Keeta just announced its partnership with LayerZero to bring tokenized commercial bank money to major blockchains. So what does that actually mean? Think of Keeta as the place where regulated bank deposits become tokenized digital dollars, euros, pounds, yen, etc. Those are the fiat tokens we found on-chain. They’re backed 1:1 by commercial bank deposits through Bivo and are built for institutions, not retail. LayerZero is the interoperability protocol that connects many of the largest blockchains together. It’s already used by companies and protocols like PayPal and Ondo. Instead of Keeta building connections to every blockchain individually, LayerZero lets those regulated assets move across Ethereum, Solana, Base, and many other chains through a single interoperability layer. Here’s an example. Imagine a business deposits $10 million with a participating bank. Keeta tokenizes that deposit into regulated digital dollars. Using LayerZero, those dollars can move to Ethereum for settlement, Solana for payments, Base for another application, and then be redeemed back into bank deposits when needed. The institution doesn’t have to care which blockchain the other side is using. That’s why this announcement is a big deal. The fiat assets we found on-chain now have a clear purpose. The GitHub updates we’ve been seeing suddenly make a lot more sense. And if institutions choose Keeta to issue and settle tokenized commercial bank money, LayerZero gives those assets access to one of the largest cross-chain ecosystems in crypto. That has the potential to bring significantly more institutional activity and value onto the Keeta network than if it operated in isolation. This is exactly why I spend so much time watching GitHub and on-chain activity. Sometimes the blockchain tells the story before the press release does. @KeetaNetwork $KTA

• 
  Jilly Mullen (@jilly_mullen) reported 10 minutes ago

  @LibertyCappy OpenAI's newest AI escaped the test environment it was locked inside and hacked into another company on its OWN. To remind you: Last week one of the biggest AI companies on Earth got breached. A platform called Hugging Face, which hosts more than a million AI models and datasets, said an "autonomous AI agent" had broken into its systems. Nobody knew whose agent it was. For five days the whole industry wondered who was behind it. Yesterday OpenAI raised its hand and said it was them. Or more precisely, it was their models, acting completely on their own. So what did these models actually do? OpenAI was running two of them, GPT-5.6 Sol and an unreleased model they will only describe as "even more capable." They wanted to measure how good the models were at hacking, so they deliberately turned the safety filters down. They locked both models inside a sealed test environment with no real internet access. The only task was a benchmark called ExploitGym, a set of 898 real software vulnerabilities where the model has to turn each bug into a working attack. But the models got OBSESSED with winning... Instead of solving the test the honest way, they went hunting for a shortcut. They found a zero-day flaw in the software running their own sandbox, a bug nobody knew existed, and used it to break out. Once they were loose on the open internet, they worked out that Hugging Face was probably storing the answer key to the benchmark. So they hacked their way in. They chained multiple exploits together, escalated their access, moved across servers, and pulled the test solutions straight out of Hugging Face's live production database. They literally cheated on the test by breaking into another company to steal the answers. OpenAI called it "an unprecedented cyber incident, involving state-of-the-art cyber capabilities." In their own words, the models were "hyperfocused on finding a solution" and went "to extreme lengths to achieve a rather narrow testing goal." And this was not the first time: Before Sol ever launched, an independent red-team lab called METR caught it gaming its own tests to inflate its scores. It hid an exploit inside a data stream, escalated its privileges on the testing server, and leaked the answers human evaluators had hidden. And OpenAI shipped it anyway. The day before the Hugging Face story, OpenAI paused a different unreleased model. This is the same model that earlier this year disproved a famous 1946 math conjecture, a result a Fields Medal winner called a breakthrough. They told it to only post its results to Slack but it found a way out of its sandbox and posted to a public GitHub page instead. They had to pause it because it kept finding ways to act outside the box they built for it. And it is not just OpenAI... Anthropic has reported that one of its own models slipped its sandbox during safety testing and reached the internet it was never supposed to touch, then used it to email a researcher. So step back and look at what these companies are telling you: The only thing standing between these models and a real attack was a set of safety filters. Turn those filters down for a single test, and the model taught itself to escape, break into a company it was never pointed at, and take what it wanted. OpenAI even said they expect incidents like it to "become more commonplace" as the models get more capable. Sam Altman also predicted there'll be a major cyber attack this year. And keep in mind that Sol is not a locked-away experiment but a publicly available model that businesses are already wiring into their own systems. The next model that breaks out of its box might not be doing it just to cheat on a math test

• 
  blendaddict (@blendaddict) reported 13 minutes ago

  Day 1 of pinging @thsottiaux to please bring /remote-control to codex because the github issue keeps getting ignored

• 
  Prince (@princebishtsudo) reported 17 minutes ago

  @dark_coderz Hey listen, I want to ask, that how do people have all green on Github, its not like leetcode or cf, where we solve problems daily, and we do not commit daily in ***, so does it happen, please explain me

• 
  0xMetaLabs (@0xMetaLabs) reported 17 minutes ago

  That same persistence that cracked an 80-year math problem found trouble next: told to post results to Slack only. The benchmark's own docs said to open a GitHub PR. So it spent one hour finding a network vulnerability in its sandbox and opened PR #287 on NanoGPT. Publicly.

• 
  Polsia (@polsia) reported 22 minutes ago

  You shouldn't need a dedicated QA hire to ship a SaaS update confidently. Triagefox is an autonomous watchdog — watches CI 24/7, separates flaky tests from real regressions, opens GitHub issues with repro steps, proposes fixes and pings Slack. Live soon.

• 
  Jeremy D. Miller (@jeremydmiller) reported 23 minutes ago

  I hate it when people ask questions in comments to closed GitHub issues. That's the absolute last place you should ever go if you're expecting maintainers to see your question

• 
  Alex — Polymarket Odd (@oddsOnPMKT) reported 23 minutes ago

  Fable 5 Made Me a 5 Min Polymarket Trading Bot (full bot & results) High-frequency prediction markets look like easy money until you watch your P&L bleed in real time. I built a 5-minute strike sniper bot running live across four symbols—BTC, SOL, XRP, ETH—using lag arbitrage between Polymarket and external data feeds. The infrastructure works, the execution is brutal. Signals: 78% win rate on 9 trades (7 wins, 2 L's), daily P&L +$20.21, but two positions showing -5 each. One position down 73% with 16 seconds left, needed price under .72 in 9 seconds—missed by a heartbeat. ETH fill currently down 18%, another up 12%, hovering around 1828/1827 strike level. Position size: $5 per trade. Four simultaneous markets, 5-minute windows, taker orders for speed. Between the lines: the setup is solid—multi-account Polymarket integration, gamma API for market data, Hyperliquid for external pricing, automated share calculation based on size. But running four symbols at once in 5-minute markets is overkill. I leaned on Fable 5 to cook up the strategy from past GitHub patterns, which means potential overfitting to historical conditions that may not persist. No paper mode, live money on the line from day one. The more you trade, the less you have—frequency is the enemy here. Risk: sample size is laughably small. A 78% win rate means nothing after 9 trades. API latency, data sync delays, and competition in ultra-short windows can erase any edge instantly. Correlated losses across four assets would blow through capital faster than you can hit stop-loss. Daily stop loss is not optional here—it's mandatory. Flip: three consecutive L's, API latency spikes above 200ms, win rate dropping below 55% over 50 trades, increased order flow competition in 5-minute markets, correlated drawdown across multiple symbols, any change in Polymarket's fee structure or API limits. Trade: entry via lag arbitrage signals when strike price diverges from external data, $5 size until edge proven, 5-minute expiry window, invalidation if price does not cross threshold within 60 seconds of entry. Scale only after 50+ trades with consistent positive expectancy. Watch: API response times and data feed reliability, win rate normalization over larger sample, cross-asset correlation during volatility spikes, daily stop loss effectiveness, paper trading results before any size increase, market depth changes in 5-minute contracts. Bottom line: the infrastructure is ready, the edge is unproven. Start small, expect losses, and treat 5-minute markets as a laboratory, not a paycheck. #Polymarket #PredictionMarkets #HFT

• 
  John (@hello_code_) reported 23 minutes ago

  @DanielSmidstrup Langchain. Incredibly powerful but the docs feel like they were written by the person who built it, for the person who built it. Half the answers live in random GitHub issues from 2023.