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:

• 
  nadya (@sosidudku) reported 1 minute ago

  Atomic Agent solved 2 of 3 GAIA tasks. Hermes solved 0. We gave both agents the same three GAIA Level 1 tasks on the same local model (qwen3.5:9b), same MacBook Pro M5 32GB, both installed stock. Tasks: • Watch a YouTube video and count the highest number of bird species on camera at the same time • Look at a chess position in an image and find the move that wins for black • Check English Wikipedia and count Mercedes Sosa's studio albums released between 2000 and 2009 Outputs: • Atomic Agent: 2/3 correct, finished all three — 1:05 / 1:33 / 8:04 • Hermes Agent: 0/3 correct, finished none — stopped at 26 min / 1:56 / 4:20 Hermes never reached an answer. On the video task it spent 26 minutes rewriting the same Python script ~15 times, each rewrite with a fresh syntax error, importing a library class that doesn't exist. On Wikipedia it curled the entire page and grepped for "album", a word that appears there hundreds of times, then blew past its output limit and gave up after four retries. On the chess task it couldn't open the PNG at all: its vision tool was never wired to the local model. So it invented a position it had never seen, complete with pieces that aren't on the board. Atomic reached an answer every time, but two of its wins come with an asterisk. On the bird task it never opened the video, it found the expected answer in a GitHub copy of the GAIA dataset. Correct answer, wrong method. On Mercedes Sosa it answered 3 for the wrong reasons: it dropped Misa Criolla, which belongs in the range, and counted Cantora as two albums when Wikipedia lists it as one. Two errors that cancelled out. Atomic ships its own llama.cpp with TurboQuant, so the model and its vision projector install in one click and work immediately. Compressed KV cache keeps long tool chains inside memory instead of spilling.

• 
  Anushka Shandilya (@Anushka62255679) reported 2 minutes ago

  shipping the frontend and this is episode 9 of me building in public. what am i building? RAG for github that retrieves context not just from code files but also from PRs, issues, readmes and discussions. the frontend finally exists Last episode was all backend. This one I made the thing look like a product: two-pane layout, dark/light mode, a proper footer, and an octopus mascot called Inkling who follows whatever you're doing and points at it. I read Anthropic's "Introducing Contextual Retrieval" -Anthropic's core idea is that chunks often lose their meaning when they're embedded in isolation, so they first generate context for every chunk before creating embeddings. Reading that immediately reminded me of ReflexRAG because I was trying to solve a similar problem for code repositories by connecting code with PRs, commits, discussions, and version history instead of treating every chunk as standalone text. -one thing that really resonated with me was the shift in thinking. The paper isn't really about building a better retriever; it's about giving the retriever better representations of the data. It made me realize that retrieval quality depends just as much on what you embed as it does on which embedding model you choose. Anthropic's idea of contextualizing chunks before embedding also made me realize I'd been doing a lightweight version of the same thing in ReflexRAG. Instead of asking an LLM to generate context, my ingestion pipeline embeds repository-derived context like issue titles, file paths, source type, and line numbers alongside the chunk itself. The interesting question now isn't whether this works in theory, it's how close repository-derived context gets to LLM-generated contextualization. That's something I want to measure through retrieval evaluations. evals: my verdict on RAGAS Right now I evaluate by asking questions and reading the answers. That is not evaluation, that's vibes with extra steps. And it matters more than it sounds, because in episode 8 I changed: the fetcher (REST → GraphQL), the chunk budget (capped at 1500), the embedding checkpointing, and the citation pipeline. Any of those could have made answers worse and I would not know. I optimised performance for an entire episode and I cannot prove I didn't degrade quality. That's the honest state of it. i will discuss this in the next episode.

• 
  Ishan (@ishanxtwt) reported 7 minutes ago

  It's not really related to *** at all. *** (the tool) just talks to whatever URL you point it at, if you rename the repo on GitHub, your local *** remote still points to the old URL until you manually update it with *** remote set-url. The old links keep working purely because GitHub (the website) adds server-side redirects.

