GitHub
As automated code generation overwhelms continuous integration pipelines with test backlogs, software value shifts from raw token output to autonomous agent loops that resolve downstream maintenance work without human intervention.
AI-assisted summary of Humans set direction. Agents close the loop. — original source. Check the original for full context.
Source published:
Key ideas
- GitHub CPO Mario Rodriguez rejects the notion of automated software factories, framing the emerging development model around humans setting direction while agents close the loop from planning to deployment. (2:42)
- Copilot Fusion combines intelligent model routing with runtime orchestration, cutting token costs significantly while producing richer multimodal and interactive software experiences. (11:40)
- GitHub introduced Lever, an open-source framework that automates CI tuning and codebase refactoring using multi-armed bandits, halving time-to-green while letting teams calibrate autonomy levels from L2 up to L4. (16:08)
- Using Copilot CLI automations and background shepherd agents, a GitHub engineer split a 600,000-line Rust crate in half over five days and merged 19 pull requests while typing only 38 total messages to agents. (21:39)
Detailed notes
## Background Published by GitHub on YouTube on November 5, 2026, this GitHub Universe 2026 presentation features Chief Product Officer Mario Rodriguez and Principal Engineering Manager Evan Boyle. The session explores an agent-native operating model where human developers define intent, outcomes, and standards while autonomous GitHub Copilot agents handle the execution loop to deliver finished software work.
## TL;DR Mario Rodriguez and Evan Boyle present GitHub's vision for an agent-native engineering system, arguing that developer value is measured by completed software work rather than raw code volume or token consumption. They demonstrate new features such as the GitHub Copilot app, Copilot Fusion for intelligent model orchestration, and community-driven remix workflows. Boyle introduces Lever, an open-source tool utilizing multi-armed bandit experimentation and configurable autonomy levels (from L2 oversight to L4 auto-merging) to autonomously optimize continuous integration pipelines and refactor monolithic codebases. Together, they urge engineers to delegate downstream maintenance toil to cloud automations so they can reclaim time for creative, zero-to-one problem solving and share their work beyond localhost.
## Atmosphere & style The session carries the electrifying, celebratory atmosphere of a major tech conference, balancing high-energy keynote enthusiasm with grounded engineering pragmatism. Mario Rodriguez brings passionate, motivational rhetoric—forcefully rejecting the idea of developers becoming assembly-line cogs in 'software factories'—while Evan Boyle provides a frank, relatable engineering perspective complete with unvarnished terminal logs and the humorous frustrations of steering stubborn agents. The talk transitions seamlessly from sweeping historical parallels about human discovery to deep-in-the-weeds CI optimization, leaving the audience inspired to push past local prototyping friction and build collaboratively in the open.
## Bulletin - [02:42](https://www.youtube.com/watch?v=BR65KdRfGvY&t=162s) GitHub CPO Mario Rodriguez rejects the notion of automated software factories, framing the emerging development model around humans setting direction while agents close the loop from planning to deployment. - [11:40](https://www.youtube.com/watch?v=BR65KdRfGvY&t=700s) Copilot Fusion combines intelligent model routing with runtime orchestration, cutting token costs significantly while producing richer multimodal and interactive software experiences. - [16:08](https://www.youtube.com/watch?v=BR65KdRfGvY&t=968s) GitHub introduced Lever, an open-source framework that automates CI tuning and codebase refactoring using multi-armed bandits, halving time-to-green while letting teams calibrate autonomy levels from L2 up to L4. - [21:39](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1299s) Using Copilot CLI automations and background shepherd agents, a GitHub engineer split a 600,000-line Rust crate in half over five days and merged 19 pull requests while typing only 38 total messages to agents.
## Key takeaways - [00:03](https://www.youtube.com/watch?v=BR65KdRfGvY&t=3s) Human progress has consistently been propelled not by isolated technology, but by collaboration, open sharing, and community iteration across generations. - [02:42](https://www.youtube.com/watch?v=BR65KdRfGvY&t=162s) Software developers are creative directors rather than assembly line workers, and the value of agents lies in finishing end-to-end software work rather than generating raw lines of code. - [05:25](https://www.youtube.com/watch?v=BR65KdRfGvY&t=325s) GitHub's agent-native engineering framework rests on six pillars: collaborative runtimes, agent networks, quality controls, security guardrails, adaptive context learning, and enterprise governance. - [06:48](https://www.youtube.com/watch?v=BR65KdRfGvY&t=408s) The updated GitHub Copilot app incorporates customizable dashboards resembling TweetDeck alongside project workspaces designed to discover, fork, and remix open-source community skills. - [11:40](https://www.youtube.com/watch?v=BR65KdRfGvY&t=700s) Community-developed workflows—such as transforming Mermaid text diagrams into styled SVGs—illustrate how open-source contributions can be rapidly packaged into reusable Copilot canvas skills. - [13:00](https://www.youtube.com/watch?v=BR65KdRfGvY&t=780s) Copilot Fusion operates as a model routing and runtime orchestration engine rather than a standalone model, delivering complex applications at substantially lower API credit costs. - [16:08](https://www.youtube.com/watch?v=BR65KdRfGvY&t=968s) Accelerated AI code generation introduces an operational paradox by multiplying code reviews, growing unit test suites, and causing severe bottlenecks in continuous integration pipelines. - [19:30](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1170s) Lever tackles CI maintenance by orchestrating concurrent agent experiments as multi-armed bandits, evaluating runtime performance improvements and discarding regressions automatically. - [19:30](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1170s) In internal trials, 20 parallel Lever agents generated 20 successful optimization pull requests that halved CI pipeline wait times without requiring manual intervention on flaky tests. - [24:19](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1459s) Lever allows developers to explicitly set autonomy scales in a lever.yaml file, ranging from requiring pull request approvals on production repositories to full unattended merging on private projects. - [24:19](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1459s) By integrating with the GitHub Model Context Protocol (MCP) server, local Lever workflows can be promoted to Copilot Cloud automations that execute unattended on daily or weekly schedules. - [27:30](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1650s) Offloading repetitive pipeline maintenance to autonomous agents frees senior software engineers to focus on creative prototyping, system architecture, and evaluating model failure modes. - [28:53](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1733s) Engineers should resist perfectionism and escape localhost by committing and sharing incomplete prototypes so the broader developer ecosystem can remix them.
## Detailed walkthrough ### [00:03](https://www.youtube.com/watch?v=BR65KdRfGvY&t=3s) Fire, Progress, and the Roots of Human Collaboration
Mario Rodriguez takes the stage at GitHub Universe, opening with high energy and hyping up the morning keynote's technical breakthroughs—particularly hitting 7,200 writes per second on Git, which he celebrates as next-level performance that is 180 times faster than existing systems. To put modern software tooling in perspective, he pulls the audience all the way back to the dawn of humanity. He paints a sensory picture: you are cold, sitting in the dark, having eaten raw meat your entire existence, until someone approaches with two sticks, creates friction, sparks a flame, and introduces fire. Beyond providing warmth, vision, and tastier food—which he jokes was the literal inception of Texas barbecue—fire demonstrated a profound lesson: humanity's real power does not lie in merely discovering a capability, but in shaping it, sharing it, teaching it to others, and refining it across generations.
He traces this collaborative arc through history: from the invention of the wheel and the printing press to the birth of modern computing. He recalls how in 1948, the Manchester Baby executed a program stored in electronic memory, followed rapidly by transistors shrinking hardware down, the birth of operating systems, modern programming languages, open protocols, open-source licensing models, and eventually Git enabling massive parallel development. Throughout every technological leap, Rodriguez insists that the core engine driving humanity forward has never been isolated tools, but the interconnectedness of people.
“The underpinnings of human progress have always been collaboration and community.” — Mario Rodriguez
[02:42](https://www.youtube.com/watch?v=BR65KdRfGvY&t=162s) Humans Set Direction, Agents Close the Loop
Addressing the room of developers directly, Rodriguez tackles the mounting anxiety surrounding artificial intelligence and industry rhetoric about automated replacement head-on. Pointing to the GitHub contribution squares, he reminds developers that they are the lifeblood of the platform. He aggressively pushes back on the concept that builders are destined to become mindless workers in automated "software factories," declaring with palpable passion: "f that." Software developers are not cogs on an assembly line; they are the creators. He explains that GitHub's goal is dual-pronged: lowering the barrier to entry to bring in one billion new builders, while simultaneously raising the ceiling for seasoned engineers so they can tackle civilizational challenges, such as writing the code that will eventually help cure cancer.
Rodriguez reflects on the rapid evolution of developer tooling since GitHub Copilot debuted in 2021. What began as ghost text—where engineers simply pressed tab to accept autocomplete suggestions—quickly shifted into delegating tasks via tool calls and reviewing code diffs. Today, the dynamic has evolved into setting overarching goals, steering outcomes, and offloading mundane toil so developers can stay in a creative flow state, much like a jazz musician improvising new melodies while supported by their backing band. However, he warns that flashy demos bound to localhost do not equate to real business value; the true metric of engineering systems must be completed software work.
“So for me, humans set directions, agents close the loop.” — Mario Rodriguez
```mermaid flowchart LR accTitle: The New GitHub Flow accDescr: An event triggers an agent-assisted loop progressing from intent to completed software work. subgraph Trigger["Trigger Event"] E["Event<br/>• User request<br/>• Code change<br/>• Production signal"] end
subgraph CoreLoop["Agent-Native Engineering System"] P["Plan"] --> B["Build"] B --> V["Verify"] V --> O["Observe"] end
subgraph Outcome["Outcome"] W["Completed Software Work<br/>(Escapes Localhost)"] end
E --> P O --> W ```
- Six integrated pillars form GitHub's agent-native engineering system: 1. Collaborative run-time surfaces where humans and agents interact. 2. An agent network operating across workflows. 3. Quality controls to uphold code standards. 4. Built-in security layers to safeguard the engineering bar. 5. An adaptive learning machine that retains intelligence and context. 6. Enterprise trust controls enabling organizations to manage costs, govern access, and maximize ROI.
[06:48](https://www.youtube.com/watch?v=BR65KdRfGvY&t=408s) The GitHub Copilot App and Community Remixing
Transitioning into live software demonstrations, Rodriguez shows off the newly revamped GitHub Copilot application and dives into an experimental feature called Dashboards. Configured with a layout reminiscent of TweetDeck, the dashboard streams live widgets tracking incoming repository issues, active pull requests, automated check statuses, and recently merged code. Opening a real pull request submitted by colleague Evan Boyle, Rodriguez shows how quickly a reviewer can inspect recommended changes and audit diffs across files. He also highlights a discovery pane displaying trending repositories, community leaders, and popular developer tools, underscoring that the Copilot app is engineered to encourage engineers to discover, fork, and remix projects directly.
He demonstrates how he used Copilot Projects to manage his entire keynote presentation, alongside an agent workspace dubbed "Mona" that handles personalized skills and coordinates development across multiple repositories. Demonstrating Copilot's multimodal abilities, he asks it to generate humorous artwork around flaky tests—joking that an agent resolved a test simply by deleting it—and prompts the model to iterate on three alternate artistic styles. Rodriguez then ties this creative workflow back to open-source sharing by displaying projects like "Anatomy" and Lucas's "Hairline" canvas tool, demonstrating how developers can pull community-authored skills into their local Copilot environment, run interactive terminal sessions, customize system graphics, and immediately remix community work into personalized applications.
“The unit of value isn't tokens or lines of code is these outcomes.” — Mario Rodriguez
[11:40](https://www.youtube.com/watch?v=BR65KdRfGvY&t=700s) Community Remixing: Palette Diagrams, Skills, and Fusion
Mario Rodriguez highlights the compounding power of the developer community, emphasizing how open-source collaboration allows developers to instantly discover, remix, and publish tooling rather than starting from scratch. Demonstrating Palette (previously discussed alongside Mermaid integrations), he shows how raw, utilitarian text diagrams can be converted into styled, production-ready SVGs. He credits community member Kopano for sharing the Obsidian integration, noting that official GitHub app support is shipping shortly. Kevin then took those diagrams, drew one manually, and styled it into an elegant flowchart: “Mermaid just by itself is not that pleasant to look at. But now you could do something like this and you could create a normal diagram.” Mario took Kevin’s work a step further by packaging it into an agent skill inside a custom canvas application, demonstrating a live execution that renders styled diagrams directly from user prompts. He sums up the open-source philosophy driving these releases: “This in my opinion, is the power of community. And this is why we exist, is to allow you to get things out there that are sharing the open source and then remix it and do more with it.”
```mermaid flowchart LR accTitle: Community Remix Pipeline accDescr: Progression from raw Mermaid flowchart to Kopano's Obsidian export, Kevin's styling, and Mario's automated Copilot canvas skill.
subgraph Community ["Community Contributions"] A["Raw Mermaid Flowchart"] --> B["Kopano: Obsidian SVG Integration"] B --> C["Kevin: Custom Styling & Flow"] end
subgraph GitHubEngine ["Copilot Automation"] C --> D["Mario: Reusable Copilot Skill"] D --> E["Interactive Canvas Application"] end ```
Transitioning from UI styling to execution efficiency, Mario showcases Copilot Fusion. Clarifying a common misconception about the tech stack, Mario states: “Fusion is not a model. I don't want you to think about it as a model. It's two items together: it's a model routing, it's a way for us to actually write the right place, and then it's model orchestration at runtime.” To demonstrate its performance, he shares a personal anecdote about building an interactive solar system application for his nine-year-old daughter across different models, using identical, simple prompts (“I want to create my daughter a solar system. Recreate it for me. Please make it engaging”):
- **Astra:** Generated an interactive solar system showing all planets for 1,254 API credits (around $1.25, at $0.01 per credit). - **Claude Opus:** Produced an ambitious, slightly buggy 3D planetary exploration experience, consuming 1,800 credits (~$1.80). - **Copilot Fusion:** Produced a rich experience complete with guided space missions for only 400 credits (~$0.40), achieving higher engagement at a fraction of the token cost.
[16:08](https://www.youtube.com/watch?v=BR65KdRfGvY&t=968s) The CI Maintenance Crisis and the Origin of Lever
Mario invites Evan Boyle to the stage to examine the other side of the equation: “raising the ceiling” on what senior software engineers can accomplish when autonomous agents close the loop. Evan describes gathering GitHub’s most forward-thinking engineers—specifically “not the people using the most tokens, but the people who are having the most impact with the smallest number of tokens, who are putting those tokens to use in the right place.” Analyzing hundreds of gigabytes of raw Copilot terminal and app session logs, the team extracted recurring patterns to see where autonomous execution creates leverage and where it creates unexpected drag.
Agents inevitably introduce a hidden paradox: because agents generate code rapidly, they drastically increase mundane downstream toil—multiplying code reviews, producing large pull requests, and saturating continuous integration pipelines with endless suites of unit tests. Teams quickly find themselves stuck waiting on the dreaded “long pole” in CI builds, such as a lagging shard six that blocks an entire deployment pipeline. Evan notes that throwing more hardware or virtual runners at the problem is ineffective; in their own repositories, queue wait time was a negligible three seconds, yet getting a PR green still dragged on for 45 to 60 minutes with a staggering 20% test flake rate:
> “Code grows inside the repo exponentially, and CI doesn't automatically keep up. Everybody I know is spending significant amounts of time on this problem.” — Evan Boyle
To fix this systemic failure, GitHub built **lever**, a tool engineered to establish structured, autonomous feedback loops. Lever asks developers to define high-level parameters—the target metric, instrumentation hooks, the baseline noise floor, and the keep/drop threshold—and lets agents run the repetitive engineering cycles required to optimize the system.
[19:30](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1170s) Automating CI Optimization with Multi-Armed Bandits
Evan outlines how the team applied lever directly to their CI performance crisis using an experimentation arm modeled after multi-armed bandits. At peak execution, lever spun up 20 agents running concurrent experiments against the runtime and application build workflows. Rather than forcing human engineers to babysit CI runs, re-trigger flaking tests, or manually evaluate compiler tweaks, lever orchestrated the entire trial process autonomously. When an experimental configuration improved performance without flaking, lever stacked it into a series of candidate PRs; when an idea failed or degraded runtime, lever discarded the branch and immediately pulled another hypothesis from the queue.
```mermaid flowchart TD accTitle: Lever Autonomous Multi-Armed Bandit Engine accDescr: Flowchart showing lever running 20 parallel optimization experiments, filtering out regressions, and stacking successful PRs for human approval.
subgraph AgentPool ["20 Concurrent Agent Experiments"] E1["Exp 1: Compiler Flags"] E2["Exp 2: Shard Splitting"] E3["Exp 3: Dev Drive Win-Arm64"] end
subgraph DecisionEngine ["Lever Evaluation Loop"] E1 -->|"Success: Speedup Verified"| Stack["Stack into Candidate PRs"] E2 -->|"Success: Reduced Latency"| Stack E3 -->|"Failure: No Perf Gain"| Drop["Drop Branch & Evict"] end
subgraph HumanReview ["Human Steering (L2 Autonomy)"] Stack --> Merged["Cornelius Reviews & Lands 20 PRs"] Drop --> Queue["Pop New Hypothesis into Arm"] end ```
One candidate experiment stemmed from a tweet by Clint Rutkas regarding Windows Arm64 builds on Dev Drive. Although testing revealed that specific optimization did not yield speedups in GitHub's environment and was dropped, the relentless exploration cycle discovered dozens of other wins. Over a single day and a half of autonomous runs, the agents managed flaky tests and long builds entirely in the background:
- **20 parallel agents** ran simultaneous optimization hypotheses. - **20 successful PRs** were generated (10 targeting the main app, 10 targeting the runtime). - **Time to green was cut roughly in half** without requiring human developers to click single retry buttons on flaky builds. - GitHub engineer Cornelius reviewed and landed the runtime PRs, verifying that the agent's performance math and benchmark gains checked out.
[21:39](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1299s) Splitting Monolithic Crates and Setting Autonomy Scales
Evan transitions to a second case study: tackling a massive monolithic codebase that had swelled to nearly 600,000 lines of Rust in a single crate. To prevent compilation and test runs from slowing down again, Cornelius set out to cut the crate in half. Cornelius, an avid terminal user, used `goal` inside the Copilot CLI alongside automated scheduled triggers and a dedicated shepherd agent assigned to keep PR branches green against main.
Over five days, 19 out of 20 generated PRs were successfully merged, accelerating CI times by an additional 28%. Despite the scale of the refactor, Cornelius personally typed only 38 messages to the agents across the entire five-day span. Evan shares unvarnished terminal receipts highlighting the realities of human-agent steering. When an agent paused over a git rebase issue, Cornelius typed: *"Merge conflict push immediately"*, followed shortly by the exasperated realization familiar to modern developers: *"Which bit about push immediately did you not understand?"* Cornelius paused, introspected into the agent's failure state, refined his guidance, and steered the runner back on track.
All of these automated patterns—running multi-armed bandits, large-scale refactoring loops, and shepherding PRs to green—are packaged into lever under single-verb commands. Crucially, lever does not impose all-or-nothing delegation; developers explicitly designate the autonomy tier for each task:
> “The great thing about lever, by the way, is that it lets you choose the autonomy scale. So for my CI changes, I chose L2, write the PRs get open.” — Evan Boyle
[24:19](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1459s) Lever Autonomy Levels and Copilot Cloud Automations
Evan Boyle explains how autonomy dials are configured across different environments using Lever, a framework GitHub has open-sourced. While someone like Cornelius—acting as an expert—might choose when to merge in production systems, Evan sets his own side projects to Level 4 autonomy (L4), allowing autonomous agents to merge changes directly into his personal, private repositories. These autonomy permissions are configured on a repository-by-repository basis inside a `lever.yaml` file. While Cornelius previously ran his unattended agents on a dedicated cloud virtual machine, Evan points out that self-managed VMs come with operational friction like mandatory OS updates. To solve this, Lever integrates directly with GitHub Copilot Cloud automations so tasks can run fully managed in the cloud without local oversight.
```mermaid flowchart TD accTitle: Lever Local to Cloud Automation Workflow accDescr: Flow diagram showing how Lever reads repository autonomy settings from lever.yaml and offloads CI optimization tasks to Copilot Cloud automations via GitHub MCP Server.
subgraph Config ["Configuration Stage"] A["Developer enters command<br/>'lever optimize runtime...'"] --> B["Read lever.yaml<br/>(Dials & workspace state)"] B --> C{"Check Autonomy Level<br/>(e.g., L2 on production, L4 on private)"} end
subgraph Execution ["Execution Stage"] C --> D["Copilot Fusion loads skill<br/>& applies agent etiquette"] D --> E["Developer runs<br/>'lever automate'"] E --> F["GitHub MCP Server configures<br/>Copilot Cloud Automations"] F --> G["Unattended Cloud Agent runs,<br/>opens PRs daily/weekly"] end ```
To demonstrate, Evan contrasts the traditional workflow with the new agent-driven approach. In the past, optimizing a build pipeline required hand-steering: an engineer would repeatedly prompt an assistant with dozens of iterative messages like "analyze CI time to green." With Lever, Evan simply executes a command like `lever optimize runtime and app CI time to green` utilizing Copilot Fusion. The agent reads the dials and workspace state directly out of `lever.yaml`, recognizes that the active repositories are constrained to Level 2 (L2) autonomy, and adheres to the established team etiquette for safe execution. Rather than tying up his local machine, Evan halts the local process and enters `lever automate` with the prompt "Move this to the cloud, please." This invokes the GitHub Model Context Protocol (MCP) server to establish a scheduled Copilot Cloud automation that runs independently, automatically opening pull requests for team review on a daily or weekly cadence. Evan invites the audience to find him at the conference after-party an hour later to inspect the pull requests and CI improvements the cloud automation produced while running unattended.
- Autonomy levels can be customized per repository using a `lever.yaml` configuration file (e.g., L2 for guarded repositories, L4 for auto-merging private code). - Lever uses Copilot Fusion to dynamically load domain skills and enforce agent etiquette based on configured workspace autonomy dials. - The GitHub MCP Server offloads local agent workflows into background Copilot Cloud automations that open pull requests on custom schedules.
---
[27:30](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1650s) Reclaiming Engineering Time for Creative Work
Evan emphasizes that the core objective of building and open-sourcing Lever is not to spend endless hours managing agents or manually micromanaging CI optimizations, but to offload routine maintenance so developers can return to creative work. Software engineers across GitHub have adopted these autonomous workflows to eliminate repetitive toil, such as splitting test suites or tuning build times. By passing those time-consuming tasks to background agents, engineers reclaim space for the aspects of programming they genuinely love.
Reflecting on his own daily routine, Evan explains that he uses his newly liberated time to focus on "hill climbing"—a continuous feedback loop of analyzing where agents fail, designing robust evaluations (evals), and systematically improving agent capabilities every single day. Beyond refining model performance, he finds deep creative fulfillment in zero-to-one product development, rapid prototyping, and experimentation. Evan sums up the philosophy behind their tooling with an explicit challenge to the audience: “Give the agents to the boring stuff. Keep the fun stuff for yourself.”
- Lever is open-sourced to enable teams to delegate toil-heavy developer tasks and file feedback or issues directly with the project maintainers. - Reclaimed engineering time is channeled into hill climbing (creating evals and improving agent accuracy), zero-to-one product conception, and exploratory coding.
---
[28:53](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1733s) Escaping Localhost and Imagining Tomorrow
Mario Rodriguez returns to the stage to contextualize how Lever fits into GitHub's broader vision of lowering the barrier to software creation while raising the ceiling for experienced engineers. He frames Lever as an active, open-source experiment that GitHub will continue expanding alongside the developer community. Mario highlights several features available for developers to test immediately: Copilot Fusion, GitHub Projects integrations, Code Review Max, and cloud-backed Agentic automations that drive autonomous loops.
Mario issues a passionate call to action, urging developers to revisit half-formed ideas or revive neglected repositories gathering dust on their machines. He warns against perfectionism and hoarding prototypes on personal workstations, declaring: “Let us escape localhost. Don't be ashamed of it. Commit. Push it. Share it.” By publishing unfinished projects publicly, developers provide starting blocks and raw inspiration for someone else in the global community to remix and build upon.
Closing out the presentation, Mario shares an illustration created by Maggie Appleton from the GitHub Next team. The artwork reflects the present reality—where developers wrestle with the friction of learning how to collaborate alongside agents—while simultaneously leaving space to imagine the future. Mario projects that this friction will soon evaporate, unlocking seamless pipelines between an engineer's intent and working software. He concludes that realized progress will always hinge on foundational human qualities: “We all have dream ideas and intentions, and the best way to realize them is through the same things that got us here today: creativity, collaboration, and community.”
- Featured tools ready for developer use include Copilot Fusion, Code Review Max, GitHub Projects integrations, and Copilot Cloud automations. - Speakers arranged an in-person follow-up session at the conference speakeasy at 12:15 to discuss community projects and inspect live cloud automation results. - The session concludes with Maggie Appleton's GitHub Next visual thesis, underscoring that human creativity, collaboration, and community remain the essential drivers of software evolution.
## Notable quotes > [02:42](https://www.youtube.com/watch?v=BR65KdRfGvY&t=162s) So for me, humans set directions, agents close the loop. — Mario Rodriguez
> [16:08](https://www.youtube.com/watch?v=BR65KdRfGvY&t=968s) Code grows inside the repo exponentially, and CI doesn't automatically keep up. Everybody I know is spending significant amounts of time on this problem. — Evan Boyle
> [00:03](https://www.youtube.com/watch?v=BR65KdRfGvY&t=3s) The underpinnings of human progress have always been collaboration and community. — Mario Rodriguez
> [27:30](https://www.youtube.com/watch?v=BR65KdRfGvY&t=1650s) Give the agents to the boring stuff. Keep the fun stuff for yourself. — Evan Boyle
## Mentioned Mario Rodriguez, Evan Boyle, Cornelius, Kopano, Kevin, Lucas, Maggie Appleton, Clint Rutkas, GitHub, GitHub Copilot, GitHub Copilot Cloud, GitHub Next, GitHub Projects, Code Review Max, Copilot Fusion, Lever, Git, Manchester Baby, Palette, Obsidian, Mermaid, Astra, Claude Opus, GitHub Model Context Protocol (MCP) Server, Rust, Windows Arm64 Dev Drive
## Video description The value of an agent isn’t measured by how much code it writes, but by how much software work it finishes. In this GitHub Universe 2026 session, GitHub Chief Product Officer Mario Rodriguez and Principal Engineering Manager Evan Boyle explore a new operating model where developers define outcomes and standards while GitHub Copilot agents carry work through the entire development loop. Discover how autonomous agents move beyond code generation to plan, review, secure, and deploy software while keeping people accountable for what ships. Learn how teams connect context, workflows, and enterprise controls to delegate ambitious tasks with confidence.
Speakers: Evan Boyle, Principal Manager, Software Engineering, GitHub Mario Rodriguez, Chief Product Officer, GitHub
Watch more videos from GitHub Universe 2026: https://www.youtube.com/watch?v=AArI948SDz8&list=PLENrlACZ7mnU
— CHAPTERS —
00:00 Welcome to GitHub Universe 2026 00:33 Humanity's progress through collaboration 02:42 Humans set direction, agents close the loop 05:25 The agent native Engineering system 06:48 GitHub Copilot app & community remixing 16:08 Raising the ceiling with GitHub Copilot agents 19:30 Automating CI with lever 24:07 Lever autonomy & cloud automations 27:30 Reclaim time for creative work 28:53 Share your work, imagine tomorrow
#GitHubUniverse #GitHubCopilot #AIAgents
Stay up-to-date on all things GitHub by connecting with us:
YouTube: https://gh.io/subgithub Blog: https://github.blog X: https://twitter.com/github LinkedIn: https://linkedin.com/company/github Insider newsletter: https://resources.github.com/newsletter/ Instagram: https://www.instagram.com/github TikTok: https://www.tiktok.com/@github
About GitHub It’s where over 180 million developers create, share, and ship the best code possible. It’s a place for anyone, from anywhere, to build anything—it’s where the world builds software. https://github.com
[Source](https://www.youtube.com/watch?v=BR65KdRfGvY)