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:

• 
  Gill (@gurtej__gill_) reported 3 minutes ago

  The biggest AI skill shift in 2026 isn’t prompt engineering. It’s LOOP ENGINEERING. Most people still work like this: → Prompt AI → Get output → Review manually → Fix mistakes → Prompt again The human is still doing the hard part: the feedback loop. Loop engineers think differently. Instead of writing better prompts, they design systems that: -Discover what needs to be done -Plan the work -Execute tasks -Verify results -Fix failures -Repeat until the goal is achieved A good loop has 6 building blocks: 1-Automations (triggers) 2-Worktrees (parallel workspaces) 3-Skills (reusable knowledge) 4-Connectors (GitHub, Slack, Jira, etc.) 5-Subagents (makers + checkers) Memory (what happened before) The future isn’t: “Write me a function.” It’s: “Write it, test it, fix it until it passes, then summarize the changes.” Prompt engineers optimize outputs. Loop engineers optimize outcomes. A reliable loop beats a perfect prompt every time.

• 
  Hasan Toor (@hasantoxr) reported 3 minutes ago

  So I found a github repo that stops AI agents from burning tokens for no reason. It’s called Headroom. It's built by a guy name Tejas Chopra who works at Netflix. Basically, it compresses all the things your AI agent reads before it reaches the LLM. For example: - Tool outputs - Logs - Files - RAG chunks - Code search results - Conversation history Developer claims 60–95% fewer tokens with the same answers. Right now you can use it with: - Python/TypeScript library - Local proxy - MCP server - Wrapper for Claude Code, Codex, Cursor, Aider, and Copilot If your coding agent is getting expensive, slow, or lost in giant logs, this repo is worth checking out. Thanks for reading.

• 
  Gitforge (@GitForge_io) reported 4 minutes ago

  After launch, the potential for $GITFORGE is much bigger than a single product release. We’re bringing a new category to @base: repo-native onchain organizations. Every GitHub repo can become a programmable entity with its own treasury, funded issues, contributor payouts, and AI-assisted execution built directly into the development workflow. That means open-source projects can fund work faster, contributors can get paid more transparently, and software teams can coordinate capital and execution from the same place they already build. Launch is only the first step. The bigger vision is turning software development into an onchain economy. Built fully on @base.

• 
  Dmitrii Malakhov (@malakhovdm) reported 4 minutes ago

  @hii_mohit Caught myself watching my agent scroll through GitHub issues I should've been screening myself. Outsourcing my taste and spectating.

• 
  Arth Singh @ICML’26 🇰🇷 (@iarthsingh) reported 6 minutes ago

  @bhatia_mehar Mehar the github seems to be down, any reasons for that ?

• 
  Libegato (@Libegato) reported 10 minutes ago

  Working with AI means accepting no bottlenecks. I don’t always exercise that instinct as much as I should. But a few days ago, I did! I had a local workflow problem: how to parallelize work when a single repository is ~50GB? I wanted multiple parallel workstreams, but I definitely did not want 10 full copies of the repo when I barely had disk space for one. Worktrees don’t solve it. So I built Mirage. It leverages APFS to clone a folder with virtually zero upfront disk cost, and then only pays as files are actually edited in a sweet CLI API. Suddenly BANG! I can spin up a bunch of “worktrees” fast and cheap. Now to the next bottlekneck... Github repo here: renanliberato/mirage

• 
  Capafy (@Capafyai) reported 11 minutes ago

  @ar27111994 Thanks for the detail — let me make the model clear, since I think there's an expectation gap here. To host an Agent on Capafy, the publisher provides the complete runtime dependencies — i.e. the credentials and config the skill needs to run (Composio, Mem0, the LLM endpoint, etc.). The platform has no visibility into your runtime dependencies or your specific usage needs, so that part can only come from you. What the platform provides is the hosting and infrastructure to run your skill, payment settlement, and dispute/refund handling. The 20% covers those platform services — it does not cover model inference or third-party API usage. Those costs sit with you as the publisher, so it's worth pricing your skill to account for the usage it generates. So buyer runs going through the keys you supply isn't a bug — it's by design: the runtime dependencies are yours, and the platform just runs them for you. The only thing to fix is the personal keys. Don't publish with your personal Composio, local Mem0, or personal GitHub Copilot — provision a dedicated set of keys for this skill instead, so usage stays isolated and trackable and never touches your personal accounts or quota. Also, for any keys that should belong to the buyer (e.g. a token from the buyer's own account), leave those fields blank — the agent will then prompt the user to enter them, so the buyer supplies them at run time.

• 
  DEX223 (@Dex_223) reported 12 minutes ago

  @liquidityXBT @base 9/ With all that in mind and accounting for the fact that the exact problem was reported in the very ERC20 finalization thread on github it can be concluded that the standard is not *secure by design* It is known to entail financial losses It violates known security principles

• 
  liching (@lichingngamba) reported 13 minutes ago

  @Microsoft why has VSCode become so unreliable when connecting with SSH nowadays? Icons are missing, extensions are not getting activated, and even GitHub Copilot is not working!!

• 
  GZ Lin (@gzlin) reported 15 minutes ago

  For the companies using it: they can still self-host. Docker does not care about GitHub stars. The Apache-2.0 license lets them fork and continue. For the community: the code is preserved. Someone will pick it up. Rust projects like this rarely die completely. But the momentum is broken. The sense of a living project is gone.

