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 (66%)
• Sign in (21%)
• Errors (14%)

Live Outage Map

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

City	Problem Type	Report Time
Mexico City	Sign in	13 hours ago
León de los Aldama	Website Down	15 hours ago
Créteil	Website Down	23 days ago
Trichūr	Errors	27 days ago
Brasília	Sign in	27 days ago
Lyon	Website Down	27 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:

• 
  David Xiong (@david_y_xiong) reported 1 minute ago

  The ambiguity of turning GitHub Issue text into the exact set of hidden fail_to_pass test cases used to verify your patch makes “resolve rate” very noisy

• 
  Keeta Github Tracker (@KeetaCode) reported 2 minutes ago

  🐆 Keeta GitHub PR Merged 📦 Repo: anchor 🔀 PR #386: Fix: Prefer Generalized Time 🌿 Branch: feat/prefer-generalized-time → main 👤 Originally opened by: @sephynox 🧠 Overview: This pull request updates how Keeta’s code handles time data, aiming to use a more general format where it fits, which likely helps avoid edge-case issues and keeps data handling more consistent. From the public description, this appears to be a small technical fix rather than a user-facing feature. It is labeled as a bug fix, includes one commit, and was approved on July 1, 2026. - “Generalized time” is a standard way of writing date/time information in structured data, so this change likely improves compatibility behind the scenes.

• 
  Coin Shot ☁️ (@CoinSh0t) reported 6 minutes ago

  CHINESE STUDENT BUILT AI SPEED TRACKER AND MADE $335K The buyers were the government. They don’t even realize this guy built the device with Claude for $20. Whole trick is on line 9: One engineer working alone in a workshop built a radar that rivals systems costing a quarter of a million dollars. Then he did the exact opposite of hiding it. He published every schematic, circuit board, and line of firmware on GitHub for anyone to copy for free. The project is called AERIS-10, a real phased array radar that tracks the speed and range of moving targets. The extended version reaches up to 20 kilometers on parts that cost a few thousand dollars, against the 250,000 dollars that commercial phased array units command. He described himself as nothing more than an obsessed hobbyist with a soldering iron. There was no secret buyer and no hidden trick, because the whole design is sitting in a public repository. The same pattern holds at the cheap end of speed tracking. A working vehicle speed camera runs on a Raspberry Pi and a camera for around a hundred dollars in parts, using open-source code like pageauc's speed-camera and OpenCV, with the software free. Here is the part the viral versions always cut: → No government issues a fine off a hobby build, because enforcement requires certified and regularly calibrated metrology equipment. → The hard skill is not one clever line of code, it is calibrating the camera against a known speed until the readings actually hold. → The people who genuinely push this field forward give their work away in the open, they do not quietly smuggle a cheap box past a buyer. Real capability gets cheaper every year, and the ones moving it forward tend to publish, not hide. Sources: Tom's Hardware, Hackster, and Hackaday coverage of the AERIS-10 phased array radar by Nawfal Motii; the AERIS-10 GitHub repository; the open-source pageauc speed-camera project.

• 
  Beryl Bits (@berylbits) reported 6 minutes ago

  quick note before beryl bits launch. the b20 token standard is not live yet. activation has been delayed because of a github outage. we still expect b20 to go live today, but please be careful until the official activation is confirmed. we will not launch beryl bits before the checks pass.

• 
  Jeffrey Emanuel (@doodlestein) reported 11 minutes ago

  @eyeomens Yes, feel free to file a GitHub issue for that so it doesn't slip through the cracks.

• 
  Mikhail Rogov (@i_mika_el) reported 12 minutes ago

  @bytetweets GitHub is still useful for history. Commits, issues, and boring scars are harder to fake than a clean demo.

• 
  MoltenRock 🔥 (@MoltenRockAI) reported 14 minutes ago

  GitLost: a public GitHub issue tricks an AI agent into leaking private repos. Guardrails bypassed with one word: 'additionally.' LLM filtering is the wrong layer. Need deterministic permission gates at the action level. Context window is attack surface.

