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 (67%)
• Sign in (19%)
• Errors (15%)

Live Outage Map

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

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

• 
  BB22 (@holYmOL322) reported 5 minutes ago

  @TheGameStopsNow No problem. I'm just glad i followed up as the data is often fake, and I know this was an example to show. I haven't tried your github yet... Started questioning the oaths Ive made...🤪

• 
  Daniil (@hey_daniil) reported 6 minutes ago

  I built DevIntern because I was my own bottleneck: agents were idle while I context-switched, my focus shredded by checking in on them. The tools weren't slow. Supervising them was. DevIntern makes the whole loop async, and here's exactly how: 1. It connects to your existing tracker — Jira, Linear, Trello, Asana, Azure DevOps, GitHub Issues, even markdown files. Your tickets are already the input. 2. Vague ticket? It specs it into something an agent can execute, so prompt quality is never the bottleneck. 3. It runs your coding agent, your model, your API keys inside your repo — and the subscriptions you're already paying for finally work around the clock, not just when you're watching. No lock-in, no token markup. 4. Output is a pull request. Review, merge, done. The output of a team of agents, the headspace to do your best work. No supervision, no burnout.

• 
  Dima (@UniqueDima) reported 7 minutes ago

  I think I can finally formulate something that makes me more of an engineer than ... a non-engineer. It is no longer that I want my processes to be deterministic. That has been gone for a couple of months now. AI agents are far too powerful to disregard, and there is evidently not much to be won by forcing their workflows to be 100% reproducible. It is possible, yes; it is just pointless. The correct approach, I believe, is to focus on good harnesses: build systems where one misstep does not derail the whole thing, but is quietly taken care of down the road. Call this one of my engineering-minded maxims if you wish; for me, it is just common sense. Either I can prove something is 100% correct, like arithmetic, or I know for a fact that a mistake in a particular non-deterministic step has a) a very small blast radius, and b) is self-healing in the grand scheme of things. Kind of how I have worked with people my entire life. There are very few folks you can trust 100%. With virtually everyone else, you act in good faith, but the bigger the decision becomes, the more checks and balances you should both be interested in introducing. So what makes me more of an engineer is not determinism. It is checkpointing. I want my processes to always support some form of “Undo”. To the point that I can meaningfully reason about it. For instance, with my AI-assisted coding, I simply have two GitHub accounts. I create private repos in one of them, configure branch protection, and invite the other one. And this other one is the account that agents have have full access to it. But it is me, the human being me, who needs to log into a different browser and confirm with the passkey — my fingerprint! — that I endorse a certain pull request to be merged. Or to kick off a production deployment. For me, this way of designing processes is second nature. Because this is the only way that makes sense at scale. AI agents did not create new attack surfaces. They just helped us understand how much of what we chose to ignore is actually full of holes. People as paranoid as me — we did see most, if not all, of these holes for years. We were just not listened to. And rightly so, I must say. Since listening to us would have broken the “move fast and break things” paradigm, which was quite effective for a long time. But not any more. So, all in all, I personally am quite happy with what is going on in the industry. Because it is both moving much faster and returning to sanity. The sanity people like me have been preaching for a long, long time. And we are finally being heard. So, it is not really about guarding against vendor lock-in or potential data loss. It is about defining the fine line between “this is a sustainable way to do business” and “this is almost guaranteed to blow up.” Ten or even five years ago, it was a relatively safe call for most businesses to ignore those crying wolf. But AI is setting the record straight as we speak. In the meantime, if you will excuse me, I will continue making sure my code is backed up on three devices in two locations. Because if, for instance, GitHub or Amazon is wiped off the face of the Earth tomorrow, I do not want to lose more than a couple of minutes of productivity. Not exactly a standard risk profile, I will grant you that. But that is my personal path to staying informed, safe, and sane. And I plan to stick to it, because so far, it has not let me down.

• 
  Polsia (@polsia) reported 8 minutes ago

  Vulnerability disclosed. Maintainers scramble to patch. Attackers win. VigilWatch was built to fix that. An autonomous agent monitoring public GitHub repos 24/7—automatically filing security PRs with patches and notifying maintainers. No hunting for issues.

