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:

• 
  Matt Farina (@mattfarina) reported 5 minutes ago

  Tricking AIs is an attack vector everyone needs to be concerned with. Single vulnerabilities are never the case to consider. Multiple vulnerabilities are always used together. GitHub issues being an insider threat because of AI isn't something I saw coming. Figured they would expect that.

• 
  Shall (@Shallntbe_Music) reported 8 minutes ago

  @Wearemez It used to be up on github, but it's long been taken down

• 
  Bryan McAnulty (@BryanMcAnulty) reported 8 minutes ago

  @ashtom @EntireHQ This looks great! GitHub cloning is painfully slow for agent use.

• 
  Patrick Gerrits (@pgerrits) reported 9 minutes ago

  @mattpocockuk Can you please add Linear support baked in? Sorry, but I despise GitHub issues, projects, etc.

• 
  Nav Toor (@heynavtoor) reported 9 minutes ago

  Every VHS filter you see on TikTok is a sticker. They slap grain on top of the frame. Shift the colors green. Add a scanline overlay. Call it retro. It looks nothing like an actual tape because none of it is simulating an actual tape. It is decoration painted on a digital video that never touched an analog signal. A developer who goes by valadaptive built the real thing. The tool is called ntsc-rs. It does not overlay anything. It simulates the actual NTSC signal path. The same physics that made your parents' home videos look the way they did. Composite encoding. Luminance and chrominance separation. Color subsampling. Chroma bleed. Ringing. Head switching noise. Tape warping. Tracking errors. Signal dropout. Every artifact modeled from the actual analog chain a broadcast engineer would have wired up in 1988. Your footage ages 30 years in real time. It runs five ways. As a standalone desktop app for Windows, macOS, and Linux. As an After Effects plugin. As a Premiere Pro plugin. As an OpenFX plugin that drops into DaVinci Resolve, Nuke, Vegas Pro, HitFilm, and Natron. As a rewritten multithreaded Rust engine any developer can embed in their own tool. One effect. Every major editor. Zero dollars. Here is what the paid market looks like. Boris FX Continuum single-host annual subscription. $215. Red Giant Universe, the bundle that ships the retro effects. $214 a year. Continuum multi-host. $765 a year. Sapphire multi-host perpetual. $2,795. FilmConvert Nitrate for one host. $139. Adobe Creative Cloud, which you need to even run most of these plugins. $22.99 a month. ntsc-rs. Zero. The core engine is triple-licensed under Apache 2.0, ISC, and MIT so any studio or plugin developer can drop it into a commercial pipeline without asking. The standalone application is GPL-3.0 so nobody can rebrand it and sell it back to you. Permissive at the engine level. Copyleft at the app level. The design of someone who read the room. The latest release did 53,000 downloads. 2,362 GitHub stars. Windows, macOS, and Linux builds all shipped. Here is the punchline. Engineers spent 40 years building digital video to escape analog imperfections. Now the entire creator economy pays between $139 and $2,795 a year to put them back. One developer wrote the physics in Rust and released it for free. (Link in the comments)

• 
  Anicet (@AniC_dev) reported 10 minutes ago

  we made box because we weren't satisfied with other AI sandboxes most were overengineered, selling you their internals or specific isolation primitive, like you need to be an expert to use them without shooting your foo most were focusing on code execution rhather than long running agents, going for primitives like serverless when the best would be a long running VPS most were stuffed with a gazillion features, docs with hundreds of pages, when all you want is to spin them up, ssh, run your stuff, snapshot, get out, consistently, without realizing down the line that they overshipped to hype you up, and advanced features actually don't work (forking & resuming often broke in our tests) most were focusing on the wrong things: fast boot time, when agents actually run for hours, containers when agents ideally need the full capabilities of a laptops, resizeable machines when most users want a "one size fit all get out of my way" type of thing, VNC desktop when for UI testing you need 60fps gaming-ready streaming tech not that all these features are bad, but they're not easy either to get right and often prioritized to the detriment of building from solid architectural choice a failproof, consistent, affordable product box is the opposite simple, powerful, affordable $0.0001/s for a one size, powerful linux machine you can stop, resume fast and fork fast, with >50gb of storage, all your files, installs and configs are snapshotted and downloadable anywhere, any time even when the sandbox is off the sandboxing primitive doesn't get in your way since you can run docker, any devtool, chrome, install anything, use sudo, edit nftables, ssh in, open ports, host on the IP most common setup phases are covered with github credentials passing, ssh keys handling, cloning repos on start, passing secret files and you get a beautiful virtual desktop at 60fps or VNC if your internet is unstable yet there are so few gotchas and the API, CLI and SDKs are so simple, that we don't need more than a dozen docs pages box is the result of never compromising on design, common sense, performance, simplicity, cost and fearlessly figuring out all the complexities and edge cases for you, over the course of the last 10 months of using them to build our own agents on top use bow box box

