GitHub
Unifying the underlying agent harness across editors, terminals, and chat allows engineering teams to deploy autonomous AI agents across existing toolchains without forcing developers into a single interface.
AI-assisted summary of Work together, your way, with GitHub Copilot — original source. Check the original for full context.
Source published:
Key ideas
- GitHub demonstrated a unified architecture across the Copilot desktop app, VS Code, CLI, mobile, web, and Slack, allowing distributed teams to collaborate on a single codebase using identical agent harnesses, models, and MCP servers without forced tooling conformity. (0:03)
- The GitHub Copilot desktop app introduces zero-clone repository sessions via automated Git worktrees, alongside native computer-use capabilities that autonomously launch and functionally verify desktop binaries. (2:35)
- VS Code added Copilot Fusion for dynamic model orchestration, inline image generation, and Model Compare, which runs identical prompts concurrently across multiple foundation models to evaluate and synthesize optimal code. (11:05)
- Autonomous cloud sandboxes can now be spun up directly via mobile voice prompts or by mentioning @github in Slack threads, enabling code execution, diff inspection, and pull request generation without an active local IDE. (24:34)
Detailed notes
## Background Published by GitHub on YouTube on November 7, 2026, this GitHub Universe 2026 presentation features Pierce Boggan, Burke Holland, James Montemagno, Julia Kasper, and Katie Savage. According to the description, the session explores how engineering teams can tackle a shared software project with GitHub Copilot while preserving individual preferences across the Copilot desktop app, VS Code, CLI, mobile, and collaboration platforms.
## TL;DR Using a cross-platform desktop capture tool called Tiny Clips as their live project, five engineers demonstrate how GitHub Copilot's unified underlying platform connects radically different personal workflows. Burke Holland showcases zero-clone repository management and computer-use UI testing in the standalone Copilot app, before handing off the identical workspace context to Julia Kasper in VS Code to run Copilot Fusion and parallel Model Compare trials. Katie Savage highlights terminal-native execution using autonomous CLI worktrees and hands-free voice prompting, while James Montemagno commands remote cloud agent sandboxes directly from his mobile phone. Pierce Boggan closes the session by demonstrating how mentioning Copilot inside a Slack thread spins up ephemeral cloud environments with inline diff viewers, proving that modern AI-assisted development can bridge diverse tools without forcing conformity.
## Atmosphere & style The presentation carries an energetic, playful, and genuinely collaborative vibe, punctuated by easygoing on-stage banter and lighthearted teasing among teammates about task delegation. Rather than relying on dry theoretical slides, the team keeps the pace lively with rapid, live handoffs that show code, assets, and tasks fluidly jumping across operating systems, editors, terminals, and mobile devices. It feels both technically ambitious and pragmatic, emphasizing developer joy and personal workflow freedom over rigid corporate standardization.
## Bulletin - [00:03](https://www.youtube.com/watch?v=VJBTPepfWUI&t=3s) GitHub demonstrated a unified architecture across the Copilot desktop app, VS Code, CLI, mobile, web, and Slack, allowing distributed teams to collaborate on a single codebase using identical agent harnesses, models, and MCP servers without forced tooling conformity. - [02:35](https://www.youtube.com/watch?v=VJBTPepfWUI&t=155s) The GitHub Copilot desktop app introduces zero-clone repository sessions via automated Git worktrees, alongside native computer-use capabilities that autonomously launch and functionally verify desktop binaries. - [11:05](https://www.youtube.com/watch?v=VJBTPepfWUI&t=665s) VS Code added Copilot Fusion for dynamic model orchestration, inline image generation, and Model Compare, which runs identical prompts concurrently across multiple foundation models to evaluate and synthesize optimal code. - [24:34](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1474s) Autonomous cloud sandboxes can now be spun up directly via mobile voice prompts or by mentioning @github in Slack threads, enabling code execution, diff inspection, and pull request generation without an active local IDE.
## Key takeaways - [00:03](https://www.youtube.com/watch?v=VJBTPepfWUI&t=3s) GitHub Copilot has transitioned from simple code completion to multi-agent parallel systems unified by a single shared platform harness across all environments. - [01:13](https://www.youtube.com/watch?v=VJBTPepfWUI&t=73s) To demonstrate multi-agent collaboration, the team built Tiny Clips, a cross-platform desktop screen capture application engineered across five distinct personal workflows. - [02:35](https://www.youtube.com/watch?v=VJBTPepfWUI&t=155s) The Copilot desktop app segments workflows into ad-hoc Chats, repo-scoped Sessions with automated Git worktrees, and multi-repository Projects. - [02:35](https://www.youtube.com/watch?v=VJBTPepfWUI&t=155s) Copilot's zero-clone workflow allows developers to collaborate on remote codebases instantly without manual cloning or local environment lock-in. - [06:05](https://www.youtube.com/watch?v=VJBTPepfWUI&t=365s) Agentic batching triages and resolves small fit-and-finish tasks concurrently across multiple repositories, consolidating changes into batched pull requests. - [06:05](https://www.youtube.com/watch?v=VJBTPepfWUI&t=365s) Native computer-use verification allows agents to boot compiled desktop builds, execute functional UI interactions, and upload visual proof directly back into chat. - [11:05](https://www.youtube.com/watch?v=VJBTPepfWUI&t=665s) Copilot Fusion combines GitHub Copilot Autos and Project Fusion to autonomously route tasks through the most suitable model path and critique pipeline. - [13:31](https://www.youtube.com/watch?v=VJBTPepfWUI&t=811s) The dedicated Agents Window in VS Code centralizes parallel background tasks, historical multi-repo logs, and runtime harness configurations inside the editor. - [16:04](https://www.youtube.com/watch?v=VJBTPepfWUI&t=964s) Model Compare dispatches an identical prompt across multiple foundation models concurrently, using an LLM judge to evaluate outputs and synthesize the best patterns into one implementation. - [18:36](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1116s) The Copilot CLI provides identical MCP servers and session states to desktop tools, featuring Interactive, Plan, and Autopilot execution modes. - [22:36](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1356s) CLI commands like `/ask` enable context-free querying, while `/diff` and shell handoffs maintain continuity with VS Code across identical Git worktrees. - [22:36](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1356s) The `/pr auto` command instructs Copilot to draft a pull request and iterate through failing checks until the build passes, preserving human control over the final merge. - [24:34](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1474s) GitHub Mobile allows developers to spin up cloud virtual machines, run shell commands, and generate multimedia promotional assets entirely via voice prompts. - [27:49](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1669s) Cloud-based agent sessions synchronize in real time across mobile devices, `github.com/copilot`, and desktop applications. - [29:44](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1784s) Mentioning `@github` in Slack channels provisions isolated cloud sandboxes that implement bug fixes and embed visual diff viewers directly into team chat threads. - [31:53](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1913s) GitHub's design principle emphasizes developer choice, allowing team members to mix and match IDEs, terminals, browsers, mobile devices, and chat apps without fragmentation.
## Detailed walkthrough ### [00:03](https://www.youtube.com/watch?v=VJBTPepfWUI&t=3s) A Connected Platform: The Evolution of GitHub Copilot
Pierce Boggan from the GitHub Copilot product team opens the session by reflecting on how dramatically developer workflows have evolved. What began as simple single-line code completion has rapidly transformed into multi-agent systems executing tasks in parallel. Today, Copilot is designed as a single, continuous experience where developers can initiate a session in one environment, seamlessly transition it to another, and finish it wherever they prefer—sharing the exact same platform across VS Code, the command-line interface (CLI), and the standalone GitHub Copilot desktop app.
Addressing the audience, Pierce tackles the single most common inquiry the team receives: which surface of GitHub Copilot should a developer actually choose? Pierce Boggan admits, “The answer depends on you, and I know that's probably not the answer you wanted to hear, but to help answer that, we're going to take a look at each of the GitHub Copilot integrations today and hopefully help to clarify that for you.” Rather than forcing everyone into an identical setup, GitHub is constructing an underlying shared platform that remains identical everywhere—encompassing the agent harness, model selection, integrations, custom instructions, skills, and Model Context Protocol (MCP) servers.
```mermaid flowchart TD accTitle: GitHub Copilot Shared Platform Architecture accDescr: Diagram showing how shared models, MCP servers, and agent harnesses power multiple developer interfaces.
subgraph Core["Shared GitHub Copilot Platform"] Harness["Agent Harness & Custom Instructions"] Models["Multi-Model Access (Local & Cloud)"] MCPServers["Skills & MCP Servers"] end
subgraph Interfaces["Developer Entrypoints"] App["Copilot App"] Editor["VS Code & IDEs"] Terminal["Copilot CLI"] Collab["Mobile, Web & Slack"] end
Core --> App Core --> Editor Core --> Terminal Core --> Collab ```
[01:13](https://www.youtube.com/watch?v=VJBTPepfWUI&t=73s) Introducing Tiny Clips: Building Software Across Diverse Workflows
To ground the technology in reality rather than theoretical slides, Pierce introduces Tiny Clips, an actual screenshot capture and screen recording desktop utility the team built for both macOS and Windows. Demonstrating the application live, he selects a desktop region, marks it up with annotation arrows, and drops in expressive emojis, joking that no modern screen capture utility is complete without an abundance of emojis. Beyond basic still captures, Tiny Clips handles recording and trimming lightweight video clips to share quick updates across a distributed engineering team.
Building Tiny Clips served as the proving ground for how the GitHub team collaborates. Pierce invites his teammates—Burke Holland, Julia Kasper, Katie Savage, and James Montemagno—to demonstrate how five engineers collaborate on a single codebase while preserving their radically different work habits. As Pierce explains, some members of the team are strictly code-first, others operate entirely agent-first, and some prefer working outside traditional code editors altogether.
[02:35](https://www.youtube.com/watch?v=VJBTPepfWUI&t=155s) Burke Holland and the Copilot App: Chats, Sessions, and Projects
Burke Holland takes the stage on his Surface Laptop to demonstrate the GitHub Copilot desktop application. He explains that the app splits work into distinct modes visible along the left sidebar: Chats and Sessions. Chats are intended for ad-hoc, one-off interactions unattached to a specific repository or project directory. For example, Burke explains that he no longer installs or configures software manually on his personal machine; he delegates environment setup to local models like Qwen running directly on device, which he used to configure his Windows Subsystem for Linux (WSL) setup.
Sessions, by contrast, bind the agent directly to a designated folder or GitHub repository. Burke highlights the zero-clone workflow as his standout favorite capability: “And this is actually my favorite feature of the app, is that I don't have to clone anything anymore ever again.” A developer simply selects a remote repository and starts collaborating immediately. Under the hood, Copilot manages Git worktrees to guarantee total isolation, though developers retain the choice to work directly against the main branch, locally, in the cloud, or inside remote environments like WSL.
Burke then highlights a major capability: Copilot Projects. Projects allow developers to track multi-repository initiatives, background agent runs, and experimental side work. Pointing to active workspaces, Burke reveals he is currently using an agent to hack his conference badge, while another workspace continuously generates visual diorama assets for a game he is prototyping. For Tiny Clips, the project spans three separate repositories simultaneously, allowing the agent to reason across the entire ecosystem from a single unified prompt.
- **Chats**: Standalone agent sessions for system administration, configuration, and one-off scripts, often leveraging local on-device models. - **Sessions**: Directory- and repository-scoped workspaces with automated Git worktree isolation and zero-cloning requirements. - **Projects**: Multi-repository workspaces that persist context across projects, background operations, and asset libraries.
[06:05](https://www.youtube.com/watch?v=VJBTPepfWUI&t=365s) Agentic Batching, Computer Use, and Dynamic Canvases
Querying the Tiny Clips project using Claude Opus to triage open issues across all three repositories, Burke identifies several small "fit and finish" tickets, such as changing button text from "archive now" to title-cased "Archive Now." Instead of wasting human time on cosmetic fixes, he instructs Copilot to resolve all open fit-and-finish bugs. The system inspects the issue list, determines the appropriate number of concurrent agents, and batches related edits together into single pull requests rather than flooding the repository with single-character PRs.
```mermaid flowchart LR accTitle: Copilot Projects Agentic Issue Triage and Testing Loop accDescr: Flowchart illustrating how Copilot Projects triages issues, batches pull requests, and runs computer use testing.
subgraph Triage["Triage & Execution"] A["Scan Multi-Repo Issues"] --> B["Group Fit & Finish Tasks"] B --> C["Spawn Background Agents"] C --> D["Batch Pull Requests"] end
subgraph Validation["Verification"] D --> E["Locate Debug Build"] E --> F["Computer Use Agent"] F --> G["UI Functional Test"] G --> H["Visual Proof in Chat"] end ```
Burke explains that these automated workflows operate quietly in the background, monitored through the app's overview sidebar and library tab, where generated assets and progress reports accumulate. To prevent regressions, the team relies on an automated daily dogfooding routine powered by native "computer use." While browser testing tools like Playwright are standard for web development, native Windows applications traditionally required manual functional verification. Burke Holland emphasizes, “Now, the reason why this is powerful is because agents are only as good as what they can test.” Copilot locates the fresh debug binary, boots Tiny Clips, snaps a test screenshot, activates the zoom annotation tool, and posts visual proof back into the chat.
To conclude his flow, Burke brings up a custom team Canvas—dynamic, agent-generated UI built directly inside the Copilot app to provide tailored dashboards, task trackers, or specialized tools like inline SQLite editors. Looking at their team task board, Burke jokes about carrying the team's workload before reassigning a pending icon issue to his colleague Julia Kasper, knowing full well she avoids the standalone app in favor of her preferred editor.
[10:13](https://www.youtube.com/watch?v=VJBTPepfWUI&t=613s) Julia Kasper: Seamless Context Handoff into VS Code
Julia Kasper joins the presentation, laughing about Burke's habit of assigning her extra work. As a Product Manager on the GitHub Copilot team, she describes her developer identity as being firmly rooted in Visual Studio Code. Stepping up to her setup, Julia Kasper asserts, “This is my home and I think over 50 million developers worldwide would agree.” She underscores that developers should never feel coerced into adopting an unfamiliar interface simply to benefit from modern agentic capabilities.
Because GitHub Copilot operates on a unified multi-agent harness across every supported environment, transitioning between platforms introduces zero loss of continuity. To prove this seamless parity, Julia launches VS Code and directly accesses the exact same team canvas that Burke had just updated in the standalone Copilot desktop app, ready to tackle the icon assignment without re-establishing context or switching tools.
[11:05](https://www.youtube.com/watch?v=VJBTPepfWUI&t=665s) Blobby, Copilot Fusion, and Built-In Image Generation in VS Code
Julia Kasper continues the demonstration inside Visual Studio Code, starting off with a playful addition directly in the editor: an interactive companion named Blobby. Blobby can be toggled via the `/vscode` command, customized with different colors, and dressed up with unlocked achievements based on completed development tasks—such as a small golden crown. As Julia explains, “The VS Code team loves to have fun, and we love to bring this developer joy to your local machine.”
Turning to her work assignments from Burke Holland, Julia finds a new task requiring an application icon for Tiny Clips. Rather than deliberating over the long list of available language models, she selects GitHub Copilot Fusion. Model selection can easily become paralyzing, and Copilot Fusion solves this by combining GitHub Copilot Autos and Project Fusion into an automated orchestration layer that dynamically evaluates the prompt and executes across the most appropriate model path.
```mermaid flowchart LR accTitle: Copilot Fusion Orchestration Pipeline accDescr: Diagram showing how user prompt flows through Fusion orchestration to select a model critique path. subgraph Input ["User Interaction"] A["User Task / Prompt"] end subgraph FusionEngine ["Copilot Fusion"] B["Smart Orchestration<br>(Autos + Project Fusion)"] C["Critique Path Selection"] end subgraph Execution ["Model Execution"] D["GPT-6 Luna"] E["Native Image Endpoint"] end A --> B B --> C C --> D C --> E ```
Julia demonstrates the native image generation endpoint integrated directly into the chat interface without extra configuration or third-party extensions. By asking Copilot for an icon concept, the editor produces several candidate images. Julia notes that Fusion automatically routed the task through a critique path powered by GPT-6 Luna, leaving a complete audit trail of every model that participated in the run.
- **Blobby Customization**: Managed via `/vscode` command; supports colors and earned achievement cosmetics (like a crown). - **Copilot Fusion Concept**: Merges GitHub Copilot Autos with Project Fusion to eliminate manual model picking. - **Image Generation**: Native endpoint inside VS Code chat that accepts image creation requests inline. - **Model Traceability**: Users can inspect which models ran during a Fusion session (e.g., GPT-6 Luna on the critique path).
---
[13:31](https://www.youtube.com/watch?v=VJBTPepfWUI&t=811s) The Agents Window and Unified Customizations
While traditional in-editor chat works well for local coding close to the files, Julia highlights scenarios requiring a bird's-eye architectural view across several repositories and parallel background runs. To address this, VS Code introduces a dedicated, built-in Agents Window.
“This is built in to VS Code. You don't have to leave the editor we all love.”
Opening the Agents Window displays a central agent orchestration canvas detailing every active workspace, ongoing tasks, and historical session logs across multiple projects—including past workshop evaluation sessions alongside the current Tiny Clips repository. Developers can drop into any suspended or running session at any time to inspect state or supply user input.
Julia also highlights the new Customization tab in VS Code. It aggregates every workspace enhancement—plugins, visual canvases, and MCP (Model Context Protocol) servers—into a single configuration screen, eliminating fragmented settings menus. From this surface, she restores the shared team load canvas with a single click, keeping task distribution synchronized across the team.
---
[16:04](https://www.youtube.com/watch?v=VJBTPepfWUI&t=964s) Parallel Agent Execution and Model Compare
Julia shifts to her next assignment: implementing a scatter sound feature for the studio agent. In the Agents Window, developers can choose whether a task runs locally on their laptop or offloaded into the cloud, as well as select the underlying runtime harness or engine. Julia elects to run the task using the native GitHub Copilot harness.
To illustrate how to handle complex implementations, Julia showcases Model Compare. Unlike Copilot Fusion—which autonomously routes to a single optimal model path—Model Compare allows an engineer to issue an identical prompt simultaneously across two or more foundation models to evaluate competing implementation strategies.
```mermaid flowchart TD accTitle: Model Compare and Synthesis Architecture accDescr: Workflow showing one prompt distributed to multiple models, reviewed by an LLM judge, and synthesized. subgraph Prompting ["Prompt Distribution"] P["User Text Prompt"] --> M1["Model A Attempt"] P --> M2["Model B Attempt"] P --> M3["Model C Attempt"] end subgraph Evaluation ["Evaluation & Synthesis"] M1 --> J["LLM Judge Review"] M2 --> J M3 --> J J --> S["Synthesize Task<br>(Best Parts Merged)"] end ```
The Model Compare setup includes: 1. **Multi-Model Spawning**: Running the exact same prompt concurrently across three distinct models. 2. **LLM as a Judge**: A designated model evaluates the completed runs, scoring and declaring an overall winner based on the criteria. 3. **Synthesize Task**: An automated post-processing step that harvests the strongest code patterns from each attempt and merges them into a single consolidated implementation.
With the multi-attempt sound effect task and the icon generation processing in the background, Julia hands the presentation over to Katie Savage to demonstrate terminal-first workflows.
---
[18:36](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1116s) GitHub Copilot CLI: Worktrees, Autopilot, and Hands-Free Voice Prompting
Katie Savage takes the stage to present the developer experience from inside the command line. While graphical editors suit many developers, Katie emphasizes terminal-centric workflows: “Julia loves code editors, but I love my terminal and I want to be able to access those same rich Copilot features and experiences where I'm at when I'm in my terminal.”
The GitHub Copilot CLI shares the exact same underlying harness, session states, and MCP server integrations as the Copilot desktop app and VS Code. Upon launch, Katie's terminal environment restores her active session context, system instructions, and external MCP servers. She opens her active session list in the left-hand terminal pane, reviewing the shared team load canvas to inspect her assigned issues.
```mermaid flowchart LR accTitle: Copilot CLI Mode Transitions accDescr: State machine of the three interaction modes in the GitHub Copilot CLI. Interactive["Interactive Mode<br>(Back-and-forth dialogue)"] Plan["Plan Mode<br>(Shift+Tab: Architectural planning)"] Autopilot["Autopilot Mode<br>(Shift+Tab: Autonomous execution)"]
Interactive -->|"Shift + Tab"| Plan Plan -->|"Shift + Tab"| Autopilot ```
Her task involves updating the Windows Screenshot editor to let users apply custom background images. Rather than modifying her active working branch directly, Katie taps `W` to automatically provision an isolated Git worktree linked directly to the issue. She then walks through the operational modes in the CLI: - **Interactive Mode**: Standard turn-by-turn conversational interaction with the AI. - **Plan Mode**: Entered via `Shift + Tab`; restricts Copilot to outlining architectures and implementation steps without touching files. - **Autopilot Mode**: Cycling once more into Autopilot empowers Copilot to independently generate files, execute terminal commands, and solve errors without prompting for manual confirmation.
Katie toggles `--allow-all` to grant Copilot unblocked autonomous execution rights, then runs `Ctrl + E` to show that sessions can instantly shift execution between local compute and cloud environments.
Freeing herself up while the worktree task runs, Katie jumps back to her primary session pane to file a new issue based on an earlier conversation with James Montemagno. By holding the `Spacebar`, she uses voice-to-text input to dictate the issue prompt: configuring the screenshot editor to default to the arrow tool instead of the move tool for the 2.0 release, and assigning the work directly to James. She kicks this off in Autopilot as well.
Finally, returning to her background worktree session, Katie invokes the `/ask` command to query the implementation status without polluting the session's prompt context:
“And the thing I love about slash ask is this is really just a one off question that I want to ask about this session, but I don't necessarily want this to be in the session history.”
[22:36](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1356s) Reviewing CLI Sessions and Creating Pull Requests with Copilot
Continuing in the GitHub Copilot CLI, Katie Savage looks over the progress of her current task and realizes it still has some ground to cover. She decides to switch contexts by jumping back into her recently active sessions and reopening an earlier workspace where she was already tackling the same problem. To inspect the code modifications made by Copilot, she issues the `/diff` slash command. This opens a unified view displaying every modified file. From this interface, developers can drill into individual files and leave comments directly for Copilot to prompt further code tweaks.
If deeper editing is required, Katie shows that a simple shell command launches the entire context straight into VS Code. This handoff preserves continuity by opening directly within the exact same git worktree she was operating in within the terminal, maintaining her active sessions. As Katie explains: “So it's creating this really fluid back and forth experience for me to work across these tools, depending on what I need to do.”
Ready to finalize the work, Katie initiates the pull request flow using `/pr`. The CLI presents several pathways: creating a standard PR, creating a PR and instructing Copilot to drive it to green by fixing broken tests and addressing feedback before automatically merging, or a balanced middle ground. Katie opts for the middle route—allowing Copilot to generate the pull request and resolve issues until the build passes, while holding off on the merge so human teammates can review it first. She triggers this workflow with `/pr auto` and sends it off. Feeling accomplished for the day, she opens the team's workload canvas to check on everyone else's status and spots that James Montemagno still has a full queue, prompting her to invite him up to showcase his workflow.
- `/diff`: Launches an interactive file tree and change inspector where inline feedback comments can be passed directly back to Copilot. - VS Code Shell Integration: Seamlessly opens the current active git worktree into the desktop editor without losing terminal session history. - `/pr auto`: Commands Copilot to draft the pull request and iterate on checks until tests turn green, while leaving the final merge approval to human collaborators.
---
[24:34](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1474s) James Montemagno: Copilot Cloud Sessions on GitHub Mobile
Taking the stage, James Montemagno professes his deep affection for traditional IDEs and developer tooling—emphasizing that he spends his days across Visual Studio, VS Code, Xcode, IntelliJ, and the terminal. However, because he does not always carry a laptop with him, he relies on his smartphone so his autonomous agents never have to idle. Holding up the standard GitHub mobile application, James dives into the `Tiny Clips` repository to triage issues and pull requests on the go. He opens an issue recently handed off by Katie, assigns it straight to an agent, and launches it into execution.
Behind the scenes, assigning an issue to an agent immediately spins up a live cloud session—the identical environment provisioned when working from desktop or browser interfaces. James explains that inspiration often strikes when he lacks the time to draft formal issues, so he taps the plus icon on the repository screen to select "New agent session." From there, he picks his target branch, selects Autopilot, chooses his preferred underlying model, and dictates his prompt via speech-to-text: “Okay, we need to update the screenshot settings on Windows. It's a hot mess right now. It is all over the place. We want to reorganize the settings, recategorize them together. Let's do that.”
```mermaid flowchart TD accTitle: GitHub Copilot Mobile and Cloud Session Lifecycle accDescr: Diagram illustrating how voice and issue triggers on GitHub mobile spawn remote cloud environments accessible across mobile, web, and desktop.
subgraph MobileInput["GitHub Mobile App"] A["Assign Issue or Tap '+'"] --> B["Dictate Prompt / Set Branch & Model"] end
subgraph CloudEnv["Isolated Cloud Session"] B --> C["Provision VM & Clone Repo"] C --> D["Headless Terminal & Autonomous Execution"] D --> E["Generate Code, Take Screenshots, Render Media"] end
subgraph CrossPlatform["Multi-Surface Access"] E --> F["Mobile: Review & Playback"] E --> G["Web: github.com/copilot"] E --> H["Desktop: GitHub Copilot App & VS Code"] end ```
Once submitted, a remote virtual environment is provisioned and clones the codebase. To prove that a complete development machine is running rather than a superficial mobile wrapper, James opens the session's action menu, taps on "Terminal," and executes `ls`, displaying the fully hydrated repository filesystem residing in the cloud. Navigating over to the Copilot tab, he browses all active and historical sessions, including an agent task from the day before where he asked Copilot to produce a promotional video for an upcoming release. The agent autonomously formulated questions, captured desktop screenshots inside its cloud environment, and compiled a complete promo video. James pulls up the video file, plays back the rendered footage directly via AirPlay on the stage screen, and shows that developers can inspect diffs and merge pull requests right from their phones. Reflecting on his travels, James jokes about building, testing, and shipping code while cruising at altitude on Alaska Airlines' complimentary in-flight Wi-Fi.
- Cloud-native terminal: Running standard shell commands like `ls` from the mobile interface confirms direct access to a dedicated cloud VM. - Multimodal generation: Copilot cloud sessions can run graphical tasks, capture screenshots, and assemble finished promotional video assets autonomously. - Real-time continuity: Sessions initialized via voice on mobile immediately surface under the user's account history on web and desktop clients.
---
[27:49](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1669s) Moving Between github.com, Desktop App, and Local IDEs
James transitions to his desktop machine to demonstrate that cloud-based agent development is entirely agnostic of the device you are currently holding. Switching his display over, he navigates to `github.com/copilot`, where every active thread—including the Windows screenshot settings task he just dictated on his phone—appears live and synchronized. He inspects the work in flight, noting that the cloud agent has already begun writing changes and preparing a pull request. Users working inside a specific project can also open the repository's "Agents" tab to monitor every agent currently executing against that codebase, choose underlying models, or spin up new instances.
He then shifts directly into the dedicated GitHub Copilot desktop app. The exact same cloud session that originated on his smartphone and appeared in his browser manifests right inside the desktop client, marked with a cloud badge. Opening the promo video session, he finds the same generated media asset ready for local review. Summing up the architecture, James exclaims: “This is the power of having super powerful machines with you everywhere and everywhere at all times. It's how I work and build software every single day, either on my computer or on my phone, and seamlessly transition between all of my surfaces.” With the mobile-to-cloud cycle complete, James hands the session back to Pierce Boggan.
---
[29:44](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1784s) Pierce Boggan: Running Copilot Cloud Sandboxes Directly Inside Slack
Taking the stage to wrap up the demonstration, Pierce Boggan reflects on how developer productivity extends beyond text editors and command-line terminals. While developers frequent tools like VS Code and the Copilot desktop client, significant parts of the workday are spent inside collaboration platforms like Slack and Microsoft Teams. Pierce pulls up the `Tiny Clips` Slack workspace, which is already integrated with GitHub to stream repository events, pull requests, and incoming bug reports.
He points out a common workplace scenario: colleagues raising complaints and posting feedback directly into communication channels. Scrolling through the messages, Pierce highlights a post from James venting about Windows analytics performance. Traditionally, handling this required manual copy-pasting of text, stack traces, and user context out of chat and into an editor. Instead, Pierce types `@github can you take this one?` directly beneath the complaint. This command immediately spins up an isolated cloud sandbox identical to the mobile and web runtime environments, converting the chat thread into an active collaborative coding channel.
```mermaid flowchart LR accTitle: Slack Collaborative Agent Workflow accDescr: Flow diagram showing how user feedback in a Slack channel spins up a cloud sandbox and posts visual diffs back into chat.
A["Teammate Feedback in Chat"] --> B["Mention @github in Thread"] B --> C["Spin up Cloud Sandbox"] C --> D["Agent Implements Fix"] D --> E["In-Chat Visual Diff Viewer & Screenshots"] E --> F["Team Reviews & Merges"] ```
To demonstrate the completed workflow, Pierce navigates to an earlier thread where he and James collaborated on introducing a light theme for the Tiny Clips website. Initiated with a simple `@github` call, Copilot worked through the task, captured before-and-after screenshots of the UI in both themes, and posted interactive visual artifacts directly into the Slack conversation. Highlighting the built-in diff inspector, Pierce remarks: “And of course, I can not only see the before and after screenshots here, but we got, we got a diff viewer in Slack in the year 2026. That's crazy.” This allows the entire team to discuss, critique, and approve code implementations directly where the conversation started without context fragmentation.
- In-thread agent invocation: Tagging `@github` inside Slack spawns an ephemeral remote sandbox that executes tasks based on chat context. - Embedded rich diff viewer: Code modifications and visual assets—such as side-by-side theme screenshots—are rendered directly within the chat feed. - Elimination of context switching: Code changes can be requested, reviewed, and iterated upon collaboratively without opening a traditional local workspace.
---
[31:53](https://www.youtube.com/watch?v=VJBTPepfWUI&t=1913s) Conclusion: Work Together, Your Way
Returning to his concluding slides, Pierce thanks Burke Holland, Katie Savage, James Montemagno, and Julia Kasper for demonstrating how an entire engineering team can collaborate on a single unified product while adopting vastly different surfaces and workflows. Whether developers prefer full-fledged desktop IDEs like VS Code, Visual Studio, IntelliJ, and Xcode, terminal environments powered by the CLI, browser and mobile sessions on `github.com` and the GitHub mobile app, the standalone GitHub desktop and Copilot apps, or chat integrations inside Slack, GitHub Copilot adapts to the individual's preferred environment.
Pierce calls the entire Tiny Clips team back onto the stage to a round of applause from the audience, summarizing the session's philosophy: developers should never be forced into a rigid, homogenous setup. Instead, Copilot bridges disparate tools, allowing teams to coordinate effortlessly across surfaces and build software together, their own way.
## Notable quotes > [06:05](https://www.youtube.com/watch?v=VJBTPepfWUI&t=365s) agents are only as good as what they can test. — Burke Holland
## Mentioned Pierce Boggan, Burke Holland, Julia Kasper, Katie Savage, James Montemagno, GitHub, Microsoft, GitHub Copilot, GitHub Copilot App, GitHub Copilot CLI, GitHub Copilot Fusion, Visual Studio Code, Visual Studio, JetBrains, IntelliJ, Xcode, Tiny Clips, Blobby, Model Context Protocol (MCP), Qwen, Claude Opus, GPT-6 Luna, Playwright, SQLite, Slack, Microsoft Teams, Windows Subsystem for Linux (WSL), Surface Laptop, Git worktrees
## Video description Your team might agree on what to build, but how to build it is another conversation. In this GitHub Universe 2026 session, join Pierce Boggan, Burke Holland, James Montemagno, Julia Kasper, and Katie Savage as they tackle a shared project with GitHub Copilot, bringing their favorite tools, models, and personal workflows. Working across the Copilot app, CLI, VS Code, and JetBrains, the team puts AI agents to work, carries context between tasks, and takes development beyond the editor while balancing speed, cost, and control. Follow the project from concept to working software to see how Copilot helps teams build together without forcing everyone into the same setup.
Speakers:
Burke Holland, Principal Cloud Advocate, Microsoft James Montemagno, Principal Technical PM Lead, Microsoft Julia Kasper, Product Manager, Microsoft Katie Savage, Technical Program Manager, Microsoft Pierce Boggan, Product - GitHub Copilot, GitHub
Watch more videos from GitHub Universe 2026: https://www.youtube.com/watch?v=AArI948SDz8&list=PLENrlACZ7mnU
— CHAPTERS —
00:00 Welcome Pierce Boggan: GitHub Copilot overview 01:13 Building tiny clips with GitHub Copilot 02:35 Burke Holland: GitHub Copilot app 10:13 Julia Kasper: Copilot in VS Code 18:36 Katie Savage: GitHub Copilot CLI 24:34 James Montemagno: Copilot mobile & web 29:44 Pierce Boggan: Copilot in Slack 31:53 Conclusion: work together, your way
#GitHubUniverse #GitHubCopilot #VSCode
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=VJBTPepfWUI)