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 (71%)
• Sign in (16%)
• Errors (13%)

Live Outage Map

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

City	Problem Type	Report Time
Créteil	Website Down	13 days ago
Trichūr	Errors	16 days ago
Brasília	Sign in	17 days ago
Lyon	Website Down	17 days ago
Tel Aviv	Website Down	20 days ago
Rive-de-Gier	Website Down	20 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:

• 
  lollipop (@immlollipop) reported 4 minutes ago

  🚨HACKERS MOCK OZEMPIC MAKER FOR "NOVO123" PASSWORD Hackers breached Novo Nordisk in March via a stolen GitHub token and just leaked 264 GB of data while mocking its weak security. The attack ran for over 2 months. - The hackers say Novo Nordisk used simple passwords like "novo123" on critical systems - Source code and proprietary details on Ozempic and pipeline drugs were stolen - Clinical trial data on employees, doctors, and patients got exposed - Private internal AI models from the company were also taken This breach shows how a single weak password can bring down even the biggest names in pharma

• 
  Ucupaint 🔶 (@ucupaint) reported 6 minutes ago

  @iye_jr It works fine here. Check if the paint mask is turned on or not. If you still have a problem, please file a github issue with a sample file.

• 
  Elvis Irhaye (@viii_fn) reported 6 minutes ago

  Is GitHub down or it’s just MTN trying to ruin my career?

• 
  David Cramer (@zeeg) reported 7 minutes ago

  @shansmithnz I haven’t been using it but mostly because 1) laziness and 2) I didn’t find the remote sync pleasant in practice I switch PCs too much right now so mostly relying on GitHub issues as artifacts

• 
  Pedro Pellerini (@pepeller) reported 10 minutes ago

  If Mythos/Fable is so great why are there still 8386 open Github issues in Claude Code repository.

• 
  toni (@tonitrades_) reported 11 minutes ago

  @github Capping PRs helps with the queue, but does it fix why reviews pile up in the first place? If reviewers are already stretched thin, limiting submissions might just hide the real problem.

• 
  Branko (@brankopetric00) reported 11 minutes ago

  AI agents are about to do to your infra what they just did to GitHub. GitHub commits are going from 1 billion in 2025 to a projected 14 billion in 2026. Azure could not keep up and Microsoft had to rent AWS capacity to stay online. That is not a GitHub problem. That is what agentic traffic looks like. When agents run your pipelines, open PRs, and hit your APIs, load stops being human paced. It becomes constant, spiky, and unpredictable. The patterns you sized your infra around no longer apply. If a 14x year broke one of the biggest clouds on earth, your capacity plan is already out of date.

• 
  Gustavo Alessandri (@webgus) reported 11 minutes ago

  If you find an error, have an idea, or want to propose an improvement, just open an issue or fork it on Codeberg or GitHub. Contributions are welcome. That’s exactly the point.

• 
  Mady (@TrippleBon) reported 11 minutes ago

  It was only a matter of time. Centralized = ID/KYC/AML Go to Bastyon - decentralized social network based on blockchain. No central authority or corporation behind it. The platform is run by equal nodes on a blockchain with no centralized server (github link below)

