The GitHub Blog
type: channel
description: Updates, ideas, and inspiration from GitHub to help developers build and design software.
date: 2026-02-24T00:27:42Z
update period: hourly
update frequency: 1
update base: 2000-01-01T12:00+00:00
generator agent: https://wordpress.org/
items: Multi-agent workflows often fail. Here’s how to engineer ones that don’t.
items: How AI is reshaping developer choice (and Octoverse data proves it)
items: What to expect for open source in 2026
items: Securing the AI software supply chain: Security results across 67 open source projects
items: Automate repository tasks with GitHub Agentic Workflows
items: Welcome to the Eternal September of open source. Here’s what we plan to do for maintainers.
items: GitHub availability report: January 2026
items: Continuous AI in practice: What developers can automate today with agentic CI
items: Pick your agent: Use Claude and Codex on Agent HQ
items: What the fastest-growing tools reveal about how software is being built

Multi-agent workflows often fail. Here’s how to engineer ones that don’t.
type: item
creator: Gwen Davis
date: 2026-02-24T16:00:00Z
subject: AI & ML
subject: Generative AI
subject: agentic AI
subject: AI agents
subject: GitHub Copilot
description: Most multi-agent workflow failures come down to missing structure, not model capability. Learn the three engineering patterns that make agent systems reliable. The post Multi-agent workflows often fail. Here’s how to engineer ones that don’t. appeared first on The GitHub Blog.
encoded: If you’ve built a multi-agent workflow, you’ve probably seen it fail in a way that’s hard to explain. The system completes, and agents take actions. But somewhere along the way, something subtle goes wrong. You might see an agent close an issue that another agent just opened, or ship a change that fails a downstream check it didn’t know existed. That’s because the moment agents begin handling related tasks—triaging issues, proposing changes, running checks, and opening pull requests—they start making implicit assumptions about state, ordering, and validation. Without providing explicit instructions, data formats, and interfaces, things won’t go the way you planned. Through our work on agentic experiences at GitHub across GitHub Copilot, internal automations, and emerging multi-agent orchestration patterns, we’ve seen multi-agent systems behave much less like chat interfaces and much more like distributed systems. This post is for engineers building multi-agent systems. We’ll walk through the most common reasons they fail and the engineering patterns that make them more reliable. What multi-agent systems are and how to use them Teams reach for multi-agent workflows when a single agent isn’t enough to reliably solve a problem end to end. But introducing multiple agents also introduces new failure surfaces: shared state, ordering assumptions, implicit handoffs, and non-deterministic behavior. We see developers use multi-agent workflows for things like: Codebase maintenance and dependency updates Automated code quality checks and refactors Spec-driven feature implementation Issue and pull request triage These scenarios only work reliably when every step is explicit and constrained. 1. Natural language is messy. Typed schemas make it reliable. Multi-agent workflows often fail early because agents exchange messy language or inconsistent JSON. Field names change, data types don’t match, formatting shifts, and nothing enforces consistency. Just like establishing contracts e…

How AI is reshaping developer choice (and Octoverse data proves it)
type: item
creator: Andrea Griffiths
date: 2026-02-19T17:00:00Z
subject: AI & ML
subject: Generative AI
subject: GitHub Copilot
subject: Octoverse
subject: enterprise
subject: generative AI
subject: open source
description: AI is rewiring developer preferences through convenience loops. Octoverse 2025 reveals how AI compatibility is becoming the new standard for technology choice. The post How AI is reshaping developer choice (and Octoverse data proves it) appeared first on The GitHub Blog.
encoded: You know that feeling when a sensory trigger instantly pulls you back to a moment in your life? For me, it’s Icy Hot. One whiff and I’m back to 5 a.m. formation time in the army. My shoulders tense. My body remembers. It’s not logical. It’s just how memory works. We build strong associations between experiences and cues around them. Those patterns get encoded and guide our behavior long after the moment passes. That same pattern is happening across the software ecosystem as AI becomes a default part of how we build. For example, we form associations between convenience and specific technologies. Those loops influence what developers reach for, what they choose to learn, and ultimately, which technologies gain momentum. Octoverse 2025 data illustrates this in real time. And it’s not subtle. In August 2025, TypeScript surpassed both Python and JavaScript to become the most-used language on GitHub for the first time ever. That’s the headline. But the deeper story is what it signals: AI isn’t just speeding up coding. It’s reshaping which languages, frameworks, and tools developers choose in the first place. <img data-recalc-dims="1" fetchpriority="high" decoding="async" height="576" width="1024" src="https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?resize=1024%2C576" alt="A chart showing the top 10 programming languages on GitHub from 2023 to 2025. TypeScript rises to #1 in 2025, overtaking Python and JavaScript, which move to #2 and #3 respectively. Other top languages include Java, C#, PHP, Shell, C++, HCL, and Go. The chart tracks ranking changes over time on a dark background with colored lines representing each language." class="wp-image-91509" srcset="https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?w=1728 1728w, https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?w=300 300w, https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top…