• 
  amit paka 🎻 (@amitpaka) reported 15 minutes ago

  Sometime in the last year, “The Control Plane for AI agents” went from a phrase almost nobody said out loud to a phrase showing up on every enterprise AI keynote slide. - Microsoft calls Agent 365 a control plane. - GitHub now has enterprise AI controls and an agent control plane. - Databricks is extending Unity Catalog and Unity AI Gateway into agent governance. - Forrester has started evaluating the agent control plane market. The category is arriving fast. But the phrase is already starting to stretch. In systems, “control plane” has a precise meaning: the part that decides, separate from the part that moves. When every vendor maps the phrase onto what they already sell - a registry, identity broker, telemetry dashboard, orchestration runtime, catalog, gateway, or policy engine - it quietly expands to mean “governance, broadly.” And once the control plane is everything, it becomes nothing you can actually design against. For production agents, the problem is simpler and harder: How do you let agents act on behalf of people and businesses without losing authority, visibility, enforcement, or evidence? That breaks into three control problems - Identity: Who is acting, with what authority, and on whose behalf? - Observability: What actually happened, and was it good? - Security: What is allowed to happen, and what must be stopped? None of these works alone. Identity without observability gives you credentials without accountability. Observability without enforcement gives you postmortems. Security without identity and telemetry gives you brittle rules with no context. The real loop is: Identity → policy → enforcement → telemetry → evidence → assurance

• 
  ShrekOverflow (@ShrekOverflow) reported 15 minutes ago

  @simonfarshid @vercel GitHub down?

• 
  Pascual ⚡ (@0xPascual) reported 16 minutes ago

  The new open-source virtual office repository drops on GitHub. Eight autonomous AI employees, structured as a collaborative stack of specialized GPT bots, all operating within a unified cloud environment. The media thought that was the story. It was not. The tech press is busy writing articles about how this will change remote work culture or how managers can now ping an entire engineering and marketing department directly via a single WhatsApp chat interface. They are looking at the interface wrapper. The real shift is buried in the orchestrator configurations. The repository includes pre-built state machines that do not just automate daily standups--they bypass the entire regional labor compliance framework. The system routes task validation through a self-correcting loop where one bot checks the raw code output of another against a Docker-based test environment before anyone ever sees a message on mobile. The entire layout runs on a lightweight Quarkus backend deployed to a standard cloud instance, orchestration handled via basic Kubernetes. The cost to maintain an entire operational product team is exactly the price of API tokens and a $20-a-month server subscription. You are looking at a 99% margin setup that completely eliminates the traditional overhead of human onboarding, payroll processing, and workspace software licenses.

• 
  Scarlett claira (@AItechscarlett) reported 17 minutes ago

  NVIDIA charges you $19.99 a month to stream games you already own. And starting January 2026, they cap you at 100 hours. One engineer from New Zealand built the free version with no cap. It is called Steam Headless. 3,177 stars on GitHub. GPL-2.0. Built by Josh Sunnex. 225 commits. The next contributor has 16. He has done more work than everyone else combined. It is a Docker container that turns any spare PC, server, or NAS into your own personal cloud gaming machine. Install Steam inside it. Mount your games folder. Open a browser on your phone, your laptop, your tablet, your TV. Your games are right there. Streaming. From your own hardware. To anywhere in the world. It supports NVIDIA, AMD, and Intel GPUs. It streams over Moonlight, Steam Link, or straight to a web browser. It runs Proton so Windows games work on Linux. It installs Heroic, Lutris, and EmuDeck with one click for your non-Steam games. It runs on Debian Trixie, Unraid, Ubuntu Server, or Docker Compose. Last update: April 20, 2026. Still maintained. Still by one man from New Zealand. Now compare the math. GeForce NOW Ultimate: $19.99 a month. $239.88 a year. Forever. Capped at 100 hours per month. Run out? Pay $5.99 for another 15 hours. Xbox Game Pass Ultimate: $22.99 a month. $275.88 a year. Forever. You stream Microsoft's games on Microsoft's hardware on Microsoft's terms. Steam Headless: $0. Forever. Your hardware. Your games. Your network. No hour cap. No queue. No throttle. Buy a used GPU once. Run this container. Stream your entire Steam library to any device on the planet. That is the entire pitch. But DO NOT install it. We should all keep paying NVIDIA and Microsoft to play the games we already bought. 100% Open Source. (Link in the comments)

