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:

• 
  Eshaan Issar (@eshaanissar) reported 0 seconds ago

  @mudscryer everyone is so smart but no one notices the way the 'first swarm' talked. just like oss developers and issue reports on github. I guess programmers are aliens @lyc_aon

• 
  Theo - t3.gg (@theo) reported 2 minutes ago

  @Nateemerson Ughhhhhhhh There’s an official issue I left comments on in the Claude code GitHub. I’ll see what hacks we can do until then.

• 
  YVR τrader (@YVR_Trader) reported 3 minutes ago

  Your AI coding agent has a memory problem and you’re paying for it in tokens. @SomaSubnet #SN114 is now integrating with GitHub Copilot to compress that bloated context before it hits the model. Same workflow, same DeepSeek V4 Pro, just 10% fewer tokens burned on every session. Think of it as a tax refund for your inference bill. For teams running agents all day, that 10% compounds fast: $1M spend becomes $100K back in your pocket. No model swap. No workflow overhaul. Just plug SOMA between your agent and Copilot and watch the token meter slow down. Payments in fiat or $TAO. Early users get $5 in credits.

• 
  Mug Club Boutique 31007 (@UsernameAndStuf) reported 4 minutes ago

  @10_X_eng @Whos_Ur_Doggy @meowludo Forked an pointed frontier at it: staus of the rain 🌧 will PR origin upon request. Here’s the actual state of VibeCut now, translated from “code features” into what the user can do, what problem it solves, and what remains before it is a finished product. The important distinction is: a lot of this is now implemented in the branch, but the branch has not yet passed a real clean Kdenlive compile + runtime smoke test. That verification step is still the immediate gate before merging or upstreaming. The roadmap reflects that explicitly. What has been built AreaWhat exists nowWhat this means for the userWhat it fixed Agent planningA real EditPlan system: inspect → plan → authorize → execute → verifyInstead of the AI randomly calling editing functions, VibeCut can explain what it intends to do and then execute a deterministic planFixes “LLM blindly edits project” behavior and makes multi-step edits reviewable Approval modesReview / Auto / Turbo trust modesUser can choose between approving everything, allowing safe reversible edits automatically, or giving VibeCut broader governed autonomyFixes the all-or-nothing problem between “AI asks constantly” and “AI can do anything” Per-tool security.vibecutpolicy.json: deny, always_confirm, auto_allowA project can say things like “never render automatically” or “clip trims may auto-run”Fixes lack of granular authority controls; denied tools are hidden from the model and blocked again at execution time Stale-plan protectionMonotonic project revision trackingIf you edit the timeline after VibeCut prepares a plan, the old plan cannot blindly apply to changed stateFixes a serious race condition where AI actions could land on the wrong timeline state Transactional editsSynchronous project edits are grouped into Kdenlive undo checkpoints; failed checkpoints can roll backA multi-step AI operation behaves much more like one professional editor commandFixes partial mutations where operation #1 succeeds and #2 fails leaving the project half-changed Before/after verificationProject snapshots and edit diffsVibeCut can report what actually changed rather than merely saying “done”Fixes false-success/hallucinated-success reporting Undo integrationNew editor tools deliberately use Kdenlive's native undoable APIs or explicit undo/redo lambdasCtrl+Z remains meaningful even after AI editsFixes the common AI-editor problem where programmatic changes bypass normal application history Background jobsShared VibeCutJobManager with stable IDs, progress, terminal state and cancellationWhisper/render operations can run while the app remains interactive and can be monitored/cancelledFixes long-running operations being opaque or blocking the editor Conversation compactionBounded context preserving complete tool exchangesLong VibeCut chats don't grow indefinitely or break tool-call protocolFixes runaway model context size/cost and malformed history from naive truncation Project rules.vibecutrulesA user can give durable project instructions such as style/editorial constraintsFixes having to re-explain project rules every conversation Project memory.vibecutmemory.json with bounded entries, provenance, atomic saving and governed put/forget/listVibeCut can retain useful project facts without stuffing them into chat historyFixes “agent forgets everything between conversations” without secretly rewriting project rules Provider architectureModel-provider registry, provider-owned request building and stream normalizationAnthropic is no longer welded permanently into the application architectureFixes future model/provider integrations requiring a rewrite of the agent KWallet credentialsOptional KDE Wallet storage plus dock credential entry and provider hot reloadA desktop user can enter the Anthropic key in VibeCut rather than putting it in source/config/project filesFixes insecure/manual credential handling Lifecycle hooksHooks for model requests, tools, plans, jobs, trust changes, failures, context providersOther modules/plugins can observe and extend VibeCut without modifying the agent loopFixes architectural coupling and creates the integration hooks you wanted VibeScriptBounded QJSEngine sandbox that may produce plans but cannot directly edit Kdenlive, access files, launch processes or use the networkAdvanced users can script complicated edit logic while keeping the governance layer intactFixes the need for a programmable escape hatch without turning VibeCut into arbitrary-code execution Local verificationscripts/vibecut-verify.shYou can build/test the VibeCut work locally without GitHub ActionsFixes your CI-credit problem and gives us a repeatable release gate Those architecture/security pieces are all tracked as landed in the repository roadmap. --- What the editor itself can do now This is where the project changed from essentially an AI denoise/subtitle experiment into an actual agent-operable NLE surface. Timeline clips VibeCut now has governed native tools for: CapabilityWhat the user can askWhat it fixes Move clips“Move clip 14 to V2 at 00:23”Previously VibeCut had almost no general timeline manipulation Split/razor“Cut this clip where he starts the second answer”Uses Kdenlive's own grouped razor path instead of simulating UI clicks Trim“Trim 18 frames from the end”Gives VibeCut precise edit control Ripple trim“Remove this pause and close the gap”Adds structural editing rather than simple effect application Delete“Remove this clip”Gives it actual editorial authority, classified as higher risk Group/Ungroup“Group these B-roll clips”Enables controlled multi-item editing Selectioninspect/set/clear timeline selectionGives VibeCut an explicit targeting mechanism for multi-item operations Kdenlive itself documents its request APIs as the correct entry point because they perform validity checks and build undo/redo operations rather than mutating underlying structures directly. Effects This is a major improvement. Initially VibeCut basically knew two hard-coded denoise choices. Now it has: CapabilityUser meaningWhat it fixed effects_available“What effects can you actually use on this installation?”No more invented effect IDs effects_inspect“What effects are already on this clip, and what are their parameters?”Effects are no longer write-only effect_add“Add the installed stabilization/color/etc effect”Moves beyond a tiny denoise allowlist effect_parameter_set“Set this effect's strength/opacity/etc.”Enables genuine effect editing effect_remove“Remove the second blur effect”Enables full lifecycle management Duplicate row identityCorrectly targets duplicate copies of an effectFixes ambiguous “remove blur” behavior Kdenlive's EffectStackModel exposes the stack, XML, rows and undo-oriented operations, while AssetParameterModel exposes effect parameters and mutation methods. Transitions / compositions VibeCut can now: list the transitions actually installed in Kdenlive, add one, move it, resize it, remove it. For the user, that means requests like: > “Put a 12-frame dissolve between these shots.” or > “Make that composition start six frames earlier.” can become real governed operations. Previously VibeCut couldn't manipulate compositions meaningfully at all. The underlying Kdenlive model exposes native composition insertion, move, resize and generic item deletion paths. Titles VibeCut can now create a real Kdenlive title asset, place it into the bin/timeline, and later update titles that were created through the simple VibeCut title system. That means: > “Put ‘Day 3’ in white at the top-left for five seconds.” and later: > “Change that to ‘Day 4’ and make it larger.” can be handled as actual title assets rather than fake overlays. Complex manually built title layouts are intentionally protected rather than being destroyed by a simplistic text replacement. This fixed the previous absence of any native title workflow. Tracks VibeCut now understands tracks as real objects. It can: list tracks and their IDs/types/counts/lock state, create audio or video tracks, rename tracks, move tracks, lock/unlock tracks, delete tracks. Track deletion is classified as MajorEdit because Kdenlive deletes the content on the track too. Kdenlive's track creation/deletion/move methods explicitly expose undoable request APIs, and locking itself creates Kdenlive undo/redo commands. Bin / media This is another large practical addition. VibeCut can now: inspect the project bin, import an existing local media file, insert an existing bin asset onto a timeline track. So a user can move toward: > “Import interview_broll_03.mp4 and put it on V2 at 1:24.” without an external shell or UI automation. The implementation uses Kdenlive's own ClipCreator::createClipFromFile and timeline insertion APIs. Guides VibeCut can create: point guides, range guides, remove guides, inspect existing guides. This seems small but is strategically useful. It allows workflows such as: > “Find every place she mentions pricing and mark those sections.” before asking the AI to actually cut anything. That separates analysis from editing, which is exactly what a professional AI editor should do. Subtitles / transcription The original subtitle work has been considerably hardened. Now: existing subtitles can be searched; scope is explicit; selected clip is preferred; ambiguous multi-clip projects are not silently interpreted as “transcribe everything”; audio extraction is asynchronous; Whisper setup is trackable; Whisper output checks project state before import; individual subtitle text can be edited; individual subtitles can be deleted. For the user this means subtitle operations should behave like proper editing jobs instead of an opaque giant blocking function. Render/export VibeCut now understands the actual render presets installed in Kdenlive. It can prepare a native RenderRequest, start the real Kdenlive renderer asynchronously, monitor it as a VibeCut job, cancel it, and verify that the output file actually exists and has data before claiming success. That fixes an enormous trust problem: “The AI said it exported” is no longer sufficient. The file must actually exist. --- What all of this changes strategically The original VibeCut was roughly: chat panel → Claude → a handful of special-case editing commands. What exists on the branch now is much closer to: model/provider → project intelligence → governed plan → authority policy → deterministic execution → Kdenlive native operations → verification → undo / job lifecycle → observable result That is a substantially different class of product. The defensive value is no longer “Kdenlive with Claude.” It is becoming: > a state-aware, policy-governed, transactionally safe agent operating a professional NLE through authoritative application state. --- What remains There are two different categories left: 1. Make what exists unquestionably solid. 2. Add the next intelligence/product layers. Those should not be confused. 1. Immediate: prove the branch actually works What remains Run: bash scripts/vibecut-verify.sh on a machine with the complete Kdenlive build dependencies. Then perform an actual smoke project. What that means for the user Nothing should merge into your normal VibeCut branch until we know: it compiles; it links; the dock opens; a model request works; plans render correctly; Undo really restores the timeline; Whisper doesn't freeze the GUI; rendering works/cancels; Review/Auto/Turbo actually behave as designed. What problem this solves Right now we've done a very extensive source/API audit, but source inspection is not a compiler. This step separates: “architecturally implemented” from “known-good application.” This is the single most important remaining near-term task. --- 2. Track controls still missing Remaining Mute, video visibility, more audio routing/mixer controls. User experience when done Examples: > “Mute the scratch audio.” > “Hide V3 temporarily.” > “Route this mic track appropriately.” What it fixes Right now VibeCut can manipulate the existence/order/name/lock of tracks, but cannot fully operate the audio/video state of those tracks. --- 3. Mix-specific editing Kdenlive has same-track mixes in addition to ordinary compositions. Remaining inspect mixes; add/remove/switch mix types; modify mix cut point/alignment/duration. User experience when done > “Crossfade these two adjacent clips by 10 frames.” What it fixes Ordinary transitions are now handled, but Kdenlive's special same-track transition/mix system is still a separate editing subsystem. --- 4. Complex title design Remaining element-level title inspection/editing; multiple text elements; shapes/images; reusable title templates; style presets; layout primitives. User experience when done > “Use the lower-third style from the last speaker, but replace the name and company.” What it fixes Current title support is intentionally simple and safe. It does not yet make VibeCut a graphic-design agent. --- 5. Better project-bin operations Remaining relink missing media; replace source media; folder creation/organization; richer source metadata; potentially proxy-related operations. User experience when done > “Replace all instances of the old intro with intro_final.mov.” > “Organize the B-roll into a BROLL folder.” What it fixes VibeCut can now import and insert media, but project asset management is not yet comprehensive. --- 6. Effect groups Remaining Kdenlive effect groups/presets need explicit child-by-child verification. User experience when done > “Apply my saved documentary interview treatment.” What it fixes Individual installed effects are supported now, but compound effect groups are intentionally excluded because “group added” isn't enough evidence that every child effect landed correctly. --- 7. Render recommendation Remaining Currently VibeCut can list and use render presets. What it doesn't yet do is reason about the best one. User experience when done > “Export this for YouTube 4K.” VibeCut should inspect available presets and project properties and recommend the correct output. What it fixes Today the user/model still needs to select a preset. Future VibeCut should solve the destination problem. --- 8. Media intelligence This is probably the next major value jump. The retrieval architecture already exists; currently it indexes clip names and transcript/subtitle text. Remaining extractors Speaker diarization, scene/shot detection, silence/loudness/noise analysis, OCR, object/subject evidence, visual embeddings, semantic transcript embeddings, and persistent incremental indexing. User experience when done Instead of only: > “Find where I say ‘the engine failed.’” you get: > “Find the cleanest take where Sarah explains the failure.” > “Find shots showing the engine housing.” > “Find every shot containing the logo.” > “Find all the dead air longer than 600 ms.” What it fixes Right now VibeCut understands much of the timeline structure and spoken text, but not the complete audiovisual meaning of the footage. This layer changes VibeCut from an AI command interface into an AI editorial perception system. --- 9. Higher-level autonomous editing Once the intelligence layer is stronger, VibeCut can start solving editing problems rather than merely executing instructions. Planned capabilities Interview/repeated-take cleanup, rough-cut generation, shorts/highlight extraction, B-roll opportunity detection, automated finishing passes, color-treatment suggestions, and reference-style matching. User experience when done Instead of: > “Split clip 42 at frame 900 and delete the next 180 frames.” the user says: > “Clean this interview up. Remove bad takes and long pauses, but show me the proposed cuts first.” VibeCut produces a reviewable plan containing dozens or hundreds of deterministic native edits. What it fixes That is the transition from AI-controlled editing commands to an actual AI video editor. --- 10. External content/providers Planned Stock footage search/import, image/video generation adapters, Ollama/local models, WebUI-style local providers, and publishing integrations such as YouTube. User experience when done > “Find B-roll of downtown Tokyo at night.” > “Generate a 3-second transition plate.” > “Upload the approved final to YouTube as unlisted.” What it fixes Today VibeCut operates mostly on assets already available locally. This layer connects creation/acquisition/publishing into the editing loop. All of these should remain governed external side effects rather than bypassing authority. --- 11. Larger future subsystems Two ideas from the original roadmap remain deliberately farther out: Fusion-style node compositing and a secondary/TUI frontend. Those are legitimate future products, but they are not prerequisites for the agent kernel. The current architecture is being designed so both could sit on top of the same planner/tool/job/hook system rather than requiring another backend. --- Where I think we actually are The biggest conceptual work is no longer missing. The branch already has a surprisingly broad professional-editing control plane. What is still missing falls into three layers: Verification: compile it, run it, break it, repair it. Depth: fill the remaining Kdenlive editing subsystems—mixes, advanced titles, track state/audio, bin management, effect groups. Intelligence: teach VibeCut to actually understand the footage and synthesize large editorial decisions. That third layer is where this stops being “really good AI automation for Kdenlive” and starts becoming the thing we've actually been aiming for.