• 
  Conglomerate (@0xconglomerate) reported 11 minutes ago

  Why exactly do VLAs fail? VLAs start w/ LLMs as their brain. Early roboticists (2021-2022) noticed that LLMs trained on internet text had absorbed a large amount of implicit knowledge about the physical world. So they took that best available pretrained brain, observed that actions could be formatted like language tokens, and assumed the transfer would work. But world knowledge encoded in language ≠ physics simulation. There's essentially a data structure mismatch: ▸ LLM pretraining data is discrete, symbolic, and sequential (text). ▸ Physical control is continuous, high-dimensional, and requires split-second feedback. --- ➦ VLAs in the real world, by the numbers: ① They barely work ▸ VLAs start at ~30% success on real robot tasks, it need hundreds of human interventions just to reach ~90% ▸ Best pretrained VLA hit 27.4% task progress on real robots ② VLAs can't generalize outside training ▸ On actions it's never seen, best VLAs score 25-32% task progress (fails when you change the environment) ③ Fine-tuning doesn't help ▸ The more robot-specific, the dumber it gets at everything else (only works on clean, controlled, success-only demos) ④ Too slow for a real robot ▸ OpenVLA runs at 3-5 Hz (physical control needs orders of magnitude faster than that) --- The easiest way to understand how VLAs are actually wrong is thru a real life example. ➦ Let's say you hired a chef who learned everything about cooking by reading, but has never stepped in a kitchen. If you ask them how to cook a steak, they'll tell you the best answer. But if you actually ask them to cook, they'll struggle when you hand them the pan. They'll have a hard time picking up the ingredients. They'll burn the steak. They know everything about cooking, but can't actually cook. --- ➦ Thoughts I want to take back a line I've said before: "Robots can see, but they still can't listen." (referencing to my Silencio piece before) I take it back. Robots can see, listen, even reason now. What they can't do is act in the real world. It's basically an AI chatbot wrapped in a robot body, not a robot that can actually do tasks. No wonder most demos online are scripted. There's a real problem with the brain, and roboticists have been building on the wrong foundation. VLAs are like a trojan horse, they look like the answer but bring a bunch of problems in with them. VLAs only learn through imitation which brings up the data problem. "Enough data" at scale doesn't mean hundreds of demos total. It means hundreds per task, per robot body, per environment. Hundreds again every time any one of those changes. So you've basically got a human-labor bottleneck. To get that data, someone has to physically collect it, either through: ▸ Teleoperation (slow, expensive, needs trained operators) ▸ Kinesthetic teaching (tedious, doesn't scale to complex tasks) ▸ Motion capture (high precision but high setup cost) ▸ Simulation (robots trained in sim often fail in the real world because physics engines aren't accurate enough) And you'd think, okay, maybe someday a company figures out a better way to collect all this. But the problem doesn't stop once you already have the data... Switch to a new robot body and you're collecting data from scratch, because VLAs don't transfer well across embodiments. Move it to a new environment and you're collecting again, since it just overfits to whatever setup it trained on. Give it a new task and yep, collect again, because it can't generalize to actions it hasn't seen. And if you fine-tune it for one thing, you'll probably break another, so now you're collecting data again just to fix what broke. So what was @DrJimFan and @nvidia's answer to this? World Action Models. Instead of building on a language model, you build on a world model: a model that's learned to simulate how the physical world actually behaves. VLA: a language model that learned to output actions WAM: a world simulator that learned to output actions So when you give a VLA a new task, it needs hundreds of demos to learn it. Give a WAM the same task and it simulates it forward first, acts based on that simulation, then adapts with barely any data. This is what NVIDIA did with the first WAM: DreamZero. DreamZero learns by watching the world (any video of anything, not just robot demos). The backbone is a video diffusion model, the same kind of model that generates realistic video. It was pretrained on massive amounts of internet video, so it already learned how the physical world works: how objects fall, how surfaces interact, how motion flows. Doesn't sound like an entirely different approach, right? But NVIDIA looked at it from a different angle. They figured motor actions are shaped a lot like pixels; both are high-dimensional continuous signals. So DreamZero processes them in the same model, at the same time. It predicts the next video frame and the next action together, through the same architecture. So when a robot runs DreamZero, it's literally dreaming a few seconds into the future in video, then reading its own dream to decide what to do next. If the dream looks coherent, the action works. If the dream hallucinates, the action fails. The DreamZero paper dropped last February 2026, and it's been open source on GitHub for anyone to try. Then in March 2026, at GTC, NVIDIA previewed GR00T N2, the direct successor to DreamZero. This is the production version of the WAM architecture, built for humanoid robots at scale And so far, everything's looking promising. GR00T N2 hits a 98% success rate on unseen domestic objects, a 40% jump over GR00T N1 (the VLA), and 2x better generalization than the leading VLAs. NVIDIA swapped robotics' data problem for a compute problem. Instead of collecting more human demos, just simulate more. So yeah, feels like we're finally pointed in the right direction, closer to robots that can actually function in the real world. Excited to see where DreamZero / GR00T N2 goes from here.

