When chat stops being enough
Agentic workflows have moved past the novelty phase. Development teams now regularly collaborate with AI agents that can plan, write, and review code at a pace that outstrips human review cycles. The problem is that the tools around those workflows haven't caught up. Context gets scattered across chat threads, logs, and diff views. It becomes difficult to reconstruct what an agent ran, what changed, what was validated, and which decisions still need a human in the loop.
The GitHub Copilot app addresses this with canvases—a persistent, shared surface where developers and agents can interact on work as it progresses. Rather than treating chat as the sole medium for directing agentic work, canvases turn workflows into something visible, inspectable, and steerable.
Chat captures intent, not execution
Chat remains a useful interface for articulating intent, especially when the problem is still ambiguous. It's fast and flexible for thinking out loud and refining direction.
The weakness emerges once an agent starts doing substantive work. A chat thread quickly becomes an unstructured log of instructions, status updates, and course corrections. The critical information—the plan, decision points, validation results, approval gates—is all technically present but buried in narrative history. Reconstructing state from that history is a coordination tax that grows with each turn.
Canvases make state explicit and durable. Agents can update progress; humans can inspect and intervene. Both sides stay aligned without having to replay context on every interaction.
Two canvases, one workflow pattern
The Java Modernization Studio was built for exactly the kind of workflow where visibility and governance matter: assessment, planning, migration tasks, validation gates, and shipping readiness. In a chat-only setup, those stages blur together, making it hard to audit work or trust it at scale—especially with multiple contributors. Teams repeatedly ask the same questions: What stage are we in? What decisions were made? What's blocked and what needs approval?
The studio made each phase explicit and inspectable. Team members could see operational state directly instead of parsing narrative history. Human reviewers focused on high-signal judgments while agents kept execution moving across checkpoints.
Site Studio applied the same principles to a content-heavy workflow: creating and managing personal site content. The stakes are different, but the orchestration challenge is similar—section progress, iterative edits, review loops, and status transitions. In a chat-only flow, content drifts: a section gets revised repeatedly, confidence drops in what's current, feedback gets scattered, and momentum stalls because each iteration starts from scratch. Site Studio persists draft values as work happens, keeps section status visible, and marks human review points explicitly.
Blueprint for a durable workflow
Both canvas builds followed the same four-step structure:
- Define workflow states clearly.
- Surface the decisions that matter.
- Persist progress and drafts immediately.
- Keep explicit human approval points.
This shifts the model from prompt-by-prompt interaction to an ongoing collaborative system with memory, structure, and control. Each turn stops being a fresh start.
Upfront cost, recurring payoff
Canvases are an investment. Site Studio consumed roughly 2,000 AI credits to build; the modernization canvas, about 3,000. Designing and shaping them well takes effort.
For repeated workflows, the investment pays back. Durable surfaces cut down on repeated prompting, reduce context loss, eliminate back-and-forth, and avoid rework. The cost model is better framed as workflow architecture: spend more upfront so recurring work becomes more efficient, predictable, and governable.
Starting with your own canvas
Both Java Modernization Studio and Site Studio are available in awesome-copilot for teams to use, adapt, or learn from. For teams already working with Copilot agents, a practical first step is to pick one repeated workflow and build a minimal canvas around it using /create-canvas. Start small, run real work, and iterate based on actual usage.
The transition to hybrid human-agent development is still early, but the direction is clear. Agents accelerate execution; humans supply vision, judgment, and accountability. Canvases are a concrete mechanism for keeping that partnership durable.
