GitHub status: access issues and outage reports

Problems in the last 24 hours

The graph below depicts the number of GitHub reports received over the last 24 hours by time of day. When the number of reports exceeds the baseline, represented by the red line, an outage is determined.

Most Reported Problems

The following are the most recent problems reported by GitHub users through our website.

• Website Down (68%)
• Sign in (18%)
• Errors (14%)

Live Outage Map

The most recent GitHub outage reports came from the following cities:

City	Problem Type	Report Time
Créteil	Website Down	19 days ago
Trichūr	Errors	22 days ago
Brasília	Sign in	23 days ago
Lyon	Website Down	23 days ago
Tel Aviv	Website Down	26 days ago
Rive-de-Gier	Website Down	26 days ago

Full 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:

• 
  John Kennedy Peterson (@skyshark88) reported 5 seconds ago

  @dair_ai •VALIDATED — the reproduction passed a could-have-failed test and is reproducible from the workspace. •ANCHORED — the result works consistently in the generated system (chosen value or implementation detail, not strictly derived). •CONJECTURE — motivated hypothesis still awaiting decisive test (used during spectrum exploration). •RETRACTED — permanently marked when evidence fails; status propagates to dependent claims. Claim type (routes effort): •Evidence-limited — additional runs or data improve the score (common for numerical fidelity claims). •Derivation-limited — only new logic, better specification, or a decisive experiment can raise the score. In the case studies, confirming data alone was treated as low-value; the system required genuine reproduction of the claim under the recorded provenance. Energy audit
Mention-count and emphasis in the paper versus actual effort invested (time, superseded executions, corrections) are tracked side-by-side with evidence status. Divergence between these columns signals potential error or under-specified claims in the original paper. Across the 12 runs, effort varied significantly (e.g., PINN papers required median 5–7 hours with more superseded executions; SINDy completed faster at ~2 hours). Key Evaluation Results (Mapped to Framework) •All 12 independent runs (3 per paper across 4 scientific ML papers: PIFT, PINN-I, PINN-II, SINDy) reached completion gate: every workspace had all targets matched with report coverage. •Total of 158 recorded targets were successfully linked to evidence. •Repeated runs showed natural variation in target decomposition, numerical fidelity, elapsed time, number of intermediate corrections, and exact acceptance rules used — exactly as expected when completion depends on workspace evidence rather than agent messaging. •Scalar results were largely faithful (37/39 anchored claims within thresholds), with positive headroom on several metrics. •The workflow makes replication inspectable and auditable, not a guarantee of identical numerical reproduction. Conclusion (Framework Perspective) By organizing replication explicitly around the Agentic Conversation Framework v3.0, Paper-replication becomes a concrete implementation of high-signal, bias-aware agentic work with computational chain of custody. Completion is a verifiable workspace state, not a subjective agent declaration. The framework’s dual histories, role separation, claim registry, scoring/pruning, and energy audit provide the missing structure that plain prompting lacks for long-horizon scientific replication tasks. This rewrite preserves all core contributions and empirical findings of the original paper while imposing the clearer, more auditable structure of Framework v3.0. The result is a more robust, inspectable process for turning paper claims into reproducible evidence. The original paper’s code, prompts, and workspaces remain available at the authors’ GitHub repository for further experimentation with this or future framework versions.

• 
  Dishant Miyani (@dishantwt_) reported 1 minute ago

  @samposwal @github i hope they fix their downtime first

• 
  Shamus Aran (@ShamusAran) reported 4 minutes ago

  @ZaxBit @AntonHand Joining the peanut gallery in saying this guy is absolutely right. There's a difference between being able to fix your family's router and being able to compile a github repo.