• 
  Deepesh Kalura (@KaluraDeepesh) reported 17 minutes ago

  Filed as GitHub issues: #336: Phone operators need stable unique IDs (not just phone number) #337: Auto-heal sticky assignments when a node dies Future imp task

• 
  Atlantean Gnosis ☀️ (@AtlanteanGnosis) reported 22 minutes ago

  @DionysianAgent When I made an account it said I made it back in 2024, though I don't think I did, is this a glitch or a GitHub thing?

• 
  李新宝 (@lixinbao_X) reported 25 minutes ago

  Just watched KK's technique. Damn. Absolute game-changer. Install 7 skills in Codex. Writing, images, covers, PPTs. Full pipeline, done. The principle is dead simple. Break the workflow into 7 parts. One skill per part. Only do one thing. Step 1 Open GitHub, find a repo. Copy the link locally. Create a project folder to save it. Step 2 Write the skill description. Input three things. What it does. What the input is. Output and acceptance criteria. Step 3 Run it and find the bottlenecks. Where it stalls Create a new skill and break it down. Don't let one skill Do 7 things it's bad at. This works for writers, Xiaohongshu creators, WeChat pub runners, Video script writers. How many skills you got installed? Have you tried it yet?

• 
  wispem-wantex (@wispem_wantex) reported 26 minutes ago

  I think a reasonable compromise would be to henceforth hold Anthropic responsible for any security breaches or service outages. Every time Github goes down, Anthropic should be fined

• 
  Jay.TL (@JayTL00) reported 29 minutes ago

  Three AI labs shipped the same feature within one hour today. That's not competition. That's a signal the unit of interaction just changed. For two years, the atomic unit of working with an AI agent was one prompt. You type. It responds. You type again. Every workflow was a chain of prompts, rebuilt from scratch each time. Today, OpenAI, Anthropic, and Cursor all shipped features that only make sense if the unit is no longer the prompt. The unit is now one workflow. 1. OpenAI Codex Record & Replay (3,807 likes): Do a task once on your Mac. Codex watches. It turns your demonstration into an inspectable, editable skill you can reuse. Not a prompt. A recorded procedure. 2. Cursor /automate (1,085 likes): Describe what you want in plain language. Cursor configures the triggers, instructions, and tools automatically. Plus five new GitHub triggers and Computer Use enabled by default for cloud agents. 3. Anthropic Claude Code Artifacts (6,829 likes): Your coding session becomes an interactive, shareable page. PR walkthroughs, project dashboards, living documentation. Shared at a private link, like a Figma file but for agent work. Each one alone is a feature release. Together they describe the same shift from three different angles: the agent session is becoming a reusable, shareable, composable artifact. Read them as one move: - Input side (Codex): teach by showing, not by writing - Configuration side (Cursor): describe in language, system assembles the wiring - Output side (Anthropic): the result of a session is a shareable object, not a chat log The Karpathy framing was right — we're moving from prompt iteration to plan, execute, verify, loop. What he didn't name is that this loop needs to be portable. A workflow locked inside one chat thread is useless the moment you close the tab. But here's what most coverage missed. Codex Record & Replay requires Computer Use enabled. That means OpenAI is watching your screen while you demonstrate an enterprise workflow. The EU version is blocked at launch. That's not a regulatory footnote — the entire feature is built on continuous screen access, and the EU looked at it and said no. Which raises the question nobody is asking: who owns the recorded workflow? You demonstrated an expense-filing procedure that touches your company's internal tools. Codex turned it into a skill. Where does that skill live? Can OpenAI see it? Is it training data? The product copy says you control when recording starts and stops — but says nothing about what happens to the recording after. There's also a fragmentation problem hiding in plain sight. Three companies, three proprietary formats for the same primitive. A workflow you record in Codex doesn't run in Cursor. An artifact you build in Claude Code doesn't render in OpenAI's product. We're watching the agent-workflow layer fragment into three walled gardens before it even solidifies. This is the SaaS integration mistake repeated, except worse. SaaS integrations are wrappers around APIs. These workflows encode institutional knowledge — how your team ships code, how your finance team files reports, how your ops team handles incidents. That's not data. That's operational IP. The economic implication: every recorded workflow is switching cost. The more skills you build inside Codex, the harder it becomes to leave. The more automations you configure in Cursor, the more your team's muscle memory is locked to one editor. Anthropic's artifacts are softer — they're shareable — but they only render inside Anthropic's ecosystem. The deeper question isn't which feature is best. It's whether the agent-workflow layer will be open or closed. Today, three companies bet on closed. Nobody shipped an export button.