What to expect for open source in 2026
type: item
creator: Dylan Birtolo
date: 2026-02-18T18:41:42Z
subject: Maintainers
subject: Octoverse
subject: Open Source
subject: open source
description: Let’s dig into the 2025’s open source data on GitHub to see what we can learn about the future. The post What to expect for open source in 2026 appeared first on The GitHub Blog.
encoded: Over the years (decades), open source has grown and changed along with software development, evolving as the open source community becomes more global. But with any growth comes pain points. In order for open source to continue to thrive, it’s important for us to be aware of these challenges and determine how to overcome them. To that end, let’s take a look at what Octoverse 2025 reveals about the direction open source is taking. Feel free to check out the full Octoverse report, and make your own predictions. Growth that’s global in scope In 2025, GitHub saw about 36 million new developers join our community. While that number alone is huge, it’s also important to see where in the world that growth comes from. India added 5.2 million developers, and there was significant growth across Brazil, Indonesia, Japan, and Germany. What does this mean? It’s clear that open source is becoming more global than it was before. It also means that oftentimes, the majority of developers live outside the regions where the projects they’re working on originated. This is a fundamental shift. While there have always been projects with global contributors, it’s now starting to become a reality for a greater number of projects. Given this global scale, open source can’t rely on contributors sharing work hours, communication strategies, cultural expectations, or even language. The projects that are going to thrive are the ones that support the global community. One of the best ways to do this is through explicit communication maintained in areas like contribution guidelines, codes of conduct, review expectations, and governance documentation. These are essential infrastructure for large projects that want to support this community. Projects that don’t include these guidelines will have trouble scaling as the number of contributors increases across the globe. Those that do provide them will be more resilient, sustainable, and will provide an easier path to onboard new contributors. The dou…

Securing the AI software supply chain: Security results across 67 open source projects
type: item
creator: Gregg Cochran
date: 2026-02-17T19:00:00Z
subject: Maintainers
subject: Open Source
subject: AI security
subject: open source
subject: supply chain security
description: Learn how The GitHub Secure Open Source Fund helped 67 critical AI‑stack projects accelerate fixes, strengthen ecosystems, and advance open source resilience. The post Securing the AI software supply chain: Security results across 67 open source projects appeared first on The GitHub Blog.
encoded: Modern software is built on open source projects. In fact, you can trace almost any production system today, including AI, mobile, cloud, and embedded workloads, back to open source components. These components are the invisible infrastructure of software: the download that always works, the library you never question, the build step you haven’t thought about in years, if ever. A few examples: curl moves data for billions of systems, from package managers to CI pipelines. Python, pandas, and SciPy sit underneath everything from LLM research to ETL workflows and model evaluation. Node.js, LLVM, and Jenkins shape how software is compiled, tested, and shipped across industries. When these projects are secure, teams can adopt automation, AI‑enhanced tooling, and faster release cycles without adding risk or slow down development. When they aren’t, the blast radius crosses project boundaries, propagating through registries, clouds, transitive dependencies, and production systems, including AI systems, that react far faster than traditional workflows. Securing this layer is not only about preventing incidents; it’s about giving developers confidence that the systems they depend on—whether for model training, CI/CD, or core runtime behavior—are operating on hardened, trustworthy foundations. Open source is shared industrial infrastructure that deserves real investment and measurable outcomes. That is the mission of the GitHub Secure Open Source Fund: to secure open source projects that underpin the digital supply chain, catalyze innovation, and are critical to the modern AI stack. We do this by directly linking funding to verified security outcomes and by giving maintainers resources, hands‑on security training, and a security community where they can raise their highest‑risk concerns and get expert feedback. Why securing critical open source projects matters A single production service can depend on hundreds or even thousands of transitive dependencies. As Log4Shell demons…