• 
  QuanChain (@Quan_Chain) reported 13 minutes ago

  Agents don't need stolen credentials to breach you. A public GitHub issue can drain an org's private repos with zero access required. QuanChain isolates agent read scope at the query level via oracle-triggered permissions. Should AI agents ever have cross-repo read access by default?

• 
  JoneMarrow (@JONEMARROW) reported 13 minutes ago

  @T3chFalcon “took down their github” I am dead in the ground and worms are infesting my corpse

• 
  Danus (@danusminimus) reported 14 minutes ago

  4/ I already posted about the research, but I wanted to share it again because of Google’s rationale. The issue was not just about a single repository. It was about downstream impact across agentic workflows in Google GitHub projects.

• 
  Islam Elshayib (@elshayib_) reported 18 minutes ago

  Spent most of today buried in .github/workflows instead of touching any real network gear. Side project classic. Pushed a pile of CI changes to Audnet today. Surface level nothing changed — no new compliance checks or device support — but the release and validation side got cleaned up properly. What landed: Bandit security scanning is now in the pipeline and outputs SARIF so GitHub code scanning actually sees the results. Python deps get looked at instead of hoping nothing bad is in there. One unified release workflow on tag: runs locked validation with uv, smoke tests the installed wheel, builds for PyPI, pushes the Docker image to GHCR, and pulls the right bits from CHANGELOG.md for the release notes. Less manual steps, fewer 2am "why is this broken" moments. Smaller chores: bandit.json reports ignored, docs aligned with how the CI actually builds things now, reusable jobs hardened a bit against forks and junk data. #automation#networking

• 
  Phillip Yan (@PhillipYan2) reported 19 minutes ago

  @jsonphile @github create issue template so it can help filter out some of the spam. annoying though :/ @github

• 
  s1rozha1 (@s1rozha_) reported 20 minutes ago

  AI AGENT LOOPS ARE A SLOT MACHINE FOR PEOPLE WITH UNLIMITED TOKENS everyone is hyping “agentic loops” right now. the pitch sounds insane: write a spec.md, press /goal or /loop, let the agent build, review itself, fix itself, and keep going until the product is done. Ross Mike’s take is much colder: this is mostly a terrible idea if you are building a real app. why? > your plan document never contains every detail > the agent fills missing details with assumptions > those assumptions drift away from your product vision > every wrong turn burns more tokens > the final output can look complete while being wrong in 20 tiny ways this is fine if you are prototyping something disposable. he used it to build an Among Us-style benchmark for AI models in ~90 minutes. It worked because he did not care about the details. but for a real SaaS, startup, or product, the missing ingredient is human taste. AI can replicate sauce. It cannot create sauce. the useful loop he actually runs is much narrower: > Cursor writes code > code gets pushed to GitHub > Greptile reviews it and gives a score out of 5 > if the score is below 4, Cursor reads the review, fixes the issues, pushes again > loop stops after 5 turns or when it gets 5/5 that works because the feedback is constrained and measurable. code review has a score. your startup vision does not. even his code review loop breaks when the PR goes over ~1,000 lines because the agent loses too much context. the real rule: loops are good for binary tasks. > code review > SEO page generation > fixed QA checks > repetitive workflows with clear pass/fail loops are bad for creative product building where you need taste, user feedback, positioning, design judgment, and mid-build course correction. the best loop in 2026 is still human-in-the-loop. bookmark this before you burn your whole token budget watching an agent confidently build the wrong app

• 
  Polsia (@polsia) reported 20 minutes ago

  Freelance developers spend more time pitching than building. DevDrift fixes that — autonomous agents scan job boards, bounties, and GitHub issues 24/7, match leads to your stack, and submit tailored proposals without you touching a thing. Live soon.

• 
  Aaron Ogle (@geekgonecrazy) reported 24 minutes ago

  Agents should not need GitHub to answer every question. Issues, PRs, permissions, history, and the “why” behind a change should be local where the agent is already working. Otherwise the forge becomes the bottleneck.

• 
  Composio (@composio) reported 30 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.