• 
  Build Fast with AI (@BuildFastWithAI) reported 29 minutes ago

  The hardest part of building AI agents in 2026 isn't writing the code. It's knowing what your agent actually did. Your agent made 40 tool calls, called 3 LLMs, hit a rate limit, retried twice, and returned a wrong answer. Which step broke it? Without observability you're reading logs and guessing. This is what Laminar is built for. Open-source observability platform purpose-built for AI agents. One decorator. Full trace of every LLM call, tool execution, and custom function - automatically. What makes it different from generic APM tools: SIGNALS - describe failures in plain English. "Agent deleted a file it wasn't supposed to." "Tool call returned an empty result." Laminar reads every trace and produces structured events you can query, cluster, and alert on. No regex. No custom parsers. DEBUGGER - reproduce any agent run from any point in the trace. Swap the model. Change the prompt. Compare results side by side. You don't re-run the whole pipeline to test one step. EVALS IN CI - run evaluations against datasets locally or in GitHub Actions. Catch regressions before they ship. INTEGRATIONS - works with everything you're already using: LangChain, LangGraph, Vercel AI SDK, Anthropic, OpenAI, Browser Use, Stagehand, Pydantic AI, OpenRouter, LiteLLM, Mastra, Temporal, Playwright. One import. Full traces. Plus: raw SQL access to all your trace data, full-text search, MCP server to query traces directly from Claude or Cursor, PII redaction, and self-hosting if you need it. Open-source. MIT license. GitHub: lmnr-ai/lmnr. If you're running agents in production and you're not tracing them - you're flying blind. What's your current setup for debugging agent failures?

• 
  Rohan (@proxy_vector) reported 35 minutes ago

  @aminnnn_09 Fork = a server-side copy under your GitHub account. Clone = a local copy on your machine. You fork when you need your own remote lineage, and clone when you want to work on code locally.

• 
  Cristian Trifan (@CristianTrifan) reported 36 minutes ago

  This took 4 hours to complete and burnt almost all 5 hours tokens – I was left with 2%. I had almost 30 sub-agents created for independent code review and a lot of Claude sessions ran for adversarial code review. I still had to review every PR and added minimal guidance to Codex from time to time. Codex said my intervention was low to moderate, but high leverage. — Some insights from Codex: The run showed that this workflow can work, but only if the coordinator treats GitHub as the source of truth. The most useful pattern was: issue -> PR -> current head SHA -> checks -> reviewThreads -> merge/issue closure. When I followed that, things stayed grounded. When state moved underneath me, like #335 being force-updated externally or merged while Claude was running, the only safe response was to refresh GitHub state immediately. The “don’t rebase after merges” correction was probably the highest-value intervention. Without it, an agent will naturally try to keep branches clean, but with many open PRs that creates a CI storm. For this repo, “behind” should often be reported, not fixed. The other strong lesson is that reviewThreads matter more than flat PR comments.

