Rusty Canvas (beta)

Rusty Canvas is a visual planner and executor for larger features. Open it from Rusty Canvas in the left rail. A canvas is called a Rusty.

Warning

Canvas is in beta. It is being actively reworked, so expect its layout and behavior to change between releases.

Canvas sits in the middle of the process, not at the beginning and not as the final authority. You decide what should exist, use the canvas to build it deliberately in small steps, and finish at a Git boundary.

The workflow

1. Explore the feature. Start in a normal chat. Investigate the existing code, compare approaches, and turn a vague request into a decision you are ready to implement.
2. Capture the brief. Extract the useful result into a Markdown file. The brief is durable project context, not knowledge trapped in chat history.
3. Generate the graph. Open a Rusty, attach the brief, and ask the Global Explorer to propose an implementation graph. The proposal is a starting point, not an order to execute. Use Review generated graph to check it.
4. Iterate node by node. Work one bounded task at a time. Select the task's model and skill, run it, inspect the generated files and diff, then use the node's chat to correct or deepen the result.
5. Reconcile convergence. Independent tasks may change the same file. Open reconciliation to compare their intended changes and compose one coherent implementation.
6. Review and merge. Review the Rusty as a whole, apply its virtual changes to the real workspace, and use Git as the final integration boundary.

A failed first result is information. Don't compensate with a larger prompt or blindly accept a plausible diff: find what the task lacked, make that context explicit, and run the bounded loop again.

Nodes

Each shape has one responsibility.

Node	What it is for
Global Explorer	The reasoning center for the canvas. Give it your feature brief, explore the codebase, and generate an editable graph of tasks and supporting context.
Task node	A focused unit of execution. It receives only its connected context and upstream work, then writes its result into an isolated virtual workspace for review.
Context node	Attach a file, folder or written instruction to the tasks that need it. Explicit context keeps generations grounded and makes their inputs visible.
MCP node	Connect a configured MCP server to a task when the work depends on information outside the repository, such as documentation, services or project systems.
Sticky note	Record an assumption, question, decision or reminder beside the work it concerns. Sticky notes never execute and never spend tokens.
Boundary	Group related work into a named visual area. It makes large canvases navigable without changing execution.

Edges describe the flow of evidence and work: which context feeds a task, and which task's output feeds the next.

Task results and the virtual workspace

A task never writes straight into your project. Its output goes to an isolated virtual workspace (VFS). The task's side pane has tabs for a Description, the Diff of what it produced and a Console, and you can clear a file from a node's change history or use Save changes to workspace to write it to disk when you are happy.

Markdown files created in the virtual workspace can be listed and opened in the editor from the canvas's Markdown menu.

Reconciliation

When independent tasks converge on the same file, select the edge between them to open the edge inspector. It has:

• an edge diff, to compare each task's intended change,
• a conflicts view, and
• a resolve chat, where you work with an agent to compose one coherent version.

Saving canvases

Canvases are saved in your workspace under .rusty/canvas/ as JSON, and include the graph, node logs and status, and the virtual workspace contents. Rusty asks before closing a canvas with unsaved changes.

When to use Canvas

Use a normal Agent Mode chat for quick, contained work. Reach for Canvas when a feature spans several files or several independent pieces, or when you want to see and control exactly what each step is given.