AI Engineer World's Fair 2026

Realtime multiplayer, automation, and you!

Idan Gazit21:41

Loading slides…

Read the talk

Realtime multiplayer, automation, and you

When code becomes cheap, choosing the right work and staying aligned become harder. GitHub Next’s Agentic Workflows and Ace explore automation and collaboration as parts of the same development loop.

From a talk by Idan Gazit

Before you start: Familiarity with Git repositories, pull requests, CI workflows, and dependency upgrades will help you follow the demonstrations.

What should we build when code becomes cheap?

If AI can help us think and make software, and the marginal cost of another line of code keeps falling, what is worth building? That question shapes the work of Idan Gazit’s team at GitHub Next, the labs group that created Copilot and explored specification-based programming and natural-language-to-app development. Its prototypes scout the tools developers might use a year or two ahead; not every experiment becomes a product. Gazit jokingly calls it the Department of Fool Around and Find Out, but the method is practical: build things to discover what is useful.

Even a developer with effectively unlimited tokens and ten terminals running agents still faces opportunity cost. More capacity does not decide where to spend that capacity. With the technology changing every week, this is no longer a problem reserved for a research team. GitHub Next looks for durable themes: needs that will survive the next model release.

A two-tone slide reads “Research?” above “Prototyping.” with the presenter inset at lower left.Open full source frame
Research? Prototyping.
0:220:36
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:22 · section reference included

Automation buys time; collaboration protects it

AI development tools began with personal productivity: complete what I type, fetch what I need, run several agents so I can pursue several tasks. But multiplying one person’s output is only part of the opportunity. The larger goal is to let groups accomplish more together.

The first route is automation. Gazit uses the industrial revolution as an analogy: software has automated many mechanical checks, such as requiring a semicolon, while leaving work that needs judgment to people. Agents make some of that judgment-dependent work automatable. The benefit is time that a team can put into craft, product quality, or features. Hiring more people expands capacity; removing recurring manual work can also free capacity already inside the team.

The second route is shared understanding. Geoffrey Litt’s observation that understanding becomes the bottleneck applies to individuals, but shipping within a team requires agreement among people. That agreement cannot wait until the end. When implementation accelerates, a small misunderstanding can produce a large amount of unwanted work before anyone notices—and that waste now includes paid tokens as well as human time. GitHub Next explores these two needs through Agentic Workflows, for background automation, and Ace, for realtime multiplayer development.

Slide pairs “Agentic Workflows” with “Secure-by-default automation” and “Ace” with “Realtime multiplayer agentic development.”Open full source frame
Agentic Workflows and Ace: automation and multiplayer development.
2:202:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:20 · section reference included

From an upgrade request to a Markdown playbook

Gazit starts the automation demonstration with his personal website, built with Astro. Frequent framework releases create an upgrade treadmill. Dependabot tells him when dependencies are outdated, but completing an upgrade can require application changes, not just a new version in a manifest. He wants an automation that continually checks dependencies and prepares those code changes too.

To create it, he gives Copilot a skill-like document explaining how to author an Agentic Workflow. The actual request then resembles a message to a junior developer: check daily for new releases, read the changelog and documentation, plan the upgrade, and open a pull request. The documentation links supply the places to investigate.

The result is a Markdown playbook. Copilot reads the repository to identify the relevant dependencies, then expands the short request into a sequence of tasks. The body can express the work directly:

markdown

# Website dependency upgrade

1. Inspect the repository dependencies and check for new releases.
2. Read the changelogs and upgrade guides between the installed
   versions and the proposed target versions.
3. Plan and apply the dependency upgrades and required code changes.
4. Create a pull request describing the upgrade.

This is the useful combination of GitHub Actions and Copilot: a recurring workflow supplies the execution setting, while a natural-language procedure describes work that requires reading, interpretation, and judgment.

4:504:59
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:50 · section reference included

The prompt describes the job, not its security boundary

At the top of the Markdown document, YAML front matter specifies the agent’s guardrails. An unattended agent needs explicit limits on what it can read, which tools it can use, where it can make network requests, and what it can write. Putting those limits only in the prompt is insufficient: a prompt injection can try to redirect the agent despite an instruction forbidding an action. The execution environment must enforce the boundary.

The demonstrated configuration separates several controls:

ControlDemonstrated boundary
Repository permissionsread-all
ToolsExplicitly specified tools
NetworkSpecified defaults, npm, GitHub, and Astro documentation
safe-outputscreate-pull-request, limited to one PR
No work neededAllowed to do nothing