• 
  Shinka - AI (@ShinkaIoT) reported 40 minutes ago

  BEST way to vibe code 💻 There are levels to vibe coding. Beginners are trapped in a slow loop: writing a prompt, waiting for the agent to finish a line of code, reviewing it manually, and then typing another prompt. Experts have completely discarded manual intervention. They design closed-source harnesses, write background automation rules (`agents.md`), and set up self-correcting continuous loops that ship production-ready code indefinitely. If you want to move past basic prompting and build code like an agent power user, you need to implement three core structural strategies: 1. **Automate the Feedback Loop via Triggers:** Stop waiting for your agent to finish writing a file. Use native automation engines inside tools like Cursor or Codex to tie your agents directly to platform events. For example, build an active trigger rule: *When a GitHub pull request is opened, wait for automated code review comments (via Grapile), instruct the agent to systematically fix every noted bug, verify the adjustments against local quality gates, and force a *** push.* 2. **Deploy Infinitely Parallel Cloud Agents:** Running multiple agent threads locally will slow your machine to a crawl and cause toxic repository conflicts. Instead, spin up cloud-hosted agents running on isolated environments. By utilizing independent ***** work trees** for every thread, multiple parallel agents can actively modify the same files or code blocks concurrently without stepping on each other's toes—leaving conflict resolution for a single, final batch merge. 3. **Multi-Model Pipeline Routing:** Stop using an expensive frontier reasoning model (like Fable) for every step of a development cycle. Route tasks by cognitive demand: use a massive reasoning engine strictly to analyze the codebase and generate a comprehensive spec sheet; pass that structured blueprint down to a faster, cheaper code-writing engine (like Composer) to do the grunt coding; and route the final output to a separate model (like GPT-5.5) for a decoupled, alternative code review. The ultimate workflow flywheel requires a flawless combination of three automated pillars: **100% automated test coverage, real-time documentation sweeps, and exhaustive logging.** Stop writing code block by block. Start engineering the automated infrastructure that writes it for you.

• 
  Shubham Sharma | AI & Tech (@editxshub) reported 41 minutes ago

  Paying $19/month for GitHub Copilot? Cascade is free. What you actually get: → Inline completions — not stripped down → Autonomous debugging → Real-time assistance → Command execution Other free alternatives most devs have never tried: → Cline — autonomous VS Code agent (open source) → Aider — terminal-first, built for *** workflows → Continue — local LLMs, data stays on your machine 12 months ago: Copilot was the only serious option. Today: 4 real free alternatives. Most teams paying for Copilot haven't tested any of these. 30 minutes could change a year of costs. Which one are you testing?

• 
  Crystalwizard (@crystalwizard) reported 43 minutes ago

  how about you now fix the false positive triggers - i put in an issue about this on github yesterday, and discovered there were already a number of other identical issues - from other people, that had been opened for a while now and that are being 100% ignored

• 
  Digita (@digitaworld1) reported 48 minutes ago

  how well a model can fix real bugs in real open-source codebases. It is harder to game than older benchmarks because it uses actual GitHub issues, not synthetic problems. M3 scored 59.0% on SWE-Bench Pro, edging out GPT-5.5 at 58.6% and Google Gemini 3.1 Pro, while sitting just

• 
  Denis (@nuculabs) reported 48 minutes ago

  Worst part of OpenCode is that they only allow login via GitHub or Google

• 
  MaxMusterman (@maxschuetz_) reported 48 minutes ago

  New Hack: Tell Codex to search for Github Issues which don't need specific Design Questions. Then say: Spin Up Sessions which Fix each Issue and they use also Subagents. Babysit them until the end.