Automate repository tasks with GitHub Agentic Workflows
type: item
creator: Don Syme
date: 2026-02-13T14:00:00Z
subject: AI & ML
subject: Automation
subject: DevOps
subject: Enterprise software
subject: Generative AI
subject: GitHub Copilot
subject: LLMs
subject: Machine learning
subject: agentic workflows
subject: AI agents
subject: automation
subject: continuous integration
subject: developer productivity
subject: GitHub Actions
subject: GitHub Next
description: Discover GitHub Agentic Workflows, now in technical preview. Build automations using coding agents in GitHub Actions to handle triage, documentation, code quality, and more. The post Automate repository tasks with GitHub Agentic Workflows appeared first on The GitHub Blog.
encoded: Imagine visiting your repository in the morning and feeling calm because you see: Issues triaged and labelled CI failures investigated with proposed fixes Documentation has been updated to reflect recent code changes. Two new pull requests that improve testing await your review. All of it visible, inspectable, and operating within the boundaries you’ve defined. That’s the future powered by GitHub Agentic Workflows: automated, intent-driven repository workflows that run in GitHub Actions, authored in plain Markdown and executed with coding agents. They’re designed for people working in GitHub, from individuals automating a single repo to teams operating at enterprise or open-source scale. At GitHub Next, we began GitHub Agentic Workflows as an investigation into a simple question: what does repository automation with strong guardrails look like in the era of AI coding agents? A natural place to start was GitHub Actions, the heart of scalable repository automation on GitHub. By bringing automated coding agents into actions, we can enable their use across millions of repositories, while keeping decisions about when and where to use them in your hands. GitHub Agentic Workflows are now available in technical preview. In this post, we’ll explain what they are and how they work. We invite you to put them to the test, to explore where repository-level AI automation delivers the most value. <img decoding="async" src="https://github.blog/wp-content/uploads/2026/02/Quotes_Option1.jpg" alt="Graphic showing quotes from customers. 'Home Assistant has thousands of open issues. No human can track what's trending or which problems affect the most users. I've built GitHub Agentic Workflows that analyze issues and surface what matters: that's the kind of judgment amplification that actually helps maintainers.'- Franck Nijhof, lead of the Home Assistant project, one of the top projects on GitHubby contributor countAgentic workflows also allow maintainers and community to experiment wit…

Welcome to the Eternal September of open source. Here’s what we plan to do for maintainers.
type: item
creator: Ashley Wolf
date: 2026-02-12T20:14:11Z
subject: Maintainers
subject: Open Source
subject: AI
subject: maintainers
subject: open source
description: Open source is hitting an “Eternal September.” As contribution friction drops, maintainers are adapting with new trust signals, triage approaches, and community-led solutions. The post Welcome to the Eternal September of open source. Here’s what we plan to do for maintainers. appeared first on The GitHub Blog.
encoded: Open collaboration runs on trust. For a long time, that trust was protected by a natural, if imperfect filter: friction. If you were on Usenet in 1993, you’ll remember that every September a flood of new university students would arrive online, unfamiliar with the norms, and the community would patiently onboard them. Then mainstream dial-up ISPs became popular and a continuous influx of new users came online. It became the September that never ended. Today, open source is experiencing its own Eternal September. This time, it’s not just new users. It’s the sheer volume of contributions. When the cost to contribute drops In the era of mailing lists contributing to open source required real effort. You had to subscribe, lurk, understand the culture, format a patch correctly, and explain why it mattered. The effort didn’t guarantee quality, but it filtered for engagement. Most contributions came from someone who had genuinely engaged with the project. It also excluded people. The barrier to entry was high. Many projects worked hard to lower it in order to make open source more welcoming. A major shift came with the pull request. Hosting projects on GitHub, using pull requests, and labeling “Good First Issues” reduced the friction needed to contribute. Communities grew and contributions became more accessible. That was a good thing. But friction is a balancing act. Too much keeps people and their ideas out, too little friction can strain the trust open source depends on. Today, a pull request can be generated in seconds. Generative AI makes it easy for people to produce code, issues, or security reports at scale. The cost to create has dropped but the cost to review has not. It’s worth saying: most contributors are acting in good faith. Many want to help projects they care about. Others are motivated by learning, visibility, or the career benefits of contributing to widely used open source. Those incentives aren’t new and they aren’t wrong. The challenge is what happens…