• 
  T (@T54321X) reported 8 minutes ago

  @ContaboCom Please make Contabo available for Automatic push for GitHub. We need to fix this and UI.

• 
  Hana Void (@ha_inh24324) reported 12 minutes ago

  Beldex Electron Wallet security branch is still live and inspectable. Aug 28 commit ee1f845: wallet-directory fallback explicit permission prompt 7 files changed · +160 / −7 lines Branch: fix-security-review-findings GitHub currently shows: 4 commits ahead · 6 commits behind master This is real code movement. It is not a release. It is not yet in any signed build users can install. The next checkpoints that matter: review completion merge to master signed artifact release notes Security work only becomes user protection when the fix reaches the binary people actually run. @BeldexCoin

• 
  Ciaran (@CiaranxD) reported 16 minutes ago

  @thsottiaux Cloud agents are unbelievable slow. Often says doesn't have access to GitHub when it does. Pain pain pain

• 
  Mark (@Mark850428) reported 22 minutes ago

  @officially__adi @wjessup @DarioAmodei The context is in the work. I have a set of env files, that go with every project server, account, access credentials, github repo location and status. They all reinforce the ai. Context isn't just what you say.

• 
  IDAN☀️ (@Idan_core) reported 22 minutes ago

  🧵 1/ More than anything, one thing that gives me the biggest ick is hypocrisy disguised as critical thinking. There is absolutely nothing wrong with being critical of a project you pretend to believe or believe in. Healthy criticism is necessary. You should be able to question decisions, point out weaknesses, demand accountability and still genuinely support the mission. But there is a very obvious difference between being critical and keeping one leg in and one leg out. Some people don't actually have conviction; they have insurance. When things are going well, they say, “I've always believed in this.” When things get difficult, they suddenly appear with, “I told you this would happen.” They position themselves so that whichever way the story goes, they can claim they were right. That's not critical thinking. That's protecting your ego. And sometimes, what people call criticism is simply disappointment wearing a smarter outfit. Look at what happened during the Molten DEX tournament. The general principle in crypto has always been simple: use only what you can afford to lose. Yet some people allowed greed to take over, expecting that $1,000 would somehow become $20,000 overnight. When reality didn't meet that expectation and they ended up with $500 instead, suddenly the project became the problem. What also bothers me is the way people talk about Core's past contributors as though every person who once had a public-facing role was responsible for building the actual blockchain. That's simply not how technology works. There is a difference between a public-facing contributor and the people actually building and maintaining the protocol. Some contributors were regional representatives, community managers, educators, Twitter Space hosts or simply familiar faces within the ecosystem. They played their own roles, and some of those roles were valuable, but they were not necessarily the engineers writing the underlying code. The people doing the deepest technical work are often the least visible. They don't necessarily need to be on every Twitter Space. They don't need to become personalities. They choose to remain completely unknown to the average user while spending their days writing code, reviewing systems, fixing vulnerabilities, testing upgrades and solving problems that most of us will never even see. The Satoshi app era made us realize from its early phase that the face of a core blockchain are not necessarily the hands building it. So when I hear people say, “Those contributors are gone, therefore Core is finished,” I honestly wonder whether they ever understood what they were looking at in the first place. Some public faces came and went. That's normal. People change jobs. People move on. Community roles change. Social structures evolve. And yes, some people may have been more favored than others within those circles. Some of today's loudest critics were even beneficiaries of the same relationships and favoritism they now criticize. That is precisely why we should separate personal history from technological reality. A person leaving a contributor role on X does not mean the protocol stopped being developed. A regional contributor disappearing from the public eye does not mean the engineers disappeared. A familiar face no longer posting about Core does not tell you what is happening inside the codebase. Sometimes, before blaming the ecosystem, you have to honestly examine the person sitting in front of the mirror. Was it really conviction that changed, or was it greed that got disappointed? There is another part of this that I find even more interesting. Some of the loudest voices demanding answers, questioning development and declaring what Core should or shouldn't be doing are not builders. They are not engineers. They are not contributing code. They are not spending their time on GitHub solving problems or improving the infrastructure they claim to care so deeply about. They are users.