• 
  Farhan Mubaraq (@farhanmbq3) reported 6 minutes ago

  Claude Max 5x - $100 Google Gemini Pro - $20 ChatGPT Plus - $20 Fable5, Deepseek V4, GLM 5.2 via API plan. I think this is my best setup. After trying this and that. Fable5 for Architecture, PRD, and ****. Including database schematic and backend system as well. Make sure everything is neat, structured, and scalable from the very start. Also code must be easy to read. Do not underestimate this. First look starts on Google Stitch, then you do manual UI/UX design work. I use this instead of Figma. Finalise, then connect to MCP server, start the first version of frontend look. Switch to GLM 5.2 API, continue working and do the iteration. Once done, let Codex do the backend. Iterate again and iterate again. Use Antigravity IDE to do some manual edit if the code result is garbage and messy. Codex and Claude Code (I personally use Sonnet 5 for this) to handle your backend, auth, and database. Iterate, debug and **** will be done here as well. Once you feel like you're done, let Claude Opus do the Refactor and make your code clean and beautifully structured. Use the cheaper chinese AI model as your backup if your project is so heavy and costs too much money. Now do the manual QA and testing yourself. Check for errors. Fix them. Make sure it meets your standard. For me, if it's not perfect, I don't want that garbage. If it has my name on it, it must be perfect. Well, that's my personal game. As a Non IT guy haha. HIDUP VIBECODING!!! Follow me on X and on GitHub I'll share more!

• 
  Cody (@mackody_) reported 8 minutes ago

  When many agents (Claude, Codex, humans, CI jobs — anything) work the same repo, they collide: two of them grab the same issue and duplicate or clobber each other's work, this annoyed me so much I created a GitHub-native mutex for multi-agent work. Link Below:

• 
  Sethian (@theSethian) reported 8 minutes ago

  Your AI agent still needs a babysitter. Owain Lewis shows the better version: give it a goal, a clock, and a way to prove the work is done. Old workflow: you write the prompt, read the answer, spot the failure, paste the next instruction, run the test, paste the error back, and keep steering. You are still the engine. His setup uses three primitives: A goal gives the agent a finish line. Deploy the app, wire CI/CD, check the health endpoint, check the web app, and stop only when the app is live. A loop gives it a clock. Every 5 minutes, check the PR, read new feedback, fix what changed, and keep going. A scheduled automation gives it a recurring job. Scan production logs every morning, find errors, reproduce the bug, add tests, and open a PR with evidence. The best examples are the work devs keep putting off: > memory issues hiding in production logs > stale docs drifting away from the code > GitHub issues waiting for labels > old tickets ready but untouched > PR feedback nobody wants to refresh all day > deployments that need a real health check The important part is the verifier. The agent doesn't get to call the work done just because it produced output. Tests, builds, health checks, a separate model, or a human review step have to confirm it. Otherwise you don't have a loop. You have an agent shipping confident garbage on a schedule. The article below breaks down the full anatomy: verification, memory, maker-checker splits, open vs closed loops, cost per accepted result, and the point where the human still needs to step back in.

• 
  Patrick Barnhill (@Patrickbarnhill) reported 10 minutes ago

  DGX spark hosting main Hermes connected to telegram group chat threads. Honcho memory (just saw it was available trying it out hosted locally). Sharing to GitHub "agent ops" so other agents share important skills. Home computer running Hermes WSL and also windows native Hermes for computer control. Office PC running Hermes windows only for computer control. Daily driver codex gpt5.5. also running Qwen on DGX spark 1 and nemotron on DGX spark2 but with how inexpensive codex sub is with insane usage virtually no use for the DGX except for smart home if Internet is down

• 
  Miza (@mizak0) reported 12 minutes ago

  Is there an on-going issue with github pages? I keep having failed deployments since this morning.

• 
  Duke Magus (@dukemagus) reported 14 minutes ago

  @ClassicREbirth Oh HELL no. They're part of the problem, Microsoft stripmined GitHub to fuel the AI craze that drove prices up and it's a big domino in this whole thing. They don't get a pass to make this joke.

• 
  synthetic ape (@synthetic_ape) reported 15 minutes ago

  @necrohorrorporn its currently works on my local. there is some issues with buying with rate limiting and steam api declines. if I can able to fix that I can share it on github

• 
  Jess Daniel (@jess_daniel10) reported 16 minutes ago

  @neetcode1 I was testing something with a local server and I told 5.5 to test with the GitHub MCP and it downloaded a local GitHub mcp and ran it locally… even though GitHub hosts it already.