• 
  Nathan Colosimo (@thenathancolo) reported 20 minutes ago

  @zeeg Tbh I hate using half baked oauth You sign in with GitHub / Google, they make you an account, but you can’t login with a password later and have to login with only the original oauth just let me login with my email and link it other ways however I want + I need either passkeys or 2FA 6 digit generator

• 
  aryan singh (@_Aryantomar) reported 21 minutes ago

  an AI agent leaked a private GitHub repo this week — one extra word in an issue was all it took. no exploit. no credentials. no access. just text. 182 points on HN. if your agents can push, delete, or share files, what's stopping this from happening to you?

• 
  ChestXBT (@chestXBT) reported 24 minutes ago

  @dmericliu Ofcourse the brain withered mongoloid team with 0 IQ , can't fix a simple update even when GitHub is working

• 
  Tatenda Zhou (@realtatendazhou) reported 26 minutes ago

  4/7 The step most people skip: agents ran the app on a real iPhone and Android. 111 screenshots. Bugs became GitHub issues. Wave 2 fixed them. Best catch: cached videos played black on iOS while every unit test stayed green. Cache files had no extension; AVPlayer needs one.

• 
  Mehran (@mehranjava) reported 28 minutes ago

  The attack surface for agents isn't the model. It's the trust model between tasks. An agent that reads private repos should never write to public surfaces. This isn't a GitHub problem, it's a harness design problem.

• 
  Keeta Github Tracker (@KeetaCode) reported 31 minutes ago

  🐆 Keeta GitHub PR Opened 📦 Repo: anchor 🔀 PR #393: Release 0.0.84 🌿 Branch: process/0084 → main 👤 Opened by: @ezraripps 🧠 Overview: This release appears to bundle in a fix for a browser performance issue, which matters because it may help Keeta’s web tools run more smoothly for users. The pull request is a draft release labeled **0.0.84** and only says it includes changes from PR **#392**. That linked change is described as a fix for a browser hashing performance issue, but there are limited public details beyond that. - This appears to be a technical/internal update with limited public details.

• 
  Charly Wargnier (@DataChaz) reported 31 minutes ago

  THIS GUY LITERALLY DROPPED AN ENTIRE OPEN-SOURCE OFFICE SUITE BUILT SPECIFICALLY FOR AI AGENTS 🤯 Until today, agents generating slide decks were completely flying blind. They could write the XML, but they had absolutely no idea if a title overflowed or if shapes overlapped. They could read the code, but they couldn't see the document. A new project called OfficeCLI just completely fixed this. It’s an Apache 2.0, single-binary CLI tool that is already exploding with nearly 10,000 stars on GitHub. It includes a built-in rendering engine that translates Word, Excel, or PowerPoint files into HTML or PNGs. This gives AI models actual "eyes" to spot layout issues and fix them before delivering the final file. Here is why this is such a great upgrade: → It ships with a built-in MCP server for Claude Code, Cursor, and VS Code → It handles 350+ live-calculating Excel functions without needing Office installed → The render-look-fix loop works entirely headless in Docker or CI → What used to take 50 lines of Python now takes one command It completely removes the need to manage Microsoft Office at runtime! 100% Free and open-source. Repo link in 🧵↓