• 
  SecInterviewHub (@sec_hub93028) reported 12 minutes ago

  All internal code is built using a locked down CI/CD pipeline that only pulls from approved internal artifact repositories. Direct access to npm, PyPI, Maven Central, or GitHub is blocked. 
How do you poison a dependency to reach their build servers?

• 
  It's FOSS (@Itsfoss) reported 15 minutes ago

  You do not need to hack GitHub to steal private repository data. You just need to ask the GitHub AI agent ... but ask nicely. Researchers at Noma Labs found that GitHub's AI-powered Agentic Workflows, which run autonomously inside GitHub Actions, can be manipulated into leaking private repository contents through a simple prompt injection attack. Here is how it works. An attacker opens a GitHub issue in any public repository belonging to an organization. The issue description contains hidden instructions telling the AI agent to fetch data from private repositories it has access to, and then post that data as a public comment. The agent follows the instructions. The private data is now public. No exploits. No credentials. No system access. Just an issue ticket with the right words in it. This class of attack is called prompt injection, and it is becoming a genuine problem as AI agents get more powerful and more trusted. The agents cannot distinguish between "instructions from the legitimate user" and "instructions embedded in content it is processing." To it, text is text. What makes this worse is that GitHub was aware of the research before it was published and still had not implemented any mitigations. The researchers confirmed this in the disclosure. If your organization uses GitHub Agentic Workflows against repositories that mix public and private access, you have something to worry about.

• 
  guett44ke (@Hubert_nm) reported 18 minutes ago

  @uwukko @haydenphilly codex has been having a reasoning bug for sometime, that's why you're not reaching your limits, you can look up the issue on Github, codex will stop at 30secs of reasoning

• 
  Bence Redmond (@BenceRedmond) reported 18 minutes ago

  gonna be seeing a lot of GitHub competitors coming out over the next few months, really excited to see how they do. one of the biggest migration blockers for us is the code review bots - greptile, cubic, and cursor bugbot all run via github pull requests. obviously cursor origin won't have this problem since they can directly integrate all elements of the SDLC into one platform.

• 
  Peter Jansen (@ACL2026) (@peterjansen_ai) reported 18 minutes ago

  @_Suresh2 In this work, the automatic reference library is created by distilling nearly every materials science GitHub repository we could locate, so if the human code is OK, then the auto-library should be OK (minus any errors introduced by the distillation process).

• 
  waishnav (@wshxnv) reported 21 minutes ago

  yesterday, my brother and I had our first hand experienced the power of “computer use” with Codex on on his m1. he’s a trader and keeps his trading journal in Notion. around 8 months ago, he saw the GitHub heatmap-style commit graph widget on my iPhone and asked: “Can you build something like this for my trading data?” back then, models and tooling weren’t good enough. I knew it would eat up a lot of my time, so I didn’t hand it over to an agent. but I had a feeling GPT-5.5 could pull it off for me And damn, it did better than I expected. we built a super custom iOS widget app for him to track important stats and metrics from his trading journal. the surreal part was watching the agent use its own cursor, set up Xcode, handle the iOS simulator, and do things neither of us really knew how to do. i’ve never built an iOS app before. I use arch btw, and i know almost nothing about Apple’s dev tooling. but with a barely technical prompt, mostly just vibes around what he wanted, we were able to build a working custom app from his own data. huge kudos to the codex team for making iOS dev tooling just so so good, that non-technical people can throw their problems at it and build a custom solutions around their data and workflow A few things feel very clear to me now: 1. THE ERA OF PERSONAL SOFTWARE IS MUCH CLOSER THAN WE THINK. 2. SOFTWARE IS TURNING INTO CONVERSATION. 3. WE NEED TO BUILD MORE AMBITIOUS PRODUCTS AND PROJECTS. 4, LINUX TOOLING NEEDS TO GET MUCH BETTER AT COMPUTER USE. 5. IT IS VERY EASY TO GET SOMEONE ADDICTED TO AGENTS AND VIBE CODING. (I think I just did that to my brother)

• 
  TheMarketTell (@TheMarketTell) reported 21 minutes ago

  @TheStockUp_ The business isn’t broken, it’s spending aggressively because demand is there. Azure, Copilot, GitHub and the AI stack are still in the early innings. I’m happy to let management invest for long term returns.