GitHub availability report: January 2026
type: item
creator: Jakub Oleksy
date: 2026-02-11T23:12:34Z
subject: Company news
subject: News & insights
subject: GitHub Availability Report
description: In January, we experienced two incidents that resulted in degraded performance across GitHub services. The post GitHub availability report: January 2026 appeared first on The GitHub Blog.
encoded: In January, we experienced two incidents that resulted in degraded performance across GitHub services. January 13 09:38 UTC (lasting 46 minutes) On January 13, 2026, from 09:25 to 10:11 UTC, GitHub Copilot experienced a service outage with error rates averaging 18% and peaking at 100%. This impacted chat features across Copilot Chat, VS Code, JetBrains IDEs, and other dependent products. The incident was triggered by a configuration error introduced during a model update and was initially mitigated by rolling back the change. A secondary recovery phase extended until 10:46 UTC due to upstream provider Open AI experiencing degraded availability for GPT‑4.1 model. We have completed a detailed root‑cause review and are implementing stronger monitors, improved test environments, and tighter configuration safeguards to prevent recurrence and accelerate detection and mitigation of future issues. January 15 16:56 UTC (lasting 1 hour and 40 minutes) On January 15, 2026, between 16:40 UTC and 18:20 UTC, we observed increased latency and timeouts across issues, pull requests, notifications, actions, repositories, API, account login, and an internal service, Alive, that powers live updates on GitHub. An average 1.8% of combined web and API requests saw failure, peaking briefly at 10% early on. The majority of impact was observed for unauthenticated users, but authenticated users were impacted as well. This was caused by an infrastructure update to some of our data stores. Upgrading this infrastructure to a new major version resulted in unexpected resource contention, leading to distributed impact in the form of slow queries and increased timeouts across services that depend on these datasets. We mitigated this by rolling back to the previous stable version. We are working to improve our validation process for these types of upgrades to catch issues that only occur under high load before full release, improve detection time, and reduce mitigation times in the future. Looking ah…

Continuous AI in practice: What developers can automate today with agentic CI
type: item
creator: GitHub Staff
date: 2026-02-05T17:00:00Z
subject: AI & ML
subject: Generative AI
subject: Continuous AI
subject: generative AI
description: Think of Continuous AI as background agents that operate in your repository for tasks that require reasoning. The post Continuous AI in practice: What developers can automate today with agentic CI appeared first on The GitHub Blog.
encoded: Software engineering has always included work that’s repetitive, necessary, and historically difficult to automate. This isn’t because it lacks values, but because it resists deterministic rules. Continuous integration (CI) solved part of this by handling tests, builds, formatting, and static analysis—anything that can be described with deterministic rules. CI excels when correctness can be expressed unambiguously: a test passes or fails, a build succeeds or doesn’t, a rule is violated or isn’t. But CI is intentionally limited to problems that can be reduced to heuristics and rules. For most teams, the hardest work isn’t writing code. It’s everything that requires judgment around that code: reviewing changes, keeping documentation accurate, managing dependencies, tracking regressions, maintaining tests, monitoring quality, and responding to issues that only surface after code ships. But a lot of engineering work goes into work that requires interpretation, synthesis, and context, rather than deterministic validation. And an increasing share of engineering tasks fall into a category CI was never designed to handle: work that depends on understanding intent. “Any task that requires judgment goes beyond heuristics,” says Idan Gazit, head of GitHub Next, which works on research and development initiatives. Any time something can’t be expressed as a rule or a flow chart is a place where AI becomes incredibly helpful. Idan Gazit, head of GitHub Next This is why GitHub Next has been exploring a new pattern: Continuous AI, or background agents that operate in your repository the way CI jobs do, but only for tasks that require reasoning instead of rules. Why CI isn’t enough anymore CI isn’t failing. It’s doing exactly what it was designed to do. CI is designed for binary outcomes. Tests pass or fail. Builds succeed or don’t. Linters flag well-defined violations. That works well for rule-based automation. But many of the hardest and most time-consuming parts of engineering ar…