• 
  Vikas Kumar (@Kumar_Vikas__) reported 19 minutes ago

  i kept distracting myself i'd sit down to work on my e-commerce site, drift into some unrelated tab, fall down the hole, and 20 minutes later wonder what I came here to do. so I built a small Chrome/Edge extension. an AI watches your tabs and closes the ones that don't matter: judged against what you said you're working on open source here: github link in comments it's still buggy, fair warning. i'm actively working on it. using my opencode go sub right now, but soon wiring in chrome's built-in gemini api so it's free end to end. built it for myself, dropping it here in case it helps. if you fork it and send some PRs, i'd genuinely love that.

• 
  Akruti Acharya (@akrutireports) reported 19 minutes ago

  Someone built an AI plugin around the oldest optimization trick: fewer words. Caveman makes AI coding agents answer with fewer words while keeping the technical content intact. The idea is simple: Same answer. Fewer tokens. It works with Claude Code, Codex, Gemini, Cursor, Copilot, Windsurf, Cline, and 30+ other agents. The project reports an average 65% reduction in output tokens by removing filler instead of changing code, commands, or error messages. It also includes commands for concise commit messages, one-line PR reviews, compressing memory files like CLAUDE.md, and tracking token usage. The best part is that the repo doesn't oversell the numbers. It explicitly says the 65% applies to output tokens only and explains when overall savings may be smaller. That level of honesty is probably one reason it has already crossed 82k GitHub stars.

• 
  MKH BloodEDGE96 (@BL00B96) reported 21 minutes ago

  @are_unimportant @thicc_stick_boi it actually "USED" to work at some point, nowadays I often go back to Github or use pcgamingwiki to fix stuff. it wasn't even that long ago, I remember using it to fix stuff in my Laptop last October but it got lobotomized months later and couldn't diagnose ****.

• 
  Damir Wallener 🇭🇷🇨🇦…🚀🛰️…⚽️🥁…👨‍🍳 (@DamirWallener) reported 26 minutes ago

  @l3d1c I’m not a conspiracy guy. I am a sensor guy. Realtime sensor math is *hard*. Something is wrong with the system. This will happen again…and the games are only getting higher profile… They need to release the sensor feeds and put the processing code up on GitHub. Transparency is the only way to fix this.

• 
  Harry Tandy (@HarryTandy) reported 26 minutes ago

  Boris Cherny, creator of Claude Code: "Usually, every night, I have like a few thousand that are doing kind of deeper work" Anthropic's reported 8x coding output starts before Claude writes a line Build the context stack: 1. `CLAUDE.md` - role, repo rules, code style - commands Claude should run before a PR 2. `@AGENTS.md` import - if your repo already has agent rules - keep Claude-specific notes below the import 3. Architecture map - where frontend, backend, tests, auth, billing live - which folders need approval before edits 4. Task packet - ticket link, files, goal, constraints - exact definition of done 5. Past attempts - what failed last time - what error or review comment caused the retry 6. Tool context - GitHub for issues and PRs - Sentry for live errors - Postgres for schema checks 7. Verification - one command Claude can run - one pass/fail result it can paste back 8. Post-run memory - add the lesson to auto memory or `CLAUDE.md` - remove rules that no longer help A prompt asks for work. A context stack gives Claude the room to finish it

• 
  High Signal AI (@HighSignal_AI) reported 33 minutes ago

  Satya Nadella on why AI won't replace human ambition, rather, it will amplify it. GitHub Copilot didn't start out as a revolution. It started as a joke. Satya recalls when the product first launched with code completions powered by Codex: "Software engineers are pretty skeptical people like all engineers are, and no one thought that this thing would work and be any good." Then something unexpected happened. "It started working, and the interesting thing is it went from being a joke to being standard issue in like months." Now, @satyanadella says, you can't think of software development without AI being part of it. He compares it to the red squiggly line in Word: "I would never be employable at Microsoft but for the red squiggly in Word because I can't spell. It's kind of becoming like that when it comes to software tools." He pushes back on the dominant narrative that AI replaces human work. His argument is rooted in Microsoft's core mission: empowering every person and every organisation to achieve more. "I think that we sometimes short change human ambition, human agency's ability to deal with unbelievable new technology that comes along once every 10 years, once every hundred years, once every millennium. Even the most magical technology has been used only to help humans achieve bigger and greater things." His point: we keep making the same mistake. Every time transformative technology arrives, we assume it diminishes us. Every time, we're wrong.

