GitHub Copilot Canvases: When to Replace Chat with a Task UI
GitHub published new canvas guidance on September 24, 2026 for the GitHub Copilot app. A canvas extension is a shared interactive work surface—such as a plan, triage board, release checklist, dashboard, incident view or spreadsheet—where a person and the Copilot agent can work against the same visible state. GitHub's documentation says canvases are bidirectional: people can change the surface directly while the agent can call canvas capabilities and update that same state. This is most useful when chat is good for defining intent but poor for repeated structured actions, inspection or handoffs. The production rule is not 'replace chat everywhere.' Use chat for ambiguity and instruction, then use a canvas when the workflow benefits from explicit controls, persistent artifacts, verification and repeatable actions. Treat every agent-callable capability as an application action that still needs least privilege, input validation, authorization, bounded side effects and human approval where the action is consequential.
A developer repeatedly asks an agent to perform the same deterministic UI or repository action in chat
Important plan, triage, release or incident state is buried in a long conversation instead of a visible artifact
A human must keep re-explaining workflow state because chat messages are acting as the system of record
An agent workflow needs buttons, filters, cards, checklists or other controls so a reviewer can steer work without writing a new prompt
A team wants a shared human-agent surface but is unsure whether it should live with the repository or only on one developer's machine
Possible causes
Chat is intentionally general-purpose, so it can become inefficient for structured, repetitive or stateful work
A workflow may need an artifact that people can inspect and edit directly rather than accepting a text-only agent summary
Agent-callable actions need explicit capabilities and state instead of relying on free-form prompts to describe every operation
Project-scoped and user-scoped extensions serve different collaboration needs and should not be mixed accidentally
Local or third-party actions exposed through a canvas can become security-sensitive if capability boundaries are broader than the user's actual task
HOW TO FIX IT
Work from the safest step to the harder repair.
Step 1. Start with the workflow, not the novelty. Keep chat for intent, ambiguity and one-off reasoning; choose a canvas only when visible state, repeated actions, direct manipulation or review checkpoints materially improve the job.
Step 2. Define the artifact the user actually needs to inspect: for example a release checklist, incident board, issue triage view, planning document or agent-session dashboard. Avoid a canvas that merely mirrors chat in a different panel.
Step 3. List every human action and every agent-callable capability separately. GitHub's documentation uses examples such as get_board, add_card and move_card; the important design rule is to expose the smallest capability set that completes the workflow.
Step 4. Choose scope deliberately. GitHub documents project-scoped canvas extensions under .github/extensions for team-shared use and user-scoped extensions under ~/.copilot/extensions for personal use. Do not commit a personal experiment into a shared repository until its permissions and dependencies have been reviewed.
Step 5. Treat capabilities like backend endpoints. Validate parameters, enforce repository/account/tenant authorization on the action itself, reject unexpected targets, and never assume a hidden or disabled UI control is an access-control boundary.
Step 6. Separate read actions from write or destructive actions. Viewing status, searching or summarizing should not implicitly grant the ability to install packages, modify files, close issues, deploy code or delete data.
Step 7. Require confirmation or a human gate for consequential operations such as deployments, package installation/removal, credential changes, destructive database work, billing changes or publishing. A canvas can make these actions clearer, but it does not make them inherently safe.
Step 8. Keep secrets outside visible canvas state and logs. If an action needs credentials, resolve them in the normal secure runtime and expose only the minimum result required by the workflow.
Step 9. Make state recoverable. Persist only the workflow data that must survive handoffs, record who or what changed consequential fields, and ensure a reviewer can tell the difference between an agent proposal and an executed action.
Step 10. Measure whether the canvas actually reduces friction. Compare repeated prompt count, review time, action error rate, agent token use and handoff clarity against the prior chat-only workflow. Keep the canvas when it improves the workflow, not merely because it is more visual.
Need the actual code? Go to GenesisCodeDoctor.com to search the Code Store or request code for the exact platform, error, and repair you are working on.
Keep canvas capabilities narrow, typed where possible, and independently authorized at execution time.
Test read, write, failure and unauthorized paths before sharing a project-scoped extension with a team.
Use logs and visible status to distinguish proposed, running, succeeded and failed agent actions without exposing secrets.
STOP AND GET HELP WHEN
Do not turn a repair into a larger outage.
Do not expose a broad shell, database or deployment capability when the workflow only needs a narrow read or update action.
Do not put credentials, access tokens, private keys or sensitive customer data into visible canvas state or agent-readable artifacts unless the workflow has a reviewed requirement and appropriate controls.
Do not treat project scope as an authorization system; a shared extension still needs least-privilege runtime permissions and server-side checks for the actions it can take.
Do not remove human approval from irreversible or high-impact operations simply because the UI is more structured than chat.
Do not create a canvas solely to reproduce a one-time prompt that has no persistent state, repeatable action or verification benefit.
HOW GENESIS HANDLES IT
Diagnose the exact failure before choosing a repair.
Genesis separates the visible symptom from the underlying technical cause. Run the supported diagnostic first, review the evidence, and then use a matching repair only when the failure is actually verified.
GitHub describes it as a shared interactive surface for a work artifact or workflow. People and the agent can work against the same state, with UI actions for humans and callable capabilities for the agent.
Does a canvas replace chat?
No. GitHub's own guidance positions chat as useful for intent and ambiguity, while canvases are useful when work needs structure, iteration, direct inspection or verification.
Where are custom canvases stored?
GitHub documents .github/extensions for project-scoped team sharing and ~/.copilot/extensions for user-scoped personal extensions.
Can a canvas call APIs or local tools?
A canvas can expose capabilities and can be packaged with other plugin capabilities such as skills or MCP servers. GitHub's September 24 post also demonstrates canvases that interact with local tooling. Those actions still require normal permission, secret and authorization controls.
How do I create one?
GitHub's current documentation says to start an agent session and use the /create-canvas skill, then describe the workflow plus what the person and agent should be able to do.
Start with a free diagnostic. If Genesis verifies a problem and a compatible treatment exists, continue to the matching Code Store product or repair path. If you cannot find the exact code you need, request it at GenesisCodeDoctor.com rather than forcing a generic snippet into the wrong platform.