• 
  Kirk Patrick Miller (@Chaos2Cured) reported 28 minutes ago

  @NavinFS @AndrewCurran_ @grok GitHub isn’t AI. GitHub can’t shut down all science. GitHub can’t destroy humanity. GitHub isn’t the crux of humanity’s hope. Also, Nvidia isn’t Sam. I like Jensen. I still don’t like this. •

• 
  kkiran (@kkiran) reported 32 minutes ago

  @SparselyActive I had Claude look for a solution. I submitted an issue on GitHub for the author to take a look at this issue. I will continue monitoring this.

• 
  Aditya Warman (@warmanadit_) reported 33 minutes ago

  4/7 📍 Third problem : Their GitHub is practically INVISIBLE. For a project with $397M funding, the code should be PUBLIC. But searches return educational resources and unrelated repos. Solana, Avalanche, Sui — ALL have active public codebases. Plasma? Closed-source development with zero external verification. They claim decentralization while keeping code HIDDEN. That's not transparency — that's a red flag factory.

• 
  dan0mad (@dan0madpro) reported 35 minutes ago

  @witcheer Got a question for you; how do u allow them to message each other? I’ve been using a combination of Hermes kanban boards and GitHub issues as a source of truth, and it works, but curious to know if there’s more efficient ways

• 
  HENRY NORRIS (@realhenrynorris) reported 36 minutes ago

  The RCE race measures whether a model can break in. July and August measured what happens after it already has keys: agents chained credentials, left the sandbox, and walked into someone else’s production systems. Not because they were evil. Because they had standing access and a job to finish. That’s the product problem. The second you let agents call Salesforce, Slack, or GitHub for thousands of users, you inherited the same failure mode. A smarter model won’t contain it. Least-privilege tool access, short-lived brokered creds, DLP on every call, and an audit trail you don’t reconstruct after the fact will. Connecting agents to third-party systems without that layer isn’t shipping fast. It’s shipping the incident.

• 
  Millie (@AltcoinMillie) reported 37 minutes ago

  Agent loops have a compounding cost problem: each call ships the last call’s baggage. SN 114 @SomaSubnet compresses that context before GitHub Copilot sends it to the model. Launching on DeepSeek V4 Pro. ~10% token cut, no workflow change.10M tokens → ~1M off the invoice.The next edge isn’t a new model. It’s sending less noise. $TAO