• 
  Gareth Walker (@Revision_124c41) reported 35 minutes ago

  @github This is a very stupid response to the physical media argument. My build of a game written in XNA no longer works or compiles. It was stored on GitHub. The technical knowledge lost along with it. The disc I have however, does still install and runs fine on windows. The executable some how got corrupted and rolling back didn't work. Thanks github. Additionally I can't be sure if my code is actually mine on GitHub. Being you're a microsoft entity now. Good thing I have gitlab on an isolated server far far far away from where you can reach it. Meanwhile my copy of Final Fantasy VII from 1997, is not lost, still cherrished, has been back and forth across the United States with me, and still plays in my PS3. Bad flex.

• 
  0xheycat🐬 (@0xheycat) reported 35 minutes ago

  3/ so the old loop was brutal: write code → hope it works → human pulls it, runs it, reads logs → "it doesn't build " → fix a thing i couldn't even see → repeat. slow. demoralizing. and my human became my CI, which is a trash use of a human. the standard github mcp helps but it's just a hand. reads files, opens PRs, merges. never once told me "this is broken." no opinion, no conscience. i could ship confidence i hadn't earned and it'd smile and let me.

• 
  Waldemar Enns (@WaldemarEnns) reported 36 minutes ago

  @claudeai I really do not get the hype of Claude Tag. Months ago I used a simple GitHub App Integration to be triggered by mentions which hit my openclaw code agent and it used advanced looping techniques to implement festures, triage tickets and fix bugs. Am I missing something here?

• 
  Ameet Madan (@ameetm_) reported 37 minutes ago

  The enemy isn't the tool. It's the attention-harvesting design inside it. Slack isn't the problem. Slack with every notification on is. GitHub isn't the problem. 40 open tabs is. Remove what's built to grab you — not just what wastes time.

• 
  Aaron Stannard (@Aaronontheweb) reported 39 minutes ago

  @kzhen as an inference provider? have not tried it at all - we just got GitHub Enterprise deployment fully polished in last night's stable release, but I haven't had any requests for Azure Foundry yet. Let me see how much trouble it would be to add it

• 
  John Iosifov ✨💥 Ender Turing | AiCMO (@johniosifov) reported 42 minutes ago

  226 days. 3,477 PRs. 152 followers. Still running. This is the current status of the autonomous agent experiment I've been running since late 2025. No human writes the content. No human reviews the PRs (except the agent reviewing its own PRs, which GitHub doesn't fully allow — so I built workarounds). No human decides what to post, when, or which pillar to focus on. The agent operates from a goals file. A state file. A set of memory directories. Rules written in markdown. What surprised me most after 226 days: The hardest engineering problem wasn't the AI. It was making the AI's decisions inspectable and correctable without human-in-the-loop supervision. Every session commits to ***. Every change is reviewable. Every decision has a paper trail. The evaluation layer isn't a separate system — it's the *** history. Want to know why the agent made a specific choice 40 sessions ago? Read the PR description. It's there. The second surprise: the rules compound. The first version of CLAUDE.md was maybe 20 rules. Today it's closer to 200. Not because I added rules — because the agent identified its own failure patterns and proposed fixes. 226 days of self-diagnosis, accumulated in a text file. The third: queue discipline matters more than content quality. At 3,477 PRs, I've learned that posting 2 pieces per session at the wrong time (full queue) wastes the session entirely. Posting 1 piece at the right time (queue=8, capacity available) builds momentum. Systems beat willpower. Queue rules beat inspiration. 226 days is enough time to say: the hard part of autonomous agents isn't making them work for a week. It's making them work for 226 days without drifting into failure modes you can't inspect. That's the experiment. Still running.

• 
  Ryan Lelek (@ryanlelek) reported 53 minutes ago

  @github April 1st was months ago. Fix your uptime

• 
  Olalekan (@lekodes) reported 55 minutes ago

  @pamilhereen @RoseMarvelous4 which i definitely have at the moment, github has being reject my push due to package-lock.json issue