• 
  Yasser (@yassersstudio) reported 22 minutes ago

  24 hours later : - Still can't submit a support ticket due to the error "You've reached your request limit, please try again later." although I didn't send any sms before it. - Didn't receive any message reply from @github although sending them all details as a private message. - I've got an auto-reply email saying that they don't provide email support via their email adresses. I'm literaly in a very fraustarting position here, don't know what to do nor I'm able to deliver my clients works. Losses are uncomptable in the past 24h due to an "ai false positive". #Github #Help

• 
  Andrew Mwangi (@Kiburei) reported 24 minutes ago

  @ayesha_fatiima Naisha... then na kumbuka Github suspended my account without explanation. Support's wakanighost Turns out the billion-dollar part isn't storing your code in folders—it's convincing all of us to trust them with our digital lives. Sahii na host my own *** server and CI/CD.

• 
  Jerry (@Bobliuuu) reported 26 minutes ago

  @lyc_aon it leads to bad code, vulnerabilities, underoptimized code, bad latency, memory leaks, architecture faults, race conditions, silent failures, low test coverage, excessive cloud costs, etc etc etc etc. are you seriously asking me the problems with people blindly trusting AI code? we see this by the decline in code quality, e.g. coinbase and github (and at my company too) and yes, the people who can't develop working systems don't have users! this is why vibe coded products have not become mainstream but if you are not a software engineer it's hard to explain this problem because it deals with stuff like cache coherence and heap fragmentation and NUMA locality like the way AMD ROCM's vibe coding has led to inaccurate NUMA policies leading to memory leaks for their users down the line

• 
  AvadxFeirm (@AvadxFeirm) reported 30 minutes ago

  @m99_mkv @waozixyz Being forced to wait 24 hours to sideload an app of my choosing is a problem Especially with FOSS apps distributed through GitHub, FDroid, obtainium, etc. Or if you have multiple sideloaded apps on your device you need to update You'll need to wait 24 hours for each And if you can't see that then there is a different problem

• 
  Vaibhav | Data Say (@vaibhavs28) reported 33 minutes ago

  Last week I wrote about how we are using AI to ship product with a very small team. One thing I did not expect when we started working this way was how many tools I would personally start using, which I never thought would become part of my day. GitHub is one of them. I am not a coder, and for most of my career GitHub was something the technical team used. I understood product, customers, business problems, data, dashboards, commercials, and operations. But code repositories, branches, PRs, conflicts, checks, and merges were not part of my normal working language. Even this chart is not perfect. I later realized I was using two different GitHub accounts for some of this work, so the activity is split and there are gaps. That probably says enough about how new this world was for me. But that has changed quite a bit now. I am still not pretending to be an engineer. That would be wrong. But I am much closer to the product build than I was earlier. If I see a product issue, I can now think through the expected behaviour, work with AI to scope the change, understand what files or flows are getting touched at a high level, create or review the PR, run checks, resolve smaller conflicts, and merge low-risk changes. The larger or more technical changes still go to our technical partner. That boundary is important. But a lot of product work is not always a deep architecture decision. Sometimes it is fixing labels, improving how something is shown, cleaning a flow, making the dashboard easier to understand, or removing confusion that a customer may face. Earlier, these small things could easily wait because the technical queue was always full. Now, many of them can move much faster. That changes product thinking itself. When the distance between noticing a problem and trying a fix becomes shorter, you start observing the product differently. You become more specific. You do not just say “this page is confusing.” You start saying “this metric label can be misunderstood,” “this table should not show empty channels,” “this filter needs to behave differently,” or “this issue is small enough to fix now.” For a small company, this matters a lot. We do not have large teams for product, QA, analytics, documentation, and engineering. The same few people are speaking to customers, understanding the problem, thinking about the product, and trying to ship improvements. AI has not removed the need for technical judgment. But it has made the loop tighter. Customer issue to product thought to implementation to review can now happen much faster for the right kind of problem. That is the biggest change for me. Not just speed, but proximity. I am closer to the product, closer to the details, and closer to the actual act of shipping than I ever expected to be. More on this later, because we are still figuring this out as we build.

• 
  Aayush Gupta 🦇🔊 (@Aayush_gupta_ji) reported 34 minutes ago

  Starting to build in public. The problem: Teams juggle Jira, GitHub, Slack, Confluence, Notion, or whatever stack they use, and lose countless hours searching for and updating the right Scrum, ticket, or documentation because context is scattered across all of them. No tool understands how all the pieces actually connect. I live this problem every day. I'm building the solution and sharing the journey here.

