GitHub Open-Sources Lever to Automate CI Pipelines With Agents

Humans set direction. Agents close the loop. — GitHub

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)

Reading summary

GitHub leadership argues that autonomous software agents should handle downstream maintenance and execution loops, while human engineers set intent, steer outcomes, and reclaim time for creative problem-solving. Redefining the Engineering Loop Beyond Autocomplete (2:42) Mario Rodriguez counters concerns about developer replacement by framing agents not as automated factories, but as mechanisms to raise engineering ceilings and reduce the barrier to entry for new builders. Developer tooling has evolved from ghost-text tab autocomplete to delegating tool calls, steering multi-repository systems, and setting high-level outcomes. Rodriguez stresses that engineering value must be measured in completed software rather than local demos, organizing GitHub's agent-native engineering framework across six core pillars: collaborative runtime surfaces, agent networks, quality controls, security layers, adaptive learning systems, and enterprise trust controls. Community Remixing and Efficient Model Routing (11:40) GitHub emphasizes open-source sharing and iterative remixing, demonstrating how tools like Palette transform raw Mermaid text into styled SVG diagrams through community contributions from members like Kopano and Kevin. Rodriguez also introduced Copilot Fusion, clarifying that it is not a standalone foundational model, but a dynamic model-routing and runtime orchestration layer. In an experiment comparing generation costs for an interactive solar system application, Fusion required 400 credits (~$0.40), compared to 1,254 credits (~$1.25) on Astra and 1,800 credits (~$1.80) on Claude Opus, achieving comparable or superior engagement at a lower token cost. Resolving Downstream CI Bottlenecks with Lever (16:08) Evan Boyle highlights an operational paradox: because agents generate code rapidly, they create an influx of downstream engineering toil, including oversized pull requests, frequent code reviews, and saturated continuous integration pipelines. In internal repositories where queue times averaged three seconds, builds took 45 to 60 minutes with a 20% test flake rate. To automate the feedback loops required to solve these delays, GitHub developed an open-source framework called Lever, which relies on multi-armed bandit experimentation to test compiler flags and pipeline optimizations concurrently. Over a day and a half, 20 parallel agents produced 20 validated PRs that roughly halved the time required to reach a green build. Configurable Autonomy and Cloud Automations (24:19) Lever lets developers define explicit autonomy dials using a repository-level `lever.yaml` configuration. Guarded production environments can be restricted to Level 2 (L2) autonomy—where agents generate PRs for human audit—while personal projects can run at Level 4 (L4) for automated merging. Boyle detailed how senior engineer Cornelius used Copilot CLI to cut a 600,000-line monolithic Rust crate in half, merging 19 out of 20 generated PRs and reducing CI times by 28% while manually sending only 38 steering prompts over five days. Rather than running tasks on local machines, Lever integrates with the GitHub Model Context Protocol (MCP) server to schedule unattended cloud automations. Reclaiming Time for High-Leverage Creative Work (27:30) Boyle and Rodriguez emphasize that delegating repetitive maintenance tasks allows engineers to focus on higher-leverage priorities, such as rapid zero-to-one prototyping, exploratory programming, and 'hill climbing'—the systematic design of evaluations (evals) to correct failure modes and improve agent capabilities. Rodriguez urged developers to escape the friction of perfectionism by publishing prototypes and unfinished projects to public repositories so the community can build on them. GitHub projects that current frictions in human-agent collaboration will steadily decline as agentic loops mature, but stresses that real-world outcomes still depend on human intent, governance, and open community exchange.

Source quotes

[2:42] Mario Rodriguez: So for me, humans set directions, agents close the loop. [16:08] Evan Boyle: 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. [0:03] Mario Rodriguez: The underpinnings of human progress have always been collaboration and community. [27:30] Evan Boyle: Give the agents to the boring stuff. Keep the fun stuff for yourself.

Original transcript