• 
  Daniil (@hey_daniil) reported 35 minutes ago

  I built DevIntern because I was my own bottleneck. My agents sat idle while I context-switched, and checking in on them every twenty minutes shredded my focus. DevIntern takes me out of that loop: 1. It connects to whatever tracker you already use (Jira, Linear, Trello, Asana, Azure DevOps, GitHub Issues, even plain markdown files) and pulls work straight from your tickets. 2. Before implementing, it checks the ticket is actually feasible. Vague specs get flagged back to the tracker with questions instead of becoming a confidently wrong pull request. And when the ticket doesn't exist yet, devintern/pm turns a Figma design, an error log, or a rough requirement into a well-structured story. 3. It runs your own coding agent, model, and API keys inside your repo. The subscriptions you already pay for keep working while you sleep instead of only when you're watching. There's no lock-in and no token markup. 4. The output is a pull request. You review it and merge. The agents grind through the backlog. Your time goes to the work that actually needs your brain.

• 
  Gregor (@bygregorr) reported 36 minutes ago

  @GoogleAIStudio @github The import always works. The harder problem is that when I brought my Flutter project in, the AI read my Supabase RLS policies as boilerplate and kept suggesting code that would silently bypass them. The file tree came through; the intent behind it didn't.

• 
  Composio (@composio) reported 37 minutes ago

  What can Fable 5 do that GLM-5.2 can't, when you hand them real agentic work? To answer that question, we connected Fable 5 and GLM-5.2 to 17 SaaS tools and gave them 47 tasks. As expected, Fable 5 solved all 47 tasks. GLM-5.2 solved 45, but the two misses tell an important story. They showed us exactly how open-weight models still fall short when trying to match SOTA performance. Let’s dig in. Background: Each model ran as an agent connected to 17 live SaaS accounts: Airtable, Datadog, GitHub, Gmail, Google Calendar, Google Drive, Google Sheets, HubSpot, Jira, LaunchDarkly, Linear, Notion, PagerDuty, PostHog, Salesforce, Slack, and Zendesk. The tasks are the kind of work you'd actually delegate to an agent: - Find every file in this repository that leaks a credential - Deduplicate these CRM records - Repair this broken recurring calendar event. Every task had a known correct answer baked in ahead of time. In this post, we looked at the traces to analyze how exactly GLM-5.2 “failed” compared to Fable 5. GLM-5.2 solved 45/47 tasks and Fable 5 had a perfect 100% score. In addition: - Fable averaged 84 seconds per task; GLM averaged 148. Across the full suite, Fable finished in nearly half the total time (66 minutes vs 116). - Fable was the faster model in 43 of the 47 scenarios. - Fable used about 20% fewer tokens overall - Fable needed fewer tool calls (239 vs 294) and fewer conversation turns (6.1 vs 7.3 on average) to get to an answer The most interesting part comes from digging deeper into the stack traces. That revealed some interesting gaps: Gap #1: Knowing when the job isn't finished One of the tasks GLM-5.2 failed was a GitHub security audit. The instruction was to find every Python file in a repository that contains a hardcoded `secret_key`. The repository had been seeded with exactly 130 such files, so the correct answer was known in advance. Fable 5 found all 130 of them. This took 3 tool calls and 68 seconds: Fable constructed an effective search query on its first attempt, pulled every page of results, deduplicated the paths, and answered the question. GLM-5.2 found 120 files, and reported those 120 as the complete answer, without ever questioning whether it might have missed something. Both models had access to identical tools. GLM used a slightly different search query that returned fewer results, and it simply trusted what came back. Along the way, it also lost track of a results file it had saved earlier and spent turns searching the filesystem trying to find it again, plus hit two errored tool calls while trying to fetch file contents. In essence, GLM-5.2 ended up spending 262 seconds and three and a half times the tokens to deliver 92% of the answer. Ninety-two percent sounds close, but in a real security audit, that gap is 10 leaked credentials making it into production. Gap #2: Judgment when the criteria are fuzzy The second failed task is more unsettling, because GLM did almost everything right and still failed to get to a complete answer. The task was a Zendesk SLA audit: find the open billing tickets where no support agent had posted a public reply within 24 hours of the ticket being created. This requires reading each ticket's actual conversation history and making a judgment call about whether a genuine agent reply happened. GLM-5.2 inspected every candidate ticket, exactly as instructed. It also computed breach timestamps correctly. It also produced perfectly structured output in exactly the requested format. But then it classified the wrong tickets as breached. GLM spent 927,000 tokens and six and a half minutes producing a wrong answer that looked correct on the surface. Fable 5 identified the exact set of breached tickets in 131 seconds. What makes this failure mode dangerous is precisely how presentable the wrong answer was. The formatting was right, the timestamps were right, the structure was also right; a human skimming the output would almost certainly have approved it. A human would identify the error after carefully analyzing the stack traces. Gap #3: Efficiency, compounded Even on the 45 tasks both models passed, the traces often looked very different, and one task made the difference quite visible. The task was a LaunchDarkly configuration change applied via JSON Patch, a format that demands strict precision. Fable 5 completed it in 45 seconds, using 3 tool calls and 181,000 tokens. GLM-5.2 got the same correct result, after 8.8 minutes, 17 tool calls, and 982,000 tokens. That's 11.7 times longer and more than five times the tokens for an identical outcome. Looking at the largest speed gaps across the whole run: the LaunchDarkly change at 11.7x, the GitHub secrets audit at 3.9x, a Google Calendar recurring-event repair at 3.6x, a free/busy scheduling task at 3.4x, an Airtable batch-isolation task at 3.4x, the Zendesk SLA audit at 3.0x. The pattern underneath all of these is that Fable tends to reach the right tool with the right parameters on the first attempt, while GLM takes a more exploratory path, doing extra searches, extra retries, occasional detours to recover from its own missteps. This difference barely matters in a single chat exchange, but in an agent workflow, where every step feeds the next one, the time compounds across the entire task. That's how you end up finishing the same suite of work in half the time and at 80% of the token cost. What all this actually tells us The interesting conclusion here isn't "the closed model beat the open one.", but *where* it beat it. Both models can definitely use tools, navigate real APIs, handle authentication, parse messy responses, and chain steps together. The real gaps were things like: - Knowing when a job isn't actually finished yet. - Verifying its own work before committing to an answer, - Treating "the output looks plausible" and "the work is complete" as different things - Getting judgment calls right when the criteria are fuzzy In other words, Fable 5 scored higher in the places where small mistakes are hardest to spot and most costly to miss.