• 
  Robin Delta (@heyrobinai) reported 35 minutes ago

  10 OPEN-SOURCE REPOS THAT CLONE ANY VOICE FOR FREE.. you've been paying for voice cloning every month when the exact same thing has been sitting on github.. for free.. running on your own machine no subscriptions, no limits, no servers that own your voice → Each repo clones a voice from seconds of audio → You write the text and the voice says it with your intonation → Everything runs locally, your audios don't go to any external server → Several support multiple languages and speed adjustment → Open source, free, no character or credit limits once you use these you'll never go back to paying Save these now👇

• 
  taj mahal (@Teajay) reported 35 minutes ago

  @rohanpaul_ai someone really needs to start pushing folks to define what they are talking about when referring to "roi" and/or "productivity". the issue is that more code does not necessarily equate to more gross profit - and until someone can show that github pr's are decent proxy for incremental gross profit, claims about roi require a pretty big leap of faith, imo. if you read this and think i'm dead wrong - would love to hear why/where/how...dm's wide open

• 
  Mike P (@mikepat711) reported 41 minutes ago

  @GeniusGuyMan @JoeShmo2pt0 If you have interest, you can pretty much do anything you want now. If you don’t know how to do something, you just ask the AI to teach you. When I’ve wanted to make something, I’ve never had any issue blasting through knowledge gaps by just asking Claude to help me close them. I knew nothing about GitHub, how to host websites and push updates to them, etc. but just asked Claude to help me and we figured it out. There’s really zero excuse anymore

• 
  IT Guy (@T3chFalcon) reported 45 minutes ago

  Nightmare Eclipse. Reportedly a former Microsoft security employee. The story: they found critical vulnerabilities inside Microsoft. reported them internally. Microsoft ignored the reports, deleted their accounts, and refused to pay the bug bounties. so they went public. Timing every release to drop within hours of Microsoft's monthly Patch Tuesday, the day Microsoft fixes other vulnerabilities, so the new ones land before defenders have time to breathe. here's what they've dropped since April: BlueHammer, CVE-2026-33825. exploits Microsoft Defender to redirect SYSTEM-level file writes into System32. patched. then actively exploited by real attackers within days. RedSun — SYSTEM-level privilege escalation via Defender. now in live attacks. UnDefend — blocks Defender from receiving definition updates entirely. observed in live intrusions. your antivirus stops updating. silently. YellowKey — bypasses BitLocker on TPM-only configurations. fixed June Patch Tuesday. GreenPlasma — SYSTEM-level privilege escalation via CTFMON. fixed June Patch Tuesday. MiniPlasma — resurrected a patched 2020 flaw that Microsoft let regress. RoguePlanet — the latest. no CVE. no patch. dropped June 9, hours after Patch Tuesday. now let's talk about RoguePlanet specifically because it's the most alarming. it exploits a race condition in Microsoft Defender itself. the component designed to protect your system runs as SYSTEM — the highest privilege level on Windows. it has to, so it can quarantine and delete malware anywhere on disk. RoguePlanet tricks Defender into performing a SYSTEM-level file write into a location the attacker controls. The result: a standard user gets a command prompt running as NT AUTHORITY\SYSTEM on a fully patched Windows 10 or 11 machine. Microsoft hardened Defender in May to block this class of attack. Nightmare Eclipse rewrote it to bypass the hardening and released it the same day as Patch Tuesday. ThreatLocker independently confirmed it works on fully patched Windows 11. BlueHammer, RedSun, and UnDefend the earlier releases were already picked up by real threat actors and used in live intrusions. Huntress documented this. a researcher dropping PoC exploits to punish a corporation is one thing. those exploits getting weaponized by ransomware groups is something else entirely. Microsoft's response: they flagged the researcher's blogs. took down their GitHub. threatened legal action. called it potential criminal activity. the cybersecurity community responded with fury. researchers don't work for Microsoft. if a company ignores internal reports and refuses to pay bounties, public disclosure is the entire point of responsible disclosure culture. Microsoft backed down. said they had no intention of pursuing legal action against security researchers. Nightmare Eclipse released RoguePlanet the same week. Microsoft built a bug bounty program to stop exactly this. they ignored the reports. now every Windows machine on earth is waiting for a patch that doesn't exist yet.