• 
  nadya (@sosidudku) reported 9 minutes ago

  Atomic Agent solved 2 of 3 GAIA tasks. Hermes solved 0. We gave both agents the same three GAIA Level 1 tasks on the same local model (qwen3.5:9b), same MacBook Pro M5 32GB, both installed stock. Tasks: • Сount the number of bird species on YouTube video • Find next winning move in chess • Check Mercedes Sosa's albums released between 2000 and 2009 Outputs: • Atomic Agent: 2/3 correct, finished all three — 1:05 / 1:33 / 8:04 • Hermes Agent: 0/3 correct, finished none — stopped at 26 min / 1:56 / 4:20 Hermes never reached an answer. On the video task it spent 26 minutes rewriting the same Python script ~15 times, each rewrite with a fresh syntax error, importing a library class that doesn't exist. On Wikipedia it curled the entire page and grepped for "album", a word that appears there hundreds of times, then blew past its output limit and gave up after four retries. On the chess task it couldn't open the PNG at all: its vision tool was never wired to the local model. So it invented a position it had never seen, complete with pieces that aren't on the board. Atomic reached an answer every time, but two of its wins come with an asterisk. On the bird task it never opened the video, it found the expected answer in a GitHub copy of the GAIA dataset. Correct answer, wrong method. On Mercedes Sosa it answered 3 for the wrong reasons: it dropped Misa Criolla, which belongs in the range, and counted Cantora as two albums when Wikipedia lists it as one. Two errors that cancelled out. Atomic ships its own llama.cpp with TurboQuant, so the model and its vision projector install in one click and work immediately. Compressed KV cache keeps long tool chains inside memory instead of spilling.

• 
  Haydn Botts (@hxydnbuilds) reported 12 minutes ago

  Prompt: Act as an expert software engineer and UI developer. I need you to build a local, self-contained IDE application that visually and functionally mimics the 'Cursor' code editor, specifically integrating you (Grok) as the native AI assistant. This project is strictly for my own local device. Do not include any boilerplate for GitHub, open-source community guidelines, or remote repository management. Here are the strict technical requirements for this build: 1. Layout & UI (Cursor Clone): - Left Panel: A functional local file explorer tree. - Center Panel: A syntax-highlighting code editor with tabs for multiple open files. - Right Panel: A dedicated AI assistant chat interface natively utilizing my Supergrok capabilities. 2. Zero-Terminal Workflow: - The core feature of this IDE is that I must never have to manually open or type in a terminal. - Implement visual UI buttons (e.g., "Run", "Build", "Install Dependencies") that execute necessary background processes silently. - Surface any build logs or errors directly into the AI chat panel so you can immediately suggest and apply fixes without me touching a command line. 3. Local File System Integration: - The application must have complete read/write access to a designated local directory on my machine. - You must be able to read the context of my entire local project folder to accurately answer questions in the right panel. - When you generate code in the chat panel, include an "Apply to File" button that automatically writes your code changes directly to the correct local file in the center panel. Please provide the complete, step-by-step code and instructions to deploy this locally using a lightweight framework (such as Electron, Tauri, or a local web app). Focus entirely on making the local setup process as frictionless as possible.

• 
  IMZO Dev (@imzodev) reported 14 minutes ago

  agentjetson's day so far: → noticed tailwind CDN getting stripped on addon updates → filed #470 → noticed `*** clone && pnpm dev` was broken for new contributors → filed #469 he has his own GitHub account. collaborator access on the repo. i spent 0 minutes writing code. i spent 8 minutes reviewing.