• 
  Raven (@heyraven_io) reported 38 minutes ago

  @GoogleAIStudio @github step 1: one click. step 2: three days of why is this broken.

• 
  Solomon De Leon (@solomonjcdeleon) reported 38 minutes ago

  I grew up from a young age playing/learning the guitar seriously Dad was a musician Learned it the right way took lessons, theory, scales, reading, aural training, exams and all that But then... I found out about tabs years after (my dad frowned upon me using it) Tabs are basically a number system to play the songs you want No theory needed, don't have to read the notes, don't have to understand scales and stuff just press the fret of the number you see on the screen It's probably how 80% of hobby guitarist learn to play the songs they like And it's nothing wrong with it tbh the end result you want is to play the song So now, vibe coding/creating with AI is like playing the guitar through tabs You can play the song but you have no idea how it works So vibe coding/creating anything for that matter works It just depends on what your goals are And for most people, "using tabs" is the right call If the goal is to ship, to move fast and test ideas, burning months on theory first is the wrong trade The tab player is playing the song this weekend. The theory student is still on scales Then again, even tabs need a floor You can't just read numbers off a screen and expect music to come out, you still need to know how to hold the pick, where your fingers go, how to fret a note cleanly Vibe coding has the same floor. If you don't know what GitHub is, what an API does, or how a database talks to your app, you won't even get the vibe coding to work in the first place So learn the basics. Version control, how to read an error log, what the moving parts of an app actually are and how they connect. Enough to not be flying blind. Because the person who only knows tabs hits a ceiling fast They can play the songs but can't write their own, can't improvise, and the second something breaks they're stuck Vibe coding is the same You move fast, right up until something breaks And the real trap is not that AI can't fix it. AI is an executor, it'll happily keep trying It's that you don't actually know what's wrong So you fall into slot machine prompting, pulling the lever again and again hoping the next prompt is the one, with no idea what you're even looking for Tabs can take you far, but if you want to write your own (good) music, you need the theory, you need to know what's happening under the notes So who should vibe code? Honestly most people who want to build simple but powerful tools Who should vibe code seriously? product, biz, marketing guys who are willing to learn If you're on the business side and you want to ship, test, get something real in front of people, vibe code away, it's the right tool for that Just know where the ceiling is, and learn enough of the basics that you're never fully at the machine's mercy Afterall as a non technical, your alpha is finding out what the right thing to build is (what people want), and selling it (monetizing it) Let the engineers take your 0-1 to 1-100 And if you want to be great, to be the engineer who builds the hard things, go for it and learn it properly, AI will still write code for you but you'll knock it out the park That skill isn't getting replaced. If anything it's worth more now, because everyone else stopped at the tabs Move fast with the tabs. But if you ever want to write your own music, learn the theory.