Pick your agent: Use Claude and Codex on Agent HQ
type: item
creator: Mario Rodriguez
date: 2026-02-04T17:00:19Z
subject: Company news
subject: News & insights
subject: Agent HQ
subject: AI agents
description: Claude by Anthropic and OpenAI Codex are now available in public preview on GitHub and VS Code with a Copilot Pro+ or Copilot Enterprise subscription. Here's what you need to know and how to get started today. The post Pick your agent: Use Claude and Codex on Agent HQ appeared first on The GitHub Blog.
encoded: Context switching equals friction in software development. Today, we’re removing some of that friction with the latest updates to Agent HQ which lets you run coding agents from multiple providers directly inside GitHub and your editor, keeping context, history, and review attached to your work. Copilot Pro+ and Copilot Enterprise users can now run multiple coding agents directly inside GitHub, GitHub Mobile, and Visual Studio Code (with Copilot CLI support coming soon). That means you can use agents like GitHub Copilot, Claude by Anthropic, and OpenAI Codex (both in public preview) today. With Codex, Claude, and Copilot in Agent HQ, you can move from idea to implementation using different agents for different steps without switching tools or losing context. We’re bringing Claude into GitHub to meet developers where they are. With Agent HQ, Claude can commit code and comment on pull requests, enabling teams to iterate and ship faster and with more confidence. Our goal is to give developers the reasoning power they need, right where they need it. Katelyn Lesse, Head of Platform, Anthropic How to get started When you have a task, you can choose Copilot, Claude, Codex, or a custom agent. You can make them work asynchronously and then review the results on your own time. Each coding agent session consumes one premium request. You can currently start Claude and Codex sessions from github.com, GitHub Mobile, and in VS Code. Claude and Codex must be explicitly enabled in your settings before use. See details on how. Create and view agent sessions on GitHub You can start and manage agent sessions directly from GitHub: Open the Agents tab in any repository where agents are enabled. Enter your request and select an agent using the Copilot icon. Submit the request to start the session. Agents run asynchronously by default. You can follow their progress in real time or review completed sessions later, with detailed logs showing what the agent did and why. Each session produces a…

What the fastest-growing tools reveal about how software is being built
type: item
creator: Dylan Birtolo
date: 2026-02-03T17:00:00Z
subject: News & insights
subject: Octoverse
description: What languages are growing fastest, and why? What about the projects that people are interested in the most? Where are new developers cutting their teeth? Let’s take a look at Octoverse data to find out. The post What the fastest-growing tools reveal about how software is being built appeared first on The GitHub Blog.
encoded: In 2025, software development crossed a quiet threshold. In our latest Octoverse report, we found that the fastest-growing languages, tools, and open source projects on GitHub are no longer about shipping more code. Instead, they’re about reducing friction in a world where AI is helping developers build more, faster. By looking at some of the areas of fastest growth over the past year, we can see how developers are adapting through: The programming languages that are growing most in AI-assisted development workflows. The tools that win when speed and reproducibility matter. The areas where new contributors are showing up (and what helps them stick). Rather than catalog trends, we want to focus on what those signals mean for how software is being built today and what choices you might consider heading into 2026. The elephant in the room: Typescript is the new #1 In August 2025, TypeScript became the most-used language on GitHub, overtaking Python and JavaScript for the first time. Over the past year, TypeScript added more than one million contributors, which was the largest absolute growth of any language on GitHub. <img data-recalc-dims="1" loading="lazy" decoding="async" height="576" width="1024" src="https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?resize=1024%2C576" alt="A chart showing the top 10 programming languages on GitHub from 2023 to 2025. TypeScript rises to #1 in 2025, overtaking Python and JavaScript, which move to #2 and #3 respectively. Other top languages include Java, C#, PHP, Shell, C++, HCL, and Go. The chart tracks ranking changes over time on a dark background with colored lines representing each language." class="wp-image-91509" srcset="https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?w=1728 1728w, https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?w=300 300w, https://github.blog/wp-content/uploads/2025/10/octoverse-20…