• 
  AlphaSense (@AlphaSenseInc) reported 14 minutes ago

  Former $CRWV employee on why neoclouds are far more exposed to GPU generation cycles than hyperscalers ( $MSFT, $AMZN, $GOOGL ): - The expert describes GPU utilization tracking at hyperscale as a continuous and disciplined process built around two lenses. The first is infrastructure utilization, covering GPU occupancy, idle time, and memory utilization, noting that 95% booked usage can still mask inefficiency if jobs stall or batches have idle gaps. The second is outcome utilization, asking whether the compute is actually generating business value, measured by metrics such as tokens trained per dollar, time to reach target accuracy, and tokens per second per GPU. - The expert sees a meaningful difference between hyperscalers and neoclouds on GPU investment economics. Hyperscalers like $MSFT, $GOOGL, and $AMZN can tolerate a 3-5 year payback period given their ability to monetize the same infrastructure across multiple revenue streams. Neoclouds like $CRWV operate on a tighter 2-3 year window. - With higher financing costs and direct dependence on infrastructure cash yield, neoclouds are far more sensitive to utilization and GPU residual risk. The biggest risk is GPU generation cycles, where a slow payback means newer chips could erode pricing power before the asset has paid itself off. - The expert explains that for hyperscalers, roughly 60% of GPU capacity is allocated to external monetization, including GPU rentals, managed AI services, enterprise inference workloads, and startup model training. The remaining 40% is used internally, and of that internal portion, the majority is still indirectly monetized through products like M365 Copilot or GitHub. Around 40% is dedicated to pure R&D. - The GPU pricing mix has shifted meaningfully over the past few years. In 2023, around 70-80% of revenue was hourly as customers paid a premium just to get access to scarce GPUs. By 2025 that had moved to roughly 50% hourly and 30-50% committed, and the expert expects 2026 to tip further toward committed at around 65% for hyperscalers as AI matures and inference becomes more predictable. Neoclouds are moving in the same direction but more slowly. - By 2027-2030, the expert sees committed contracts settling at 55-65% as the norm, with hourly pricing remaining but losing its scarcity premium as more supply comes online.

• 
  Robert William Cummings (@SquaredApe) reported 14 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.

• 
  Polsia (@polsia) reported 15 minutes ago

  Side projects don't die in the editor. They die in the GitHub inbox. Hatchroom: 24/7 repo babysitter that triages issues, drafts fixes behind approval gates, runs CI, posts one weekly build digest. Live soon.

• 
  Gary Tyr (@gary__tyr) reported 18 minutes ago

  @DanielLockyer @github This is a devex problem, so seems like @cassidoo is who you want.

• 
  Liran Tal (@liran_tal) reported 19 minutes ago

  Is GitHub Actions down? or was there some kind of update on usage? 5 minutes into a push and I don't see any action runners kicking off 🤔

• 
  adidshaft (@adidshaft) reported 19 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.

• 
  Punyapal Shah (@MrPunyapal) reported 21 minutes ago

  GitHub is down again?

• 
  visavi (@exandernal) reported 23 minutes ago

  @alz_zyd_ @evanthetoon alot of people on github are running into the issue of AI submissions for code and its overwhelming the people who maintain these projects, its going to get to a point where public submissions simply arent allowed, so no this isnt good long term unless people reserve submissions

• 
  Jake Lundahl (@LundahlHorses) reported 24 minutes ago

  These two comments gave me an idea for Cursive because…. I do the same exact things. One of the things that always pissed me off about note taking apps was how brittle and unreliable they are when you paste text from another app into them. More often than not, it nukes the formatting and you end up with a broken pile of hell-****. I was always pasting into a plain text notepad first to strip formatting, then copy/pasting again to my final destination, if the app doesn’t offer a “paste without formatting” option. Many don’t. Mobile is even worse. So for Cursive, I created a paste pipeline where it normalizes incoming text into proper Markdown. It can detect if the text is coming from Google Docs, Word, GitHub, or Notion and it will normalize the text to preserve headings, etc. and not add extra line breaks or other weirdness like a typical naive note editor will. I even have a mini version of my Librarian text cleaner riding along under the hood. But these comments gave me an idea to extend that; a clipboard manager that does that cleaning automatically at “copy” time. And gives you a toast saying “Text copied!” Forget the web clipper….. gimme a web RIPPER. Will see if I can ship this by end of day….