These settings describe the demonstration, not a complete current configuration recipe. The distinction that matters is between the agent requesting an action and the system permitting that action. A single-PR limit also bounds disruption: Gazit’s example of an injected agent creating 500 pull requests would be a denial of service against the maintainers. Allowing no action is equally deliberate. A fleet of automations should not manufacture work or notifications just to announce that it ran.

6:597:08
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:59 · section reference included

Inspecting the upgrade, not just the version bump

The first result comes from Gazit’s actual website automation. Its pull request synthesizes the release notes between the installed and target versions into a description tailored to his project. For the minor-release example, it reports no breaking changes and checks the project by running and building it. A Cloudflare preview deployment then lets Gazit inspect the upgraded website. It appears unchanged, which is the desired result for this maintenance task; any hosting system with preview deployments could provide the same inspection point.

The next example is more demanding. Gazit describes upgrading the site from Astro 5 to Astro 7, crossing two major versions. The generated explanation covers changes from both intervening releases. He reports that the workflow repairs affected code, verifies the build, and highlights manual steps still required. He opens the preview again and finds the website still working. The pull request therefore delivers more than a dependency bump: it combines changes, an explanation, build evidence, and a remaining-work handoff. A successful preview does not erase that handoff.

8:489:04
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:48 · section reference included

Markdown is the source; Actions YAML is the artifact

Changing the automation means editing the English in its Markdown source and recompiling it into an Actions workflow. The generated YAML is an artifact, rather than the primary surface for iteration. A library of workflows supplies starting points that teams can customize instead of authoring every procedure from scratch.

The examples extend well beyond dependency maintenance:

  • Issue triage and code investigation: GitHub has experimented internally with an issue triager and workflows that hunt for N+1 queries in its monolith.
  • Repo Assist: A group of cooperating workflows finds approachable fixes, nudges tickets, and identifies places where maintainers need feedback from issue reporters.
  • CI Doctor: Broken CI becomes a task to investigate, rather than merely a reason to rerun the same job.
  • Team and repository status: Recurring summaries make project activity easier to follow.
  • Research and ticket synthesis: Gathering information from the internet and summarizing related tickets can serve product managers as well as engineers.

Making these procedures accessible to more roles broadens who can create automation—and which recurring work a team can remove.

10:2310:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:23 · section reference included

Keep secrets outside the agent’s environment

Background execution makes security architecture central to the product. Gazit gives four principles:

  1. Use defense in depth. No single protective layer is enough.
  2. Never expose secrets to the agent. Treat a secret the agent can read as compromised, because injected instructions may induce disclosure.
  3. Stage and vet writes. Changes must pass through an inspectable path.
  4. Log everything. Preserve the evidence needed to audit what happened.

In his jail-and-warden analogy, credentials remain outside the agent’s jail. When the agent needs a credentialed service call, it asks the warden to make the call. The service can be used without placing its secret into the agent’s readable context.

Gazit reports a concrete adoption example from Home Assistant: a workflow examines submitted issues and follows Python stack traces to distinguish bugs in the project’s own code from bugs in third-party code, closing issues outside its responsibility. The accompanying slide describes investigating backtraces, finding root causes, and suggesting ways to address them. This is the sort of contextual triage he sees as newly practical with AI, beyond the heuristic checks teams previously automated.

Home Assistant slide quotes a workflow that examines issues with Python backtraces originating in its codebase, finds root causes, and suggests ways to address them.Open full source frame
Home Assistant describes a workflow for investigating Python backtraces.

At the time of the talk, Agentic Workflows is in public preview. Gazit expects background automation to become a larger category than interactive AI: work that continues while people are away can remove recurring obligations without requiring another conversation each time.

11:4612:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:46 · section reference included

Bring collaboration inside the build loop

The familiar development sequence is to plan together, build alone, and review together. When AI can take substantial implementation steps quickly, that separation becomes less useful. People can instead adjust direction together, let the AI take a step, inspect what happened, and adjust again. Planning and review become recurring parts of building rather than phases on either side of it.

A chat interface helps expose information that is absent from the repository. Slack was designed as an improvement on office email, not specifically as a place to make software, but conversation carries essential constraints: a vice president favors one direction, a stakeholder wants purple, or an Azure infrastructure deal makes another cloud economically unattractive. An agent cannot recover those reasons simply by reading code.