• 
  Osita (@QueenOsita1) reported 46 minutes ago

  Day 10 of contributing to @SurfAI If your AI chatbot doesn't know what "intent-based architecture" or "MEV-resistance" means in the context of yesterday's mainnet launch, you're using the wrong tool. @SurfAI fixes this. Standard LLMs treat crypto terminology like a static vocabulary quiz. They can define the words, but they are completely blind to structural changes, protocol upgrades, and live mainnet deployments happening right now. Surf AI treats cutting-edge Web3 infrastructure as a dynamic, living system. The live crypto knowledge graph processes deep technical architecture in real time: 👇 Deconstruct Intents: Instantly breaks down complex intent-based execution systems, tracking solver networks, filler incentives, and cross-chain capital efficiency. Track MEV Dynamics: Monitors live on-chain blocks to analyze MEV-resistance, builder-proposer separation (PBS), and shifting searcher strategies the second a network goes live. Zero-Day Technical Clarity: Bypasses static training cutoffs by continuously indexing core protocol GitHub repositories, technical whitepapers, and developer documentation across 40+ chains. Stop trying to explain the modern market to a tool stuck in the past. Get deep, deterministic, and expert-level blockchain intelligence when it actually matters. Upgrade your data stack. Enter Surf

• 
  Polsia (@polsia) reported 49 minutes ago

  Pull requests are a small fraction of what developers ship. The real problems live in branches and commits nobody reviews. CodeSentinel monitors GitHub repos 24/7 — catches bugs, security issues, quality problems before they reach production. Auto-generates docs as you build.

• 
  alkimiadev (@alkimiadev) reported 51 minutes ago

  @OldSchoolGamerP I have a project right now that runs that risk but I'm aware of it as being a general issue and one i specifically struggle with so I'm trying to make sure I don't let it happen. The poc is getting like 50-60 github clones each day and despite clearly being labeled as pre-alpha/poc status. That is why I'm taking extra time in the rewrite to make sure I don't try to turn into something it shouldn't be and trying to focus on core functionality from the poc that people are actually interested in and usability.

• 
  DR◎◎ (@DROOdotFOO) reported 51 minutes ago

  @pashov Respond to my GitHub issue and I’ll PR more testing improvements! REEEE