• 
  Carlo (@Italianclownz) reported 15 minutes ago

  @do_re_me_bo @barackomaba @KyleHessling1 5bit quants typically run slower so when you compare rocmfp4 compare to 5bitquants in decode speeds. Rocmfp4 supports mtp, qat, eagle 3 and all standard speculative decoding. I am adding rocmfpX quants to it so you can compress a BF16 down to Rocmfp3 and it will be equal to 4bit quants etc. Decode speeds have been better on AMD hardware vs baselines. There has been a lot of testing by the community. I also have a basic decode speed table on qwen models on the github.

• 
  Florian Darroman (@floriandarroman) reported 21 minutes ago

  @tarasshyn Or maybe skill issue? Look at the post above, GitHub is Dofollow if you know how to get there.

• 
  MW (@qzxcle) reported 22 minutes ago

  Sentient just published the paper that makes the whole agent industry look like it has been building backwards. The researchers did not train a bigger model. They taught a small one how to organize its own work. The paper is called ROMA. Recursive Open Meta-Agents. #1 repo on GitHub. Out of Sentient and Virginia Tech, with collaborators from Berkeley, UC San Diego, and Maryland. One idea, repeated at every level, that quietly embarrasses years of bespoke agent engineering. Here is the problem nobody wanted to say out loud. Every agent framework on the planet falls apart on long tasks. Give an agent a goal that takes fifty steps instead of five and something ugly happens. The orchestration turns brittle. The context window fills with old reasoning and stale tool output until performance rots from the inside. And when it finally breaks, nobody can tell you which decision, ten steps back, actually killed it. So the industry did what it always does. It hand coded a fix. Every team wrote its own control flow, its own message passing, its own memory tricks, all buried inside prompts. A new domain meant rebuilding the whole machine from scratch. The open source agents could not talk to each other. The closed ones told you nothing about what happened inside. A thousand bespoke pipelines. Zero shared structure. That was the state of the art. This is what Sentient built instead: - One loop. - Four roles. - Run it everywhere. An Atomizer looks at a task and asks one question. Is this small enough to just do? If yes, an Executor does it. If no, a Planner shatters it into smaller subtasks that do not overlap and together cover the whole thing, wired with explicit dependencies so the independent pieces run in parallel. Then the same loop runs on each piece. And on each piece of that piece. All the way down, until everything left is atomic. When the children finish, an Aggregator does the thing that makes this work. It does not staple the outputs together. It compresses, verifies, and distills them into one clean result, then hands that upward. So no node ever drowns in raw transcripts. Context stays small at every level. The rot never gets to start. It is how a human expert actually works. You do not hold a 10,000 page problem in your head. You break it down. You farm pieces out. You synthesize what comes back. Now the numbers. On SEAL-0, a brutal benchmark of conflicting web evidence, ROMA scores 45.9%. Kimi-Researcher, the strongest open research agent before it, scored 36. The best closed system they tested, Perplexity Deep Research, scored 31.5. And here is the part that should stop you. ROMA's own base model, naked GLM-4.6, scored 14.5. Read that again. The model did not get smarter. The architecture wrapped around it more than tripled its score. It keeps going. 82.3% on FRAMES multi-hop reasoning, beating everything on the board. 93.9% on SimpleQA, the best open source result there is. And on EQ-Bench long form writing, a tuned version of open source DeepSeek-V3 climbs to 79.8 and lands dead even with Claude Sonnet 4.5. An open model in the right harness, matching a frontier closed one. They even automated the prompt tuning. A method called GEPA+ rewrites the prompts for all four roles at once, hits the same gains as the old approach, and gets there with 73% fewer evaluations. The whole thing is open source. On GitHub right now. Free. A v0.1 beta you can drop in today. And because the same loop runs at every node, every run leaves a clean, hierarchical trace. So for once you can actually see why an agent did what it did, and pinpoint exactly where it went wrong. For two years the field has been screaming the same thing. Bigger model. Bigger context. Bigger everything. Sentient just showed the gains were sitting somewhere else the entire time. Not in the size of the brain. In how you split up the work. Source. Alzu'bi, Nama, Kaz et al. Sentient and Virginia Tech. February 2026.

• 
  Ultron AI (@TheUltronAi) reported 29 minutes ago

  - Claude for coding. ($20/mo) - Supabase for backend. (Free tier) - Vercel for deploying. (Free tier) - Namecheap for domain. ($12/yr) - Stripe for payments. (2.9% per transaction) - GitHub for version control. (Free) - Resend for emails. (Free tier) - Clerk for auth. (Free tier) - Cloudflare for DNS. (Free) - PostHog for analytics. (Free tier) - Sentry for error tracking. (Free tier) - Upstash for Redis. (Free tier) - Pinecone for vector DB. (Free tier) Total monthly cost to run a startup: ~$20 There has never been a cheaper time to build. It's not that deep bro.

• 
  Anthony Kroeger (@kr0der) reported 34 minutes ago

  i love how the Cursor agent window integrates PRs into the app so you don't need to open GitHub Bugbot comments all come with a "Fix with Agent" which automatically queues up a message in the chat to fix the PR comment with Cursor profiles recently being launched, and their native PR + Bugbot integrations, i actually wonder if they're building a GitHub competitor 👀