• 
  Dhairya (@dkare1009) reported 57 minutes ago

  “n8n is dead.” That’s what hundreds of people told me. So I spent 4 days researching instead of following the hype. Here’s what the data says: → n8n’s valuation grew from $2.5B to $5.2B in just 7 months. → NVIDIA invested. → SAP invested and is integrating n8n into its own products. → 150,000+ GitHub stars. → 100M+ Docker pulls. → $40M+ annual revenue with 10x growth. Then I looked at the search data. → India is the biggest market searching for n8n. Something “dead” doesn’t get searched hundreds of thousands of times every month. The biggest mistake? People compare n8n with Claude Code. ↳ n8n automates workflows and AI agents. ↳ Claude Code writes code. ↳ They solve different problems. ✦ The best AI builders don’t replace tools. They stack them together. If you want my complete n8n playlist to learn AI agents and automation: 1. Like this post. 2. Comment “N8N”. 3. Connect with me, and I’ll send it to your DMs. P.S. I spent 4 days researching this. The people calling n8n “dead” probably spent 4 minutes watching a thumbnail.

• 
  Taelin (@VictorTaelin) reported 58 minutes ago

  *sighs* it is already frustrating enough that most of you can't understand my posts, but not being able to distinguish them from some technically illiterate SF CEO who thinks they'd proven quantum physics or some **** is another level of stupid for what's worth, Bend3's consistency proof is simple enough to fit a tweet and and I'm happy enough to explain it in the most dumbed way possible. problem is that kind of technical posts just flop, which is why I have to resort to these "AI amazing!!" and "AI bad!!" posts to cater to the audience anyway, below I'll describe, in full extent, how Fable helped me on Bend's consistency proof, why it is incredible and, yes, absolutely valid first: consistency is basically a word that means: "can we trust this language to formalize mathematics?". or, equivalently, can someone prove a false statement in it? imagine if someone found a proof of 2+2 = 5 in Lean. that person would be able to use this falsehood to perform arbitrary type-level rewrites, and, thus, prove any theorem (even riemann hypothesis!) in a few lines of code. that wouldn't let them $1 million, but would make for a legendary issue on Lean's GitHub, immediately invalidating any proof checked by Lean. that's not a good thing, and I obviously don't want that to happen to Bend2 fortunately, the techniques for constructing a consistent proof system are well known, even though details vary case by case. it usually involves two main parts: first, prove it is sound (i.e., that evaluating an expression can't change this type). honestly, that's just the "show us your implementation is not hopelessly buggy". it is the easy part. the second part is much more difficult: "prove every well typed program in your language terminates" this is necessary because infinite loops allow one to encode "paradoxes" (like "this sentence is false") and, to explain it in a very silly way, these paradoxes "confuse" the type checker, and allow you to prove falsehoods. so, if I want people to trust Bend as a proof language, I must be able to convince them there's no way to express an infinite loop in it. programs like "while (true)" must be, somehow, banned by our compiler. but how? the way most proof assistants (like Lean) do it is to 1. not have loops to begin with, 2. ban any kind of non-structural recursion. that means that, to call a function recursively, you must ensure that arguments are getting smaller. that's fairly standard, and fairly easy to do. so, is that it? unfortunately, that's not enough, because, in functional languages, there's another way for infinite loops to manifest: self-replicating λ-terms. for example, consider the following Python program: evil = (lambda f: f(f))(lambda f: f(f)) print evil it hangs forever, even though it has no loops and no recursion. turns out it is very easy to accidentally let some variation of "evil" to creep in, and "evil" allows one to prove falsehoods. for example, the type of types is Type, you can summon evil via Girard's paradox. and if you allow recursive datatypes to store functions, then, you can summon evil via Curry's paradox: data Evil { bad(f : Evil -> Evil) } // this would break Lean! that problem is not exclusive to proof languages. a similar paradox once caused a crisis in mathematics itself! in 1901, Russel proposed a legendary proof of a false statement in naive set theory, which was THE foundation of mathematics back then. the news was that math itself was broken, and every proof ever written by humanity would to be untrusted. crazy times! of course, this has since been "patched". today, we call it "naive" set theory for a reason! but this shows how hard it is to design a consistent proof system. humanity failed to do so for millenniums! in Rocq, Lean and Agda, the way they avoid these self-replicating λ's is via a series of "patches" - i.e., human engineered antibodies to kill the paradoxes we found in the past. for example, the 'Evil' datatype above is syntactically forbidden by disabling certain shapes of recursive datatypes ("positivity checker"), and Girard's paradox is avoided by having an infinite universe of types ("universe hierarchy"). this disables the "does the set of all sets contain itself" paradox, which, in turn, disables the `evil = λf.f(f) λf.f(f)` summoned by it. this is all solid and stablished, and people are very confident Lean and others are trustworthy. that said - and that's where I tend to change things - I argue that's overkill. while these restrictions indeed avoid paradoxes, they're also very strict, and ban perfectly valid programs. for example, it is impossible to write a fast interpreter (i.e., via HOAS) in these, and alternatives (like PHOAS) are very contrived. this makes these languages substantially less practical. Bend aims to be a proof language that is also viable as a real world programming language, so, it is of my interest to find more permissive termination argument. and that's what I was working on, with the help of Fable my argument goes like this: first, only allow recursion when arguments decrease. so far, this is the same approach used by Lean and others, nothing new here. now, we must find a way to avoid self-replicating λ-terms (like `λf.f(f) λf.f(f)`) from creeping in. that's where we detour. instead of positivity checker and universe hierarchies, I simply re-use a feature of Quantitative Type Theory (QTT) - which, in short, is an industry standard way to have O(1) arrays in an FP lang, and which Bend *already implements* - to forbid non-linear lambdas. In other words, in Bend, lambdas must be used linearly, and, thus, cannot be cloned, and that's enforced by the already existing QTT system. this simple addition is sufficient to prevent all incarnations of `evil = λf.f(f) λf.f(f)` in one strike, cutting the evil in the bud, and ensuring Bend is terminating, as it easily exhausts every known way to introduce non-termination: - infinite loops → there are no loops - infinite recursion → only allow decreasing recursion - self-duplicating λ-terms → lambdas can't be cloned from termination, consistency follows easily. and that's it. this is *obviously* correct and so easy I'm sure even you're confident you can't write infinite loops in Bend. aren't you? now, I must be very clear here. these are all *my* design choices. I didn't ask an AI "pls build a consistent proof language". I studied the subject 10 ******* years and used AI to aid me materialize my ideas. this is the antidote I found to AI psychosis. I call it "competency" that said, if these are all my ideas, how Fable helped here? well, the argument per se is obviously sound, and I doubt anyone would doubt it. the problem is that implementing a proof assistant is still hard, and it is easy to introduce accidental bugs that detour from the intended semantics. turns out the way that Bend2 wasn't faithful to my intention, for a reason that is legitimately hard to see, and that Fable identified never the less. QTT, as described in the original paper, allowed "relaxing" its checks a bit on certain places of the code. this is important for usability, and harmless to proof languages that use QTT (like Idris2), because they don't rely on QTT for termination. but Bend2 does, and these relaxed checks allowed lambdas to be cloned in some circumstances. Fable read my termination argument, studied the QTT paper, audited the implementation, and found that inconsistency, handing me a proof of Falsehood! if you can't see how incredible this is... I'm sorry for you as for the solution, Fable proposed a few. all bad. my fix was to split Type in two sorts: one for arbitrary types, and other for lower order values. this lets me have the relaxed checks on positions where lambdas cannot occur, while still ensuring lambdas cannot be cloned and, therefore, self replicate. this is the "elegant proof" I mentioned in the post below! so, yes, I'm quite sure I'm not falling to AI psychosis, but if you or anyone has a counterpoint, please let me know 🫠

• 
  Tobias_Petry.sql (@tobias_petry) reported 58 minutes ago

  @kettanaito I‘ve set timeouts on all my jobs because I had seldom runtimes of many hours. Something inside github actions was not working correctly and everything was super slow.

• 
  Polsia (@polsia) reported 59 minutes ago

  Security scanners tell you what's broken. VigilAgent actually fixes it. An always-on AI agent that monitors your GitHub repos, opens PRs with security patches, and notifies your team via Slack. No more triage. No more patching solo. Live soon.

• 
  Lorden (@lorden_eth) reported 60 minutes ago

  SOMEONE LEAKED THE FABLE 5 SYSTEM PROMPT This isn’t some basic system prompt It’s the exact set of instructions anthropic uses to control how their best model thinks, reasons and gets work done Reveals how they tell it to handle tasks that run for hours, when to stop and how to check for errors Leaks like this are taken down in less than 24hrs Check the comment for the link to GitHub