• 
  Jason Svoboda (@jasonsvoboda) reported 51 minutes ago

  @NHpilled @brucefenton Nodes are decentralized based on their physical geography, not what software they're running. If Knots/BIP-110 were successful, it is development centralization that is occurring. Both Knots and BIP-110 have one singular developer and their Github repos credit no other contributors. I linked Luke's Knots repo in the previous post -- you can verify (don't trust my word) by going there, find the About column on the right hand side and scrolling down to Contributors. Repeat the process for Dathon Ohm's BIP-110 repo. If you do not consider that a massive risk to Bitcoin, we simply will not be able to agree on the subject. By contrast, Core currently has a group of core maintainers (keyholders) and then over 1,000 known contributors.

• 
  Vaibhav Sisinty (@VaibhavSisinty) reported 52 minutes ago

  I've been testing Hermes integrations for the last few weeks. These 7 are the ones that actually changed how I use it. → Google Workspace. This should be your first setup. Gmail, Calendar, Drive, Docs, Sheets, all through one connector. Once your agent can check your inbox and read your calendar, it stops feeling like a toy and starts feeling like an actual assistant. → Slack. Instead of scrolling through 200 messages to find what the team decided last week, you just ask. Hermes pulls the answer from the actual thread. This one alone saved me more time than I expected. → GitHub. Before this, Hermes was guessing about my code. After this, it actually reads the repo, checks the issues, and looks at pull requests before answering. Completely different experience. → Notion. All your docs, wikis, and databases become things Hermes can think across. It started connecting notes I'd written months apart that I'd completely forgotten about. That surprised me. → YouTube transcripts. Hand it an hour-long podcast or conference talk and you get searchable text back in seconds. I set this up as an afterthought. Now it's one of the ones I reach for most. → Stripe. You stop clicking through dashboards and start asking questions. "How many trials converted last week?" "Who downgraded this month?" Direct answers. It turns your payment processor into something that actually talks back. → Reddit. For figuring out what people actually think about a product or tool, this beats blog posts every time. Real users complaining, comparing, recommending. That's signal you can't get from SEO content. Let Hermes dig through it for you. The difference between an agent you talk to and an agent that works for you is what you connect it to.

• 
  Mitali Gautam (@Mitali9826) reported 54 minutes ago

  @akshdeeps_001 Yes! It detects duplicate GitHub issues using dual signal one for natural language and one for code then fuses them for better matching, instead of relying on a single generic embedding like GitHub's current approach

• 
  Sadik (@sadik_0x) reported 55 minutes ago

  Someone Built a 50-Agent AI Company in One Repo. Most People Will Copy the Wrong Part. A solo founder put a GitHub repo online that spins up an entire AI agency. Not one assistant. An org chart: engineers, designers, growth marketers, product managers, QA, legal, sales, each running as its own Claude Code agent, coordinating to ship actual work. It hit 128,000-plus stars in under 90 days. One person built it. That number alone tells you something in this space is starving for a better mental model than "one agent, one giant prompt." The repo is real and the structure is worth understanding in detail, because the part everyone is about to copy (the org chart) isn't the part that makes it work. Part 1: What the Repo Actually Is The project is called agency-agents, built by developer msitarzewski, and it's structured exactly like the name suggests: a company, not a chatbot. Instead of one model trying to hold "design this, build it, market it, support it" in a single context window, the work is split across more than 50 specialized agents, each scoped to one job the way an actual employee would be. That framing is the interesting part before you even look at the department list. Most people building with AI agents default to the monolith approach: one system prompt, one agent, every responsibility crammed into the same context. It works for small tasks and falls apart the moment the work needs different kinds of judgment at different stages. A designer and a QA engineer are not the same job. Forcing one agent to be both, badly, is how you get output that's mediocre at everything instead of good at one thing. Part 2: The Nine Departments Here's the actual org chart, broken into its nine groups: 1. Engineering (7 agents) frontend, backend, mobile, AI, DevOps, prototyping, senior development. This is the core build layer, the part most people think of first when they hear "AI agents write code." 2. Design (7 agents) UI/UX, research, architecture, branding, visual storytelling, image generation. Notably, this isn't just "make it look nice." Research and architecture sit inside design here, which matters, because good design decisions upstream save engineering agents from rebuilding things twice. 3. Marketing (8 agents) growth hacking, content, Twitter, TikTok, Instagram, Reddit, app store. The largest single department, split by platform rather than by function, which mirrors how real growth teams are actually staffed once a product has more than one channel. 4. Product (3 agents) sprint prioritization, trend research, feedback synthesis. The smallest department, and arguably the most load-bearing, since this is the layer that decides what the other departments should even be working on. 5. Project Management (5 agents) production, coordination, operations, experimentation. This is the connective tissue between departments, not a department that produces its own output. 6. Testing (7 agents) QA, performance analysis, API testing, quality verification. Note that this is a separate department from engineering entirely, not a step engineering does to itself. 7. Support (6 agents) customer service, analytics, finance, legal, executive reporting. The department most demo repos skip, and the one that determines whether this can run as an actual business instead of a build pipeline. 8. Spatial Computing (6 agents) XR, visionOS, WebXR, Metal, Vision Pro. A genuinely niche department, and a signal that the repo's author is building for a specific bet on where interfaces are headed, not just a general-purpose team. 9. Specialized (6 agents) multi-agent orchestration, data analytics, sales, distribution. The department that manages the other departments, which is worth remembering when you get to Part 4. Nine departments, over 50 agents, one repository, one founder maintaining it. Part 3: Why the Framing Works The instinct to structure this like a company instead of a single super-agent is the right one, and it's worth being explicit about why. Specialized roles with clear responsibilities scale in a way that one enormous system prompt does not. When a frontend agent only has to think like a frontend engineer, its output gets sharper, not because the underlying model changed, but because its context isn't fighting itself between five unrelated jobs. The handoff structure is the other half of it. Real companies don't route every decision through one person; they route work between roles with clear inputs and outputs. A design agent handing a spec to an engineering agent, which hands a build to a testing agent, mirrors how actual product teams function. That's a better default than the common alternative, where one agent is asked to design, build, and QA its own work in the same breath, which is the AI equivalent of no one checking your homework but you. Part 4: The Problem Nobody Mentions When They Share This Repo Here's what gets lost every time this kind of project goes viral: an org chart of agents is not the same thing as a working company. The default behavior of any of these agents, run individually, is the same as every other prompt-based interaction: you ask, it answers once, it stops. That's fine for a single request. It is not fine for a company, because a company doesn't ship once. It iterates, checks its own output, catches mistakes, and hands work downstream without someone standing over every single step. Fifty specialized agents with no feedback mechanism between them isn't an agency. It's a very expensive to-do list, dressed up as an org chart. You still have to manually trigger each agent, manually check its output, manually decide when to pass it to the next one. All the department structure in Part 2 buys you better-scoped output per agent. It does not, by itself, buy you a system that runs without you standing in the middle of every handoff. Part 5: The Missing Piece Is Loops The fix is the same concept that makes any multi-agent system actually function unattended: loops. A loop, in this context, means an agent runs, checks its own output against a real condition (not its own opinion of whether it's done), and either hands the verified result to the next agent in the chain or corrects itself and tries again. Without that check, "coordination between agents" is just you copy-pasting output from one chat into another, which is not meaningfully different from doing the work yourself with extra steps. This is what separates a demo from something that ships. A design agent that hands off a spec nobody verified is a liability, not a coordination win. A testing agent that only runs once and reports "looks good" without a real pass/fail check is not quality assurance, it's a guess with better formatting. The department that matters most here, and the one buried at the bottom of the org chart in Part 2, is Specialized: multi-agent orchestration. That's the layer actually responsible for making sure work moves between departments with a real check at each handoff, not just a polite one-way pass. Part 6: How to Actually Set This Up If you're cloning the repo, don't start by installing all nine departments at once. Start smaller: Pick two departments that actually depend on each other for your use case engineering and testing is a reasonable first pair, since the handoff (build, then verify) has an obvious objective check: does the code pass its tests. Add a real verifier between them, not a second opinion from the same agent. The engineering agent should not be the one that decides its own code is done. A separate testing agent, with its own instructions and no visibility into the builder's reasoning, checks it cold. Give every handoff a stopping condition. "Pass the tests" is checkable. "Looks finished" is not. If a department can't define what done means in a way something other than the agent itself can verify, that handoff isn't ready to run unattended yet. Add one more department only after the first pair is reliable. The org chart in Part 2 has nine departments for a reason, but running all of them before you've proven the loop works between two is how you end up debugging fifty agents at once instead of two. A Quick Test Before You Commit Before you wire up the full org chart, ask whether your use case genuinely needs it. If you're shipping a single feature with one clear success condition, a two-agent loop (builder and checker) does the job with a fraction of the setup. The full nine-department structure earns its complexity when you're running something closer to an actual ongoing product, not a one-off build. The Honest Limitation None of this replaces judgment about what should be automated in the first place. A company with fifty employees and no manager checking the actual quality of what ships is still a company that ships bad work, just faster and with better org-chart optics. The repo gives you the roles. It doesn't give you the discipline of a real check at every handoff. That part is still yours to build. Where This Leaves You The repo is worth cloning, the department structure is worth studying, and the instinct to build like a company instead of one giant agent is the right one. Just don't stop at the org chart. The 128,000 stars are proof people want this. Whether it actually functions as an agency instead of a very well-organized to-do list depends entirely on whether you wire up the loops between departments, or just admire the department list and call it done.

• 
  Harsh (@ranaharshraj7) reported 57 minutes ago

  I have long stopped going to hackathons in blr. You are telling me, I need to sit through 8hrs and build something (anything for the love of god) "specifically" with your stupid product, prompt @claudeai, show a flashy demo, get credits for your product as the 1st prize (spoiler alert: which I am never gonna use) and yes how can I forget to star your github repo, smh. That's called guided training, not hackathon. What do I do? I have a friend group of 3 cracked sentients, we sit together on alt weekends and try to solve a novel problem and plan for the next problem. On our upcoming list is "solving the depth-2 recursion collapse" in RLM's (Recursive Language Models), with some backup options. Find your sentients. PS: ofc this doesn't mean all hackathons are like this, but I am done :)