Video summary

GitHub Copilot Day live: new releases, real workflows, and live coding

Main summary

Key takeaways

Technology

Big theme: “agent-native engineering system”

GitHub Copilot is positioned as an end-to-end loop:

  • Idea → implementation → security/quality checks → PRs → deployment

Agents also change day-to-day workflow:

  • Prompts become parallel work
  • Work shifts from writing every line to shaping what gets built
  • More emphasis on quality, security, trust, and cost

1) Hydrofusion: model orchestration for better quality at lower cost (CLI + research preview)

What it is

Hydrofusion is a research preview orchestration system that selects the workflow (a composition of models) rather than picking a single “best model.”

It behaves like an advanced router, choosing workflow patterns such as:

  • Single: run a single model
  • Cascade: start cheap, then escalate/retry with a stronger model if needed
  • Critic: a strong model drafts, a cheap reviewer critiques and iterates
    • The critic typically does not directly edit (review-first) to reduce “takeover” risk

Why model routing is needed

Selection depends on model + task, and “best model” alone has a quality/cost ceiling.

Model composition (e.g., cheap + strong models in a workflow) can expand coverage while keeping cost controlled.

Evaluation / reported results

Hydrofusion is evaluated with:

  • TerminalBench 2.1
  • DeepSUI
  • An internal CheckpointBench

Reported claims include:

  • ~67% lower estimated cost with quality improvements on TerminalBench 2.1 vs Opus 5
  • Similar quality on DeepSUI and CheckpointBench with substantial cost reductions (figures cited in the transcript)

Where it’s available

Hydrofusion is available in the GitHub Copilot CLI under an experimental mode (referenced via slash models / Hydrofusion).

2) GitHub Copilot app: agent-native “hub” for GitHub + tool permissions + agent modes

Core capabilities shown

The Copilot app supports agent sessions across:

  • local folders
  • remote Git repositories
  • GitHub projects

It demonstrates:

  • agent modes
  • tool permission controls

Modes shown include:

  • Interactive / plan / autopilot (as described in the segment)
  • A new experimental Assisted mode:
    • auto-approves tool requests that pass an LLM safety check

New feature: auto optimizations (launched in the show)

Auto mode adds tuning knobs to optimize for:

  • efficiency
  • balanced
  • intelligence

Goal: reduce the need for “model shopping” by selecting models per request.

Model ecosystem support

Models can come from:

  • multiple vendors
  • external routing providers (example mentioned: OpenRouter)
  • local/hosted options (examples mentioned: running locally or via frameworks)

3) Agent “skills,” MCP servers, canvases, and automations (extensibility)

Skills (behavioral prompting patterns)

A major segment focuses on Matt PCO’s skills, especially “Grill with Docs”:

  • The agent asks structured questions before writing implementation
  • Produces a PR with improved specs and understanding

Other skills mentioned:

  • Code Review: checks against repo standards/specs using sub-agents and origin/main diffing
  • Improve Codebase Architecture: architecture review with suggestions
  • Implement Spec: parallel, ticket-based implementation using a spec as the destination
  • Retro: retrospective over recent sessions using artifacts + checkpoints

MCP servers / tools / runtime integration

The Copilot app can install and use:

  • MCP servers
  • plugins
  • skills
  • canvases

Tools/skills can be plugged in so the app understands internal systems (examples mentioned include):

  • Azure DevOps
  • Figma
  • Playwright/device testing
  • Work IQ
  • and others referenced in the transcript

Canvases (visual interaction surfaces)

A canvas is described as a visual/interactive surface to drive agent sessions.

Examples shown:

  • Web canvas: embedded browser to manipulate and validate UI/app behavior
  • iOS simulator canvas: agent testing with screenshot validation and App Store screenshot generation
  • Mobile/VS Code canvas usage via tools/MCP

Automations (repeatable agent workflows)

Demonstrated scheduled/triggered automations such as:

  • daily issue triage with enrichment
  • weekly accessibility audits
  • cost tips using Chronicle
  • PR-generating workflows (e.g., remove dead code) with validation split:
    • find dead code vs verify usefulness

4) Review/run/preview tight loop inside the Copilot app

A key workflow emphasizes:

  • diff + tests + live preview side-by-side inside the app

The demo shows:

  • agent edits via diff (green/red)
  • the user remains the decision-maker:
    • accept changes
    • leave comments
    • ask Copilot to adjust
  • CI/CD validation before merging
  • a “one-click PR” flow

Agent merge automation

An agent merge feature can:

  • resolve review issues, CI failures, conflicts, etc.
  • merge automatically when checks are addressed
    • (framed as optional/autonomous depending on user choice)

5) Collaboration & “where you already work”: Slack and Teams integrations

Slack integration

Copilot integrates into Slack (and mentions availability in Teams).

A demonstrated flow:

  • connect a repo to a Slack code channel
  • stream agent activity and artifacts
  • use Slack conversation context to:
    • investigate
    • propose a fix

Purpose: reduce copy/paste and keep context in the collaboration tool.

Teams

Teams support is mentioned as available/coming in the demo context.

6) VS Code agent harness + “bring your own” (BYO) keys

VS Code “agents” support multiple harnesses, including:

  • Copilot harness (via OpenRouter in demo)
  • Claude harness (via Anthropic API key)
  • Codeex harness (via ChatGPT subscription sign-in)

The agents UI allows users to pick harnesses/models while keeping a unified experience.

7) Agent Host Protocol + remote execution continuity

Agent host protocol concept

An agent host protocol is introduced:

  • a standard way for clients to connect to runtimes hosted anywhere
  • local or remote runtimes

Demo behavior

The demonstration involves:

  • running a Copilot-like runtime on a remote machine (via a relay/host tool)
  • connecting from the CLI to manage remote sessions
  • attaching to active sessions so multiple clients can observe live updates

The transcript also mentions direction toward “Mission Control” on GitHub for remote environments.

8) Live coding: multi-session, worktree isolation, and model/cost strategies

Live demos included:

  • running multiple agents simultaneously using separate worktrees to avoid collisions
  • generating PRs and running CI checks
  • using Hydrofusion/Auto modes to manage cost while maintaining quality

9) “Vibe coding” demo: HTML & Canvas + 3D device simulation (iPhone Duo simulator)

Wes Boss showcased an experimental setup:

  • building and animating a 3D “folding device” using Three.js / 3D rendering
  • rendering through HTML/Canvas APIs
  • creating interactive app-like experiences inside the simulation (examples mentioned: calculator, notes, and attempts involving photo/camera)

The point is not only visuals:

  • agents drive UI creation
  • iterate based on rendering feedback
  • produce working interactive components in an emulator-like environment

Main speakers / sources (as named in the subtitles)

  • Kyle Dagel (COO of GitHub; also CMO Developer at Microsoft)
  • James Montag
  • Pierce Boen
  • Burke (co-host reference; name partially unclear in subtitles)
  • Matt PCO (skills presenter)
  • Julia (PM on GitHub Copilot team; leads Hydrofusion deep dive segment)
  • Ashna (Applied Scientist, Microsoft Research; Hydrofusion lead researcher per transcript)
  • Patrick Nicolet (PM; Copilot SDK / runtime + agent host protocol)
  • Megan (PM; Slack/Teams multi-surface demo)
  • Wes Boss (live “vibe coding” demo; iPhone Duo/3D simulation)

Original video