Summary: GitHub advocate Ayan Gupta describes Copilot canvases as durable shared surfaces that make agentic workflows visible, steerable, and approvable instead of buried in chat history. Two examples are a Java modernization studio and a Site Studio, costing about 3,000 and 2,000 AI credits respectively. The proposed blueprint defines states, surfaces decisions, persists drafts, and keeps explicit human approval points.
The Problem: Agents Outpace Human Review
Teams already have the tools to plan, build, review, and ship code, yet plenty of workflows still feel disjointed. Context slips away as work moves between threads and surfaces, and more and more time goes into reviewing agent-generated output. As GitHub Developer Advocate Ayan Gupta notes in a recent blog post, agents can produce changes faster than any human can review them, and most developer tools were not originally designed for multi-agent orchestration. So it becomes easy to lose track of what ran, what changed, what was validated, and what still needs human judgment.
That is the coordination tax: the moment you have to reconstruct the plan, decision points, validations, and approval moments out of a long chat scroll, you are already paying for lost context. The GitHub Copilot app’s answer is canvases—a durable, shared surface where developers and agents interact. Canvases keep work visible, steerable, and approvable as it unfolds, which turns agentic workflows from ephemeral conversations into persistent, auditable systems.
Chat Excels at Intent, Not at Durable Execution
For expressing intent, chat is still hard to beat. It is where you think, refine, and give direction, especially while the problem remains ambiguous. The trouble starts once an agent begins real work: chat turns into a long scroll of instructions, logs, pivots, and corrections. The parts that matter—the plan, decision points, validations, approval moments—are technically there, just buried. Reconstruct all of it from history and you are paying a coordination tax again.
Canvases give workflows a home instead. State becomes explicit and persistent: humans inspect and guide, agents update and progress, and both stay aligned without constantly replaying context. That is the shift from prompt-by-prompt interaction to durable collaborative workflows, in which each workflow becomes a system with memory, structure, and control.
Two Canvases in Practice: Java Modernization and Site Studio
Java Modernization Studio
Java Modernization Studio was among the first canvases Gupta built. Visibility and governance matter in exactly this kind of workflow: assessment, planning, migration tasks, validation gates, and readiness to ship. Inside a chat-only experience, those steps blur together. You can still move forward, but auditing gets harder and trust at scale gets harder, especially with multiple contributors. Teams keep asking the same expensive questions: What stage are we in? What decisions were made? What is blocked? What still needs human approval?
The studio made every phase explicit and inspectable. The Overview tab lays out the modernization journey—Assess, Remediate, Validate, Ship—next to a compile-blocker card, a Run on autopilot option, assessment findings with P0–P3 severity counts, and the detected stack. Rather than parsing narrative history, teams read operational state directly. Human reviewers spent their attention on high-signal judgments, while agents carried execution forward between checkpoints.
Site Studio
After that, Gupta built Site Studio, aimed at a very different workflow: creating and managing personal site content. The work is content-heavy rather than migration-heavy, but the orchestration challenge rhymes: section progress, iterative edits, review loops, and status transitions. Content drifts quickly in a chat-only flow. A section gets revised, then revised again, and confidence in what is current drops. Feedback scatters, drafts repeat, and momentum slows because every iteration starts by rebuilding context.
Site Studio holds that state durably instead. The Content tab reports 100% completion with editable sections—Design System, Hero, Navigation, About, Conference Talks, Videos, and Contact—each carrying filled fields and a “Mark ready for review” action. Draft values are persisted as work happens. Human review points are explicit. The agent can keep moving while the human steers, approves, or redirects without losing the thread.
Both canvases are available in awesome-copilot for anyone to use, adapt, or learn from.
The Repeatable Blueprint: Four Steps Toward a Durable Workflow
Across both canvases, Gupta found the same repeatable blueprint:
- Define workflow states clearly. Which stages exist, and what does each one mean?
- Surface the decisions that matter. The key choices should be visible and open to inspection.
- Persist progress and drafts immediately. Save state as work happens rather than waiting for a final output.
- Keep explicit human approval points. It should be obvious where human judgment is required.
The model moves from prompt-by-prompt interaction to durable collaborative workflows. Each turn stops being a fresh start, and each workflow becomes a system with memory, structure, and control.
Cost and Efficiency: When the Investment Pays Off
Gupta is explicit about cost: canvases can be an investment. Site Studio, for instance, cost about 2,000 AI credits, and the modernization canvas about 3,000 AI credits, on top of the effort required to design and shape them well. Over the long run, though, and especially for repeated workflows, that investment pays back. Durable surfaces reduce repeated prompting, reduce context loss, reduce unnecessary back-and-forth, and reduce rework. With time, that can save both time and money while improving trust and throughput.
The framing is not “spend more tokens for nicer UX” but “invest in better workflow architecture so recurring work becomes more efficient, predictable, and governable.” The cost behaves like a one-time investment, while the savings from a reduced coordination tax recur. How long payback takes depends on how often you run the workflow and the size of your team, but at least the ledger is transparent—a rarity in AI feature announcements.
Practical Takeaway: Start Small, Iterate, Contribute Back
If you already use Copilot agents, a practical next step is to pick one repeated workflow and build a minimal canvas around it with /create-canvas. Start small, run real work through it, and iterate from actual usage. If it helps your team, contribute it back to awesome-copilot so others can benefit too.
This transition is still young, but the direction is clear. Agents can accelerate execution. Humans provide vision, judgment, and accountability. Canvases are one way to make that partnership real, durable, and scalable. For builders designing their own agentic workflows, the key is to treat the workflow as a system design problem, not a conversation: make approval points product features, persist state as a prerequisite for auditability, and start with the most painful, high-frequency workflow to amortize costs.
Limitations remain: this implementation is tied to the GitHub Copilot ecosystem, the credits pricing model is still evolving, and cross-platform canvas abstractions don’t exist yet. But the pattern is clear and transferable: when agents become the primary executors, human value shifts to vision, judgment, and accountability—and the interface’s job is to make those three things happen.