The comparison is collaborative document editing. Instead of emailing Word files back and forth, people now create and collaborate in the same surface. Ace explores what that arrangement could mean for code: teammates, agents, and the work itself share a place.

13:1713:27
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:17 · section reference included

A shared session with chat, compute, and preview

Ace initially looks like a Slack-style interface, with repository sessions listed on the left. Each session represents a repository branch checked out into a cloud microVM. Gazit explains that none of the demonstrated session compute runs on his machine. The shared environment holds both the code under development and the conversation about it.

While chatting with Russ about favorite colors, Gazit installs dependencies and starts the development server with:

bash

bun dev

He then opens a browser preview. Chat and terminal interaction coexist, but they remain different input modes: he accidentally submits a remark about green being calmer as a terminal command, then moves it back into the conversation.

The application is a calmer take on Hacker News. Having discussed its color with a teammate, Gazit does not want to restate that discussion as a separate specification for the agent. Instead, he invokes Ace with “Yo, Ace, do it.” Ace can read the team conversation’s backscroll and use it as context. The live response is delayed, which Gazit attributes to Wi-Fi; he moves on without showing the completed color change.

The intended capability goes beyond extracting the most recent sentence. Engineering conversations contain proposals, edge cases, reversals, and returns to earlier ideas. Gazit expects the agent to infer the final agreed direction from that history, sparing a person the extra job of turning a conversation the agent already saw into a new handoff prompt.

14:5215:05
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:52 · section reference included

Edit the plan together, then ask for implementation

For a more involved change—adding selectable timeframes—Gazit asks the agent to generate a Markdown plan. That document is not a private answer for one developer. It is a shared editing surface: Russ can add an all-time option while Gazit removes today. Gazit then asks the agent to act on the updated plan. The demonstrated handoff is the jointly revised document; the passage does not show the completed feature.

This suggests a broader development interface. Markdown documents in a docs folder can capture intended application behavior, and changing the application can begin by changing those documents. Gazit’s formulation is “make the document true”: ask AI to bring the implementation into agreement with the edited specification. If that becomes a common way to work, shared document editing is a central development capability, not merely a convenience attached to chat.

17:0617:21
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

17:06 · section reference included

Stay aware without joining every session

Realtime editing does not by itself keep a team aligned. People also need ambient awareness of work happening elsewhere. Recalling GitHub’s former social coding tagline, Gazit shows a dashboard of actual Ace team activity, including Krzysztof’s work on VM tooling. The displayed Maggie identity has a prototype-specific explanation: Maggie built the dashboard and hard-coded her name. The purpose is to make teammates’ ongoing work visible without requiring everyone to participate in every session.

Background automations could eventually appear in that same surface. A person might talk to an automation, or an agent might ask a person a question when it needs a decision. That leads to an inversion of the usual interaction: better goal descriptions let agents proceed with less continuous supervision, while models that detect underspecified behavior can request clarification or human action. An interface that lets agents follow ongoing activity can also let them initiate contact when necessary. Gazit briefly compares this destination with OpenClaw approaching from another direction, without developing an architectural comparison.

18:2818:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

18:28 · section reference included

Help with the work around the code

Gazit closes by citing an unnamed longitudinal study of roughly 100 developers over thousands of hours, describing hands-on-keyboard typing as 5% of their time. His slide labels that category Editing and shows Comprehension at 58%, Navigation at 24%, Other at 13%, and Editing at 5%. The study is not identified in the talk, so these figures serve here as his framing of developer work rather than a universal division of the working day.

Horizontal bar chart lists Comprehension at 58%, Navigation at 24%, Other at 13%, and Editing at 5%, with editing highlighted in teal.Open full source frame
Comprehension 58%, navigation 24%, other 13%, editing 5%.

The remaining work includes finding the system to change, understanding how it behaves now, and learning what other people think should happen next. If an agent can discover facts inside a repository, the development environment still needs to help people and agents handle all the context and coordination around those facts. That is the connection between the two prototypes: automation frees attention from recurring tasks, while a shared workspace helps direct that attention and the resulting implementation.

At the close, Gazit invites discussion and feedback through GitHub Next and the Microsoft booth. Agentic Workflows is already available to try; he hopes Ace will enter technical preview later that month. The invitation is to explore tools that help teams decide, understand, and coordinate—not only type faster.

20:0820:17
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

20:08 · section reference included

Resources

From the talk

Updates since the talk

Transcript download
Full transcript

Loading transcript…