[0:03] Please welcome Mario Rodriguez. [0:10] Good morning. Good morning GitHub Universe. [0:14] What about some of those announcements at the Keynote 7200 writes per second on Git. [0:22] Who's excited about that? [0:24] That's next level. That's 180. X better than anything out there in the system today. [0:30] It's incredible. [0:32] I actually want to start today by taking you back a bit [0:36] to one of humanity's very first tool. [0:39] I want you to imagine this. [0:41] Your cold is dark and you've been eating raw meat your whole life. [0:47] Somebody walks over with a couple of sticks and says, watch this. [0:53] It's a little bit of friction. [0:55] It's a bit of a spark and boom, fire. [0:59] You get fire for the first time. [1:01] You're warm, you can see. [1:04] And dinner just got a whole lot better. [1:06] I mean, if you're from Texas in the room, that was the start of barbecue right there. [1:11] So but the real power, right, isn't just knowing how to do it. [1:15] It's shaping it. It's sharing it so others can learn so they can improve it [1:21] so they can pass it on. [1:25] Now we did this. Humanity did this with the wheel, the printing press, [1:30] and eventually with computing. [1:33] In 1948, the Manchester baby runs a program stored in memory. [1:39] Not long after transistors begin to make computers smaller and smaller, [1:45] we create operating systems, programing languages, [1:48] and open protocols so we could share and create these networks. [1:53] Now open source licenses end up. [1:56] Then removing these barriers and get. [1:59] Let us collaborate in parallel. [2:02] The underpinnings of human progress have always been collaboration and community. [2:09] And that's the part of this story that I don't want us to lose. [2:12] I don't want you to think going forward that we're going to lose that. [2:19] Like that is what makes us special, that you could learn from someone you never met, [2:23] built on their work and give something back. [2:28] So to every developer in this room, to every developer out there, [2:33] those squares of GitHub are you and you are GitHub. [2:38] You are why we exist. [2:42] So as I reflect, and I know you've been hearing people talk about replacing you [2:47] and about building this freaking software factories. [2:50] And you know what I say to that f that, f that. [2:55] We're not going to freaking replace you. [2:59] You are GitHub and GitHub is you. [3:04] You're not a robot in an assembly line. [3:08] You're the ones that create. [3:09] And us humanity will continue to push forward from that very first contribution. [3:14] I don't know when it happened for you, but from that very first contribution [3:18] to a project, others depend on the team building together. [3:22] That is an interconnected community. [3:25] That interconnected community is GitHub and we power it. [3:29] We're lowering the floor. [3:31] And I've been talking about this a lot more. We're lowering the floor [3:34] so more people can come in. We want to create 1 billion builders out there, [3:39] but we also want to raise the ceiling as more and more people come and create with us [3:44] and share with us, we want them to become professionals, [3:47] and they're going to go in and actually increase their craft. [3:52] When we solve cancer, there's going to be a team of developers that worked [3:56] on software to make that happen. [3:58] That is raising the ceiling. [4:01] The tools themselves will keep changing, so let's be honest about that. [4:05] They are not going to stay static. [4:06] And we know that and they're changing faster than ever before. [4:12] If you think about it, we launched Copilot in 2021 [4:17] and that was a beautiful beginning, right? [4:19] That was the beginning of us actually working with AI. [4:23] You first started accepting a few lines of code. [4:27] If you remember, it was ghost text and you tap, tap, tap. [4:30] Then you were given an agent a task your delegation ended up being tool calls. [4:35] You accepted tool calls and then accepted a diff. [4:39] And now what are you doing? [4:40] You're setting a goal. You're steering it towards an outcome. [4:43] You're giving agents the routine work so you can focus on creating. [4:49] You can focus on building. [4:51] So like a jazz player who's found their groove listening and improvising [4:55] and taking that music somewhere new with the band right there supporting them. [4:59] That's how we want building to feel. [5:02] That's what I want to keep here, [5:04] to give agents that routine work and then to keep you all in flow. [5:09] So for me, humans set directions, agents close the loop. [5:13] Humans set directions, agents close the loop, and that loop has to escape localhost. [5:19] There's a lot of things that happen that don't escape localhost. [5:21] We need to escape localhost because that's how we'll measure the system. [5:25] Right? Completed software work. [5:27] Jay mentioned this in the keynote. [5:29] Completed software work. [5:31] So a flashy demo isn't going to be enough. [5:33] We need to complete software work. [5:36] The unit of value isn't tokens or lines of code is these outcomes. [5:41] And to make that possible, [5:42] we're bringing six parts together surfaces where humans [5:47] and agents collaborate at runtime, an agent network quality, and security. [5:53] To uphold that engineering bar, we need to uphold that engineering bar, [5:58] a learning machine that carries it forward with intelligence and enterprise trust. [6:03] Organizations can scale and actually manage engagement costs and improve their ROI. [6:09] Now, together, these forms are agent native engineering systems. [6:13] Together, they make up the platform that powers your creativity, [6:17] that keeps you in flow. [6:19] Now the new loop starts with an event. [6:21] And you saw this in the keynote, a request from you, a code change, [6:25] a signal from production. [6:27] The system helps carry it through planning, building, verifying and observing. [6:32] From intent to complete a software work. [6:37] That's the new GitHub Flow. [6:39] That's intelligence at the middle. [6:41] Always being proactive with you. [6:43] And this is the future we're going towards. [6:47] Now, since this is a dev conference, [6:49] I want to show you a couple of things that hopefully you didn't see in the keynote [6:53] as well. [6:56] Okay, perfect. So this is the new GitHub Copilot app. [7:00] If you haven't downloaded, please do so. [7:02] And I am right now in an experimental feature. [7:05] So if you go into experiments, you're going to be able to actually enable this. [7:10] And this is dashboards. [7:12] So what I could do right now in it, I could set up a set of widgets. [7:15] Think about it like X, TweetDeck and things like that. [7:18] And I have my Copilot app. [7:19] All of the issues are coming in. I have my pull requests that are being opened. [7:24] This is live data. That's why you saw one actually pop up. [7:26] And this is a real actual check failing at that moment. [7:30] And then I could also see some of the things that we have recently merged as well. [7:34] So this is one of those PRS. [7:35] I could go full screen on it, [7:37] try to see what that PR actually is about the changes recommended. [7:41] This is Evan. You're going to see him later. [7:43] He's going to do an awesome demo for us. [7:46] I could just go through the files [7:47] and you can see how fast we could actually go through all [7:49] of the changes in here overall. [7:51] And then I have something for you later. [7:53] Not today that we could actually do as well. [7:56] So here's the new GitHub app. [7:59] The other thing that I actually really like about this, if I go back into it, [8:03] is that you're going to be able to see trending Repo. [8:06] So right from right here, [8:08] I'm going to be able to see that community right now is actually at the top. [8:12] And then you see some trending deaths as well [8:15] and the amazing projects that this community has. [8:18] So from right here, you can start then interacting with them and then remixing, [8:22] remixing with them as well. [8:24] So that's number one. The other thing that you saw today in the Keynote was projects. [8:30] I'm not going to go too much through them at the moment, [8:32] but I do want to kind of show you one thing overall. [8:36] So I actually built the entirety of this Keynote with a project, [8:42] and then I have another one Mona. [8:44] It's kind of like my personal agent. [8:45] I have some stuff that is skills, [8:47] and then I have the application that will show you across many repos with for coffee [8:52] as well on the left. Now, one of the things is that we could go over here [8:55] and now GitHub Copilot can actually generate images for you. [8:59] So I had asked for a joke and I created this joke, [9:02] which is I asked Canadian to fix one flaky test to close the loop. [9:06] So well, I deleted the test and now she has been green and saying, perfect, give me. [9:12] I know these models are incredible at improv. [9:15] Give me three other images. [9:19] With different styles. [9:23] So I can just do that really quick. [9:25] It's going to think for a second, make sure that I have internet. [9:30] And it's going to come back to us now as it's actually thinking. [9:34] And let's hope that everything is working there as well. [9:37] What I want to do is kind of talk a little bit about how we connect this community. [9:41] So this is a project, it's called anatomy. [9:44] So you probably saw it trending on X at one moment. [9:46] You see right here this GitHub logo, right? [9:49] So almost all of the projects are there [9:52] and the skills they are on where they're on GitHub. [9:54] So where is Ryan created this shared with everyone. [9:58] And then we get something like this. [9:59] So we could go and remix. [10:01] Actually, I ended up doing that as well. [10:04] So if I go back into the app right now [10:06] and there are my three images right there generated, [10:09] I built an automated computer as well. [10:12] You can see how it's going back and forth with the model. [10:14] Now I'm going to walk you through all of these tests, [10:18] but what I do want to show you is the finished project really quick. [10:21] So which is here and the one that you saw before the logo was not GitHub. [10:25] So I ended up doing is when it boots up, it boots up with GitHub and there you go. [10:32] It boots up with GitHub and now it says social coding. [10:34] In fact, this thing is so amazing that you could even type on it. [10:37] You could say, hello GitHub Universe. [10:42] Can you believe that overall? [10:44] And then if I go here, you're able to see that too. [10:47] So I got something from the community. [10:49] I ended up remixing it. [10:51] Now there's another project called hairline. [10:54] And hairline is great because it allows me just to do these quick mockups [10:57] and as a PM, I want to actually do that. [11:00] I want to explain something to people [11:02] and be able to do it with the community as well. [11:05] And here it is. This is Lucas. [11:07] He actually shared that with all of us in GitHub. [11:10] So what I wanted to do is just do the exact same thing. [11:13] I ended up downloading that skill, [11:15] and if we go back to the app and we go back to the overview, [11:20] there's going to be one where we created a hardline canvas for us to explain it. [11:25] So again, this is just me getting the skill from the community and then remixing it. [11:31] This is the session that ended up creating. [11:33] And here it's one of the ones that we did. [11:37] So here's a foldout with our line of this thing called canvas, [11:40] which you saw today in the keynote as well. [11:42] So what this allows me now to do if I want to create a presentation for a customer, [11:46] if I want to do something, then with my team, [11:49] I could quickly get what is in the community, remix it and share it. [11:53] But why stop there, right? [11:54] So Pele, how many people have already downloaded Pele and included in the application [11:58] or palette. [12:00] So what it allows you to do is get mermaid diagrams and actually get an SVG on it, [12:05] but it allows you to also style them, which is incredible. [12:09] And Kopano is the one who actually shared this. [12:12] And here it is as part of obsidian. [12:14] We're ready. We're going to have support in the GitHub app as well. [12:17] So that will be shipping here shortly. [12:20] And then the interesting thing with this, [12:22] and this is what I love about the community, right? [12:25] Kevin ended up getting these diagrams and he drew one himself and then styled it. [12:31] He gave it more. Again, mermaid just by itself is not that pleasant to look at. [12:37] But now you could do something like this and you could create a normal diagram. [12:42] Believe it or not, this is just a normal flowchart. [12:44] And then you could style it overall. [12:47] And that's the power of it. [12:48] So let me show you that example over here as well. [12:51] So if I go to the overview, if I go into my canvas and I go to poly. [12:59] Here is one of them. Let's go full screen on it so you can see it. [13:03] And that's my pallet diagram. [13:04] I could even split it and then style it, [13:07] but I took it one further. Just by itself is not. [13:10] So I took what Kevin did, created a skill for it, [13:14] created a little application and now let's see it in action. [13:17] This is live demo, okay. [13:18] And this is a custom canvas that we just did right just [13:23] before it errored out a second. [13:24] But now it's doing it and you could create it in real life. [13:29] So this in my opinion, is the power of community. [13:33] And this is why we exist, [13:35] is to allow you to get things out there that are sharing the open source [13:39] and then remix it and do more with it. [13:41] I don't know if I did it in real life or not. [13:44] Let's see if we see it again. [13:45] Perfect. Okay. So then the other thing that I wanted [13:48] to show you was fusion just very quick. [13:51] And then fusion. Fusion is not a model. [13:53] I don't want you to think about it as a model. [13:56] is two items together. It's a model routing. [14:01] It's a way for us to actually write the right place. [14:04] And then it's model orchestration at runtime. [14:06] And what we show you is that we could achieve the best quality [14:09] at the best price with that. [14:12] Here's a normal example. [14:13] So I was, I have a nine year old [14:16] and I wanted to teach her a little bit more about the solar system overall. [14:20] So here's Astra and Astra created this for us. [14:23] I could go really quick in it so you can see what it has. [14:26] It has all of the planets. [14:28] I could click on each one of them. [14:30] And then for Astra to create this, it took 1254 API credits. [14:37] So one I credits is is $0.01. So it cost me around 1.2. [14:43] So opus actually did something a little bit more involved, [14:47] which I really appreciate as well. [14:49] But here's I'm going to just explore on my own. [14:51] So now I have a little bit of some of 3D, but it's the same functionality, right? [14:57] I could go in and then learn more about each one of them. [15:00] It's a little bit buggy and ended up just doing one prompt on this, [15:04] so I didn't go and spend that much time. [15:06] And if we go back into it, right, [15:08] what you're going to see is that it took 1.8. So 1.8 k. [15:12] And here's fusion. Same thing. [15:14] One prompt. Look I didn't like I want to create my daughter a solar system. [15:17] Recreate it for me. Please make it engaging. [15:19] That's all I said. And here it is pretty engaging. [15:23] I could go on a space mission as well, which actually she enjoyed. [15:28] I could go in through each one of the planets and learn, learn, [15:32] learn a little bit more about them to guess how much it actually took. [15:38] 400 credits. So 1.8, 1.2, 1.4 400 credits. [15:43] This is what it's all about, right? [15:44] Giving the ability for you to do these things at scale. [15:48] So that's a little bit of lowering the floor. [15:50] And what I want to do is I want to bring Evan back [15:53] to show you what raising the ceiling looks like. [16:00] How are you doing? [16:05] Hey, everybody. Thanks for having me. [16:09] I got together with a bunch of the most AI forward engineers at GitHub, [16:15] not the people using the most tokens, [16:18] but the people who are having the most impact with the smallest number of tokens, [16:24] who are putting those tokens to use in the right place. [16:28] So I get questions a lot about, hey, what's your workflow? [16:31] What skills do you use? [16:33] And so I had all of these engineers get together with me. [16:37] We took all of our sessions, hundreds of gigabytes of session data, [16:42] and we used agents to analyze them and extract out skills and workflows [16:48] and common patterns so that we can share them with you and show you how we work. [16:53] So there is all of this work that nobody wants to do, and agents, in a way, [17:00] end up creating more of it. [17:02] I I'll tell you about that in a second. [17:04] Things like splitting up Russ creates more code review keeping CI fast. [17:12] How many of you have ever woken up and wanted to, you know, [17:16] go rebalance some CI test shards? [17:19] You might do this one time and your agents are just going to add more tests, [17:24] more unit tests, more tests. [17:26] And you end up with a graph that looks like this. [17:29] You wait on that long pull, right? [17:32] We don't want to wait for shard six. [17:34] We want to rebalance things. [17:36] I've done this. I don't know. [17:38] Countless times over the last year and it never stops. [17:46] So Copilot with a human steering. [17:48] I want to tell you two stories. [17:51] Two stories that we pulled out of all of this session. [17:53] Data we brought from this group of engineers. [17:58] Everybody is at a different point in time on this journey. [18:02] I have lots of friends in industry, at startups, at big companies, inside GitHub, [18:09] and also at Model Labs. [18:10] And everyone is facing this problem. [18:13] Code grows inside the Repo exponentially, and CI doesn't automatically keep up. [18:19] Everybody I know is spending significant amounts of time on this problem. [18:26] In two of our repos in the app, in the runtime, [18:28] we had 45 minutes to an hour to get a PR green, and we had a 20% flake rate. [18:36] This was a huge hindrance to our productivity and it was not fun. [18:41] The answer was not to throw more runners at the problem. [18:44] We had only a three second queue time for jobs. [18:50] And so this is what lever does. [18:52] It helps you establish feedback loops. [18:56] You describe? What's your outcome? [18:58] What's your metric? How do we instrument it? [19:02] What's, you know, the noise floor, the keep bar. [19:05] This is how you set up a loop on a problem that has a feedback system built [19:10] into it that agents are really, [19:12] really good at the kind of work that I don't want to do, [19:16] but needs to get done every week, sometimes every day. [19:21] And lever walks you through how to set this up. [19:24] You don't have to know every single step of creating a feedback loop. [19:29] It's really difficult. [19:34] So for the CI problem, we put lever to work and 20 agents were running at peak. [19:40] We call this an experimentation arm. [19:44] Maybe you've heard of a term called multi-armed bandits. [19:47] That's what lever did here. [19:49] It chose 20 experiments. [19:51] It ran them in parallel. [19:53] When one succeeded, it moved it into a stack of pairs. [19:59] When one failed, it got rid of it. [20:01] It added a new experiment to the queue. [20:05] So some of the things we kept, some of the things we dropped. [20:10] This was actually inspired by a tweet that I saw. [20:13] Number four, Dev Drive Clint Ruckus on Twitter was out there helping somebody [20:19] with windows Arm64 builds. [20:21] I saw this tweet and I realized, oh my gosh, [20:25] like that builds slow on our system as well. [20:29] Ran this job. That one didn't work out and we dropped it [20:33] because our builds were slightly different and had some similar optimizations, [20:37] but we found dozens of improvements, ten PR s in the app and ten PR s in the runtime. [20:43] That did succeed. And it's because we didn't stop at checking that one improvement. [20:47] We kept generating ideas to go and test. [20:53] So in one and a half days of letting these agents run. [20:58] They had to, by the way, run CI, wait for an hour, work through those flakes. [21:03] I didn't have to sit there and click retry. [21:05] My agents did it for me. [21:07] CI time roughly half time to green. [21:12] And we got to choose what was the level of autonomy. [21:16] The agents didn't just merge these paths. [21:18] We have a wonderful engineer, Cornelius, who landed all the PRS in the runtime. [21:25] He knows the most about our CI system. [21:26] He was able to make the decisions, and he said that the agent's math checked out. [21:33] But so what happens when it gets slow again, right? [21:39] Cornelius ended up having to go through and split the crates. [21:42] And this was another arc that ended up in the data that resulted in lever. [21:47] We had almost 600,000 lines in one crate and we cut it in half. [21:53] That's what we wanted to do. Right. [21:55] And so Cornelius is a heavier terminal user. [21:59] I'm a heavier app user. [22:01] And he used goal in the Copilot CLI every to run a schedule that checked the work. [22:09] And another shepherd that kept all of the PR is green. [22:16] Five days later, we had 19 out of the 20 press that Cornelius generated were merged. [22:23] It sped up CI by 28%. [22:27] And, you know, this is kind of the point. [22:30] We're spending all this time. [22:31] I'm spending a ton of time. [22:33] Cornelius is spending a ton of time. [22:34] Right. [22:36] But who actually did the typing in this instance? [22:38] Right. Cornelius sent 38 messages only over the course of those five days. [22:45] The rest of it schedules were firing, the instructions, [22:49] the agent keeping itself moving, working towards its goal. [22:54] And I always love this. [22:56] Sometimes we. I write a lot of internal discussion posts [22:59] and blogs about how I use AI, [23:01] and I always love to share the receipts of exactly what I send to my agent. [23:04] So, you know, Cornelius notices he's checking in, says, hey, [23:08] Merge conflict push immediately and I'm sure everyone's experienced this. [23:13] The agents don't quite understand [23:16] which bit about push immediately did you not understand? [23:23] And then Cornelius stops. [23:24] He introspects. He tries to understand this failure. [23:30] So he set the goal, steered. [23:32] When they drifted, he shipped these 19 pairs. [23:36] He introspected as he found these issues, these missteps from the agent. [23:41] And he corrected them. [23:44] And all of this is in lever one command, [23:48] but a verb per job for setting up loops that run autonomously for Experimentation. [23:54] Bandits where you can run arms of experiments, refactoring, [23:59] review shepherding PR to green. [24:02] Helping you work. Helping you organize. [24:06] The great thing about lever, by the way, [24:09] is that it lets you choose the autonomy scale. [24:13] So for my CI changes, I chose L2, write the PR's get open. [24:19] But Cornelius the expert us, we choose when to merge for my side projects. [24:26] L4, I let the agents merge into my personal private repos [24:30] and I can configure this Repo by Repo in my lever dot Yaml file. [24:39] The great thing about this is that lever lets you not just do [24:43] this on your own machine. [24:44] It's great that Cornelius had a VM [24:46] in the cloud where he was running his agents unattended, but those need OS updates, [24:52] right Lever also lets you automate this in the cloud using Copilot Cloud automations. [25:00] So I want to show you what that looks like real quick. [25:03] In the old world, I might have started by talking and saying, hey, [25:07] let's analyze CI time to green, you know, send dozens of messages. [25:11] I'm steering this work by hand, but instead I can run lever arms and say, [25:18] let's optimize runtime and app CI time to green. [25:25] And I'm using Copilot fusion for this. [25:29] And so we'll see. It's going to, it's going to go load the skill. [25:32] It's going to check my autonomy that I've configured in these repos. [25:38] There we go. It's reading the the dials [25:41] and the workspace state for my lever dot Yaml file. [25:47] It picked up that I'm in L2 when I'm working in these two repos, [25:50] so it knows how to stay on the rails. [25:53] What the. Agent etiquette is for this kind of work with this group of people [26:00] and I could let this run locally, [26:02] but instead I'm going to stop it and I'm going to say lever automate. [26:09] Move this to the cloud, please. [26:14] And this is going to use the GitHub MCP Server [26:16] to go configure Copilot cloud automations that will run this job, [26:22] open PRS for me and let me merge them every day, every week, [26:29] whatever I decide to configure. [26:34] Okay. [26:36] By the way, I'll say at the after party, [26:39] if any of you want to check in and see in an hour or [26:42] so what the automations running in the cloud came up with [26:46] in terms of CI optimizations, come find me and we'll, we'll take a look together. [26:55] So that's the most exciting thing is we worked with these engineers. [27:00] You heard the stories about how they're using these workflows, [27:04] not so that they can spend tons of hands on time, on splitting rest rates, [27:09] on CI optimizations. They're using AI to automate that work [27:14] so they don't have to check in on it so they can go and do creative work, [27:19] go do the things that they love about software engineering. [27:23] And that's why we open source lever. [27:25] So really encourage you all to go in, check it out, give it a try. [27:30] File some Issues. [27:34] QR code there for anybody in the audience who wants to go and pull it up. [27:41] I'll leave it up for one more second. [27:48] Great. All right, so what do I like to do with the time that I reclaim. [27:55] I love to do hill climbing. [27:57] That means. [28:00] Basically making the agents better at specific tasks, [28:04] finding areas where the agents fail, building evals and making them better every day. [28:09] Not everybody loves to do it. [28:11] I have a lot of fun with it. [28:13] I love building new products, I love experimentation, [28:17] I find V zero work to be incredibly creative and fulfilling. [28:22] These are the things that I reclaim my time with lever and with agents. [28:29] Get away from optimizing CI, get away from the work that I don't want to do, [28:33] and free up my time for the things that I love. [28:39] So I encourage all of you, give the agents to the boring stuff. [28:45] Keep the fun stuff for yourself. [28:47] Mario, back to you. [28:53] Thank you. Thank you. [28:56] So we're going to continue to make leather better [28:58] and kind of take it in different ways right now. [29:00] Think about it. Just an experiment that we want to open source [29:02] and share with the community as well. [29:04] So, so I show you the lowering the bar of creation and building on top of others. [29:08] Well, Evan, show you how you could get time back to actually continue [29:12] to raise the ceiling. Now, here are some of the new features [29:16] that you could try today. [29:17] I just want to make sure that you see them in there. You saw fusion for a second. [29:20] You show projects. I didn't show you Code review Max, but that was also it really, [29:25] really proud of the team and that and then automations. [29:28] A lot of what liver is doing is through the automations [29:30] and also through the Agentic Agentic loop too. [29:33] So take that idea and something that is in your mind. [29:39] I want you to kind of take something in your mind, that idea [29:42] and give it another shot, try something new, [29:45] go in and dust up an old Repo and make sure that you share it, [29:50] because that could become then a starting point where someone else can take it [29:54] and say, I could do something with that. [29:56] Let us escape localhost. [29:58] Don't be ashamed of it. [29:59] Commit. Push it. Share it. [30:01] In fact, you know, I'd love to hear more about it. [30:03] Like Evan was saying, we're going to be in the speakeasy right after this talk [30:06] at 1215. Now, I want to close with this image. [30:09] And this comes from Maggie Appleton. [30:12] She works in GitHub next. [30:14] And for me, I love this visual because it really reflects today. [30:18] And it also leaves us room to imagine tomorrow. [30:21] She's thinking about what is possible. [30:23] But there's this friction to collaborate with agents as well. [30:27] But in tomorrow, all of that will go away. [30:29] And I will have new ways of actually taking what I have in my head [30:33] and making it through. We all have dream ideas and intentions, [30:37] and the best way to realize them is through the same things that got [30:40] us here today creativity, collaboration, and community. [30:45] Thank you so much and have a great Universe.