GitHub Copilot Canvases: Agent Work You Can Supervise

GitHub has launched Canvases: a side-by-side workspace inside the Copilot app where a developer and an agent operate on the same surface instead of trading messages. It presents as a UI update. It is really a fix for the part of agentic development that has been quietly broken since the first coding agent shipped.

The problem with chat-only AI development

Chat is excellent for expressing intent:

• "Generate a migration plan."
• "Refactor this component."
• "Investigate failing tests."

Once the agent starts working, the format stops helping:

• important decisions disappear into a long conversation thread
• state becomes difficult to track
• human oversight becomes cumbersome
• multi-step workflows lose transparency
• collaboration between human and agent becomes inefficient

GitHub describes this as work getting "lost in the scroll." The prompts, logs, decisions, validation steps and outcomes are all technically present — just scattered across a growing chat history.

Anyone who has built AI agents has met this problem from the other side. Agent reasoning can be impressive, but if users cannot see what is happening, trust and governance are hard to establish.

What exactly is a Canvas?

A Canvas is a persistent, interactive workspace generated and operated by GitHub Copilot. Instead of communicating exclusively through messages, you create a visual environment tailored to one specific workflow.

GitHub describes canvases as a shared surface where:

• humans interact through UI controls
• agents update the workspace directly
• both parties collaborate on the same artefact
• state persists across sessions and interactions

A canvas is not fixed once created. It evolves alongside the workflow, and you can ask Copilot to add capabilities or behaviour to it as the work changes shape.

Traditional Copilot → Copilot Canvas

• Conversation → workspace
• Prompt and response → human and agent collaboration
• Temporary context → persistent state
• Text interface → rich interactive UI
• Reactive assistance → structured workflow

Starting one

Creating a canvas takes a single command:

/create-canvas "Initialize a repository triage interface that
renders pending GitHub issues as swipeable cards..."

Copilot builds the interface next to your code rather than describing it back to you. Usage runs on a credit system, which at least makes the cost of an agentic workflow a number you can budget against instead of an open tap.

What teams are building with templates

Canvas layouts are shared as extensions, collected in a public gallery at awesome-copilot.github.com/extensions. The published set maps closely to the workflows that suffer most in chat:

• Java Modernization Studio — runs a modernisation workflow through assessment dashboards and validation gates
• Site Studio — plan and author the sections of a site on a shared surface
• Backlog Swipe Triage — work down a backlog by swiping triage decisions
• Diagram Explorer — interactive diagrams whose nodes the agent explains as you open them
• Repository Issues Kanban — a board for tracking remediation work across issues
• Where Was I? — reconstructs context from branch history so work can resume
• Workshop Signals — a live dashboard of agent signals and multi-agent coordination metrics

The gallery runs wider than that. One canvas renders credit usage as a game of Pac-Man; another serves retro arcade games to play while the agents work. Underneath the serious ones the pattern is identical: take a multi-step agent workflow and give it a surface with state.

Why this matters for AI engineers

The significance of Canvases is not the UI. It is that canvases make agent workflows visible, steerable and inspectable. That maps onto four problems AI engineering teams are already working on.

Human-in-the-loop governance

Enterprise AI systems rarely operate fully autonomously. There are checkpoints requiring approval, validation, prioritisation and review. A canvas gives those interactions an explicit place to live. Rather than asking "what has the agent done so far?", you inspect the current state.

Durable state

Most chat systems suffer from state fragmentation. A canvas behaves as a durable artefact: the agent updates status, adds results, marks tasks complete and stores findings, without the user reconstructing context from previous conversations.

Better multi-agent coordination

Many teams are moving towards agentic workflows with separate planning, coding, review and testing agents. A shared visual workspace becomes the coordination layer between them. Instead of passing information through messages, every participant works against the same stateful surface.

Lower cognitive load

People are remarkably good at interpreting visual systems. Kanban boards, architecture diagrams, dashboards and checklists land in seconds; 500 lines of chat history do not. Canvases lean on that asymmetry rather than fighting it.

The real shift

The interesting claim in Canvases is not that AI-assisted development gets faster. It is that it becomes auditable. Chat made agents easy to instruct; canvases make them possible to supervise. For anyone putting agentic workflows in front of an enterprise review board, that is the harder half of the problem.