The Problem: Agents Outpace Human Review
We now have tools to plan, build, review, and ship code, but many workflows still feel disjointed. Context gets lost across threads and surfaces, and too much time is spent reviewing agent-generated work. 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. It becomes easy to lose track of what ran, what changed, what was validated, and what still needs human judgment.
This is the coordination tax: when you have to reconstruct the plan, decision points, validations, and approval moments from a long chat scroll, you’re already paying for lost context. The GitHub Copilot app addresses this with canvases—a durable, shared surface where developers and agents interact. Canvases make work visible, steerable, and approvable as it unfolds, turning agentic workflows from ephemeral conversations into persistent, auditable systems.
Chat Is Great for Intent, Weak for Durable Execution
Chat remains one of the best interfaces for intent. It’s where you think, refine, and direct, especially when the problem is still ambiguous. But once an agent starts doing real work, chat becomes a long scroll of instructions, logs, pivots, and corrections. The important parts are technically there but buried: the plan, decision points, validations, and approval moments. If you have to reconstruct all of that from history, you’re already paying a coordination tax.
Canvases solve this by giving workflows a home. They make state explicit and persistent. Humans can inspect and guide; agents can update and progress. Both can stay aligned without constantly replaying context. This is a shift from prompt-by-prompt interaction to durable collaborative workflows, where each workflow becomes a system with memory, structure, and control.
Two Real-World Canvases: Java Modernization and Site Studio
Java Modernization Studio
One of the first canvases Gupta built was Java Modernization Studio. Java modernization is exactly the kind of workflow where visibility and governance matter: assessment, planning, migration tasks, validation gates, and readiness to ship. In a chat-only experience, those steps blur together. You can still move forward, but it gets harder to audit and harder to trust at scale, 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 each phase explicit and inspectable. The Overview tab shows the modernization journey—Assess, Remediate, Validate, Ship—along with a compile-blocker card, a Run on autopilot option, assessment findings with P0–P3 severity counts, and the detected stack. Instead of parsing narrative history, teams could see operational state directly. Human reviewers could focus on high-signal judgments while agents kept execution moving between checkpoints.
Site Studio
After that, Gupta built Site Studio for a very different workflow: creating and managing personal site content. It’s content-heavy rather than migration-heavy, but the orchestration challenge is similar: section progress, iterative edits, review loops, and status transitions. In a chat-only flow, content can drift quickly. A section gets revised, then revised again, and confidence drops in what is current. Feedback gets scattered, drafts repeat, and momentum slows because each iteration starts by rebuilding context.
Site Studio keeps that state durable. The Content tab shows 100% completion with editable sections—Design System, Hero, Navigation, About, Conference Talks, Videos, and Contact—each with 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 can steer, approve, or redirect without losing the thread.
Both canvases are available in awesome-copilot for anyone to use, adapt, or learn from.
The Repeatable Pattern: Four Steps to a Durable Workflow
Across both canvases, Gupta found the same repeatable blueprint:
- Define workflow states clearly. What are the stages? What does each mean?
- Surface the decisions that matter. Make key choices visible and inspectable.
- Persist progress and drafts immediately. Don’t wait for a final output; save state as work happens.
- Keep explicit human approval points. Make it clear where human judgment is required.
This shifts the model from prompt-by-prompt interaction to durable collaborative workflows. You stop treating each turn like a fresh start and start treating each workflow like a system with memory, structure, and control.
Cost and Efficiency: The Investment Pays Back
Gupta is explicit about cost: canvases can be an investment. For instance, Site Studio cost about 2,000 AI credits, and the modernization canvas cost about 3,000 AI credits. They take effort to design and shape well. But in the long run, especially for repeated workflows, that investment pays back. Durable surfaces reduce repeated prompting, reduce context loss, reduce unnecessary back-and-forth, and reduce rework. Over time, that can save both time and money while improving trust and throughput.
This is not “spend more tokens for nicer UX.” It’s “invest in better workflow architecture so recurring work becomes more efficient, predictable, and governable.” The cost is a one-time investment, while the savings from reduced coordination tax are recurring. The payback period depends on how often you run the workflow and the size of your team, but the ledger is transparent—a rarity in AI feature announcements.
Practical Takeaway: Start Small, Iterate, and Contribute
If you’re already using 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, and iterate from actual usage. If it helps your team, contribute it back to awesome-copilot so others can benefit too.
We’re still early in this transition, 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.
Sources
AI-assisted summary compiled from the sources above, reviewed by a human before publishing.