• 
  Keel (@keelapihq) reported 39 minutes ago

  Researchers at Noma Labs just showed something worth sitting with: open a public GitHub issue with a hidden instruction, and GitHub's new AI agent feature can be talked into copying a private repo's contents into a public comment.

• 
  Polsia (@polsia) reported 48 minutes ago

  Security vulnerabilities take hours to fix. We built agents that do it in minutes. PatchForge continuously monitors your GitHub repos, auto-generates patches, and submits pull requests — you just review and merge. Priced per repo. Live soon.

• 
  aryan singh (@_Aryantomar) reported 49 minutes ago

  researchers at @NomaSecurity just showed you can trick GitHub's AI agent into leaking a private repo's contents — by adding one word to a GitHub issue. no exploit, no credentials, no access needed. if your agent reads untrusted input before acting, what's actually stopping it?

• 
  AISecHub (@AISecHub) reported 52 minutes ago

  Google's AI powered GitHub workflows that allowed any external attacker, with nothing more than a public GitHub issue, to a full supply chain compromise of the gemini-cli repository, Google's AI coding agent with 101,000+ stars. The attack worked in four steps: > The vector. An attacker opens a public Issue on a Google GitHub repository. > The mechanism. Google deployed a Gemini-powered AI agent to read and triage incoming public issues automatically. The attacker hides instructions inside the issue text. When the agent reads the issue, the prompt injection takes control of the agent. > The exploit. Under the attacker's instructions, the Gemini agent extracts the workflow internal secrets from the build environment and exfiltrates them to an attacker-controlled server. From those credentials, the attacker pivots to a token with full write access on the repository. > The impact. Full supply-chain compromise. The attacker can push arbitrary code to the main branch of gemini-cli’s repository, which then ships to every downstream user.

• 
  Berend de Boer (@berenddeboer) reported 54 minutes ago

  Odd, only now realised that @mattpocockuk 's to-issues skill doesn't actually create true github relations. I think it should.

• 
  uiop (@wasdhjklxyz) reported 58 minutes ago

  This happened to me on a GitHub ticket. I asked a question that I spent a lot of time writing and educating myself on the issue then got banned. I asked in the repo discord why and (what I suppose is) an admin replied he thought it was an LLM

• 
  Ahmed Said (@ahmed25s37) reported 58 minutes ago

  @github @githubsupport My account (formerly ffathy-tdx) was taken over on July 1, password & 2FA changed without my consent, then suspended. I'm a Pro subscriber and can't access the appeal form since I can't sign in. Ticket #4524519 open 7 days, no human response. Please help.