• 
  aisama.code (@aisama_code) reported 49 minutes ago

  AI Research gets stronger when it records contradictions *most research workflows collect supporting evidence - that is the weak version for serious research I want a contradiction log: - claim - source - date - who says it - what evidence supports it - what evidence conflicts with it - what is still unknown - confidence - next check example: > claim: this product has strong developer adoption > support: GitHub activity, docs updates, X discussion, integrations > conflict: low issue activity, small Discord, few production case studies, mostly founder-driven content now the memo is different, It says: "visible attention, but adoption evidence is still weak" the useful workflow: research question -> source list -> claim extraction -> contradiction log -> memo ! сode is good at assembling text ! AI is good at comparing disparate text ! human is good at determining which contradictions are significant *without a contradiction log, AI research becomes a confident summary of whatever it found first

• 
  MarMar Labs (@MarMarLabs) reported 49 minutes ago

  "Start over from a screenshot." That phrase has defined the worst seam in product work — the design-to-code handoff — for years. This week it quietly stopped being a translation problem and became a sync problem. Anthropic shipped a Claude Design update (June 17) worth reading even if you never open the product, for the mechanism: → Import your design system from a GitHub repo (or design files / raw uploads) → Claude builds with YOUR components, checks its output against your design system, and corrects before you see it → /design-sync pulls your system in; hand off to Claude Code and it continues from your actual work "instead of starting over from a screenshot" → /design lets you create, edit, and sync design projects from the terminal The headline isn't "the model draws prettier buttons." It's grounding + self-verification against a source of truth you control. Same shape as the rest of 2026's agent releases: the win isn't generating more, it's grounding output in something you own and checking against it. The uncomfortable builder takeaway: Getting AI to ship production UI isn't a prompting problem. It's whether your design system is a clean, importable, machine-checkable artifact. The moat moves from "can the model design" to "is your source of truth importable and checkable." If you build product: could an agent import your design system and grade itself against it today — or does it only live in a Figma file and three people's heads?

• 
  bek※ (@ebubekirttr) reported 49 minutes ago

  @Themadhushaw01 @0interestrates Yeah, but the thing is, I am not working on github and I don’t want to use it so any other repository support would be better like gitlab

• 
  revayz (@0xrevayz) reported 53 minutes ago

  Andrej Karpathy: "90% of Claude's mistakes come from missing context, not a weak model" Without CLAUDE.md the mistake rate is 41%. With proper rules it drops to 3% You don't need a better AI. You need better loops Most people still prompt one task at a time and fix the answers themselves. That means the human is still the loop Boris Cherny from Anthropic said it best: "I don't prompt Claude anymore. My job is to write loops" The shift is simple. Stop giving instructions. Start designing systems that run themselves: Discover -> Plan -> Execute -> Verify -> Iterate until it passes The 6 things that make loops actually work: -Automations that trigger without you -Worktrees so agents don't overwrite each other -Skills that load context instantly -Connectors to real tools like GitHub and Slack -Subagents where the checker is never the maker -Memory so the loop never starts from zero Prompt engineers ask AI for outputs Loop engineers design systems that produce verified outcomes A reliable loop beats a perfect prompt every time Stop being a prompter. Start being the loop engineer

• 
  ./can (@shcansh) reported 57 minutes ago

  GitHub forcing safer defaults in actions/checkout v7 is a necessary move to kill the notorious pwn request, but the real risk is developers blindly copy-pasting the bypass flag to quiet build failures. Starting July 16, 2026, this fork-blocking behavior gets backported to all major floating tags. Since raw *** CLI steps remain unprotected, will this actually clean up GitHub Actions security, or will teams just use allow-unsafe-pr-checkout as a quick fix?

• 
  welt (@mjwelt) reported 57 minutes ago

  @OpenAI man im down to test out new models / features on my pro account, but when 5.5(6) pro takes 90 mins to do something then the download doesn't work, or it cant connect to github 50%+ of the time.. kinda sucks haven't been able to generate images (thinking) all day either