Cursor Canvases: When to Ask the Agent for a UI Instead of Text

Cursor shipped interactive canvases on April 15, 2026 as part of Cursor 3.1, giving the agent a way to answer with a custom interface instead of more text. A canvas is an agent-generated dashboard, report, or mini-tool that renders next to the chat as a standalone view. It is designed for the moments when you would rather click around a UI than scroll through another wall of markdown.

Update (August 26, 2026): this page described canvases as session-scoped, unshareable, and unauthorable, and all three are now wrong. Cursor's canvas documentation says Cursor "saves the canvas so you can reopen and rerun it later with fresh data" and that "each canvas appears in your workspace's canvas list". Sharing shipped in the Cursor 3.5 changelog on May 20, 2026 and is documented today as a Publish action producing a browser link, gated to paid plans and to users who are on a team. And you are not locked out of the markup: the docs tell you to "switch to the source to tweak it" and note that "for small tweaks, you can also manually edit the source code". Two further corrections that were wrong on day one rather than gone stale are marked in place below: the fourth use case Cursor highlighted was autoresearch, not ML experiment tracking, and the launch post named canvas skills, which this page omitted entirely.

Key Takeaways

• Canvases are agent-generated interactive artifacts, not static images
• They persist past the session. Cursor saves each one to your workspace's canvas list, and you can reopen and rerun it with fresh data
• Three documented ways in: the card at the end of the agent's response, Open Canvas in the Command Palette under View, and a canvas tab in the Agents Window
• You can edit the source for small tweaks, or ask the agent to change the layout for larger ones
• Publishing to a team link needs a paid plan and a team. Free accounts cannot create shares
• Common canvas workflows can be packaged as skills so the layout comes out the same every time
• Best for incident response, PR review clustering, eval failure analysis, and watching a long-running agent experiment

What Is a Cursor Canvas?

A canvas is a custom interactive interface the Cursor agent emits in response to a prompt. Instead of returning a paragraph of analysis or a table dumped into chat, the agent assembles a small UI -- a dashboard, a triage view, a diff cluster, a chart panel -- and renders it as a standalone view laid out with sections, stats, and tables. Cursor's own framing in the docs is to "ask agents for a dashboard, analysis, audit, or report, and Cursor opens the result in a canvas when that is a better fit".

The component library is React-based and first-party. Cursor's launch post describes rendering canvases "using a React-based UI library with first-party components like tables, boxes, diagrams, and charts", alongside components you have already seen elsewhere in the editor like diffs and to-do lists. Logic and interactivity -- click handlers, filters, the way one row drills into another -- are tailored to the prompt that produced the canvas.

You do not have to author the canvas markup, and that is the normal path: you ask for what you want, the agent emits it, Cursor renders it. But the escape hatch exists. Cursor's documented iteration loop is to review the rendered view, "switch to the source to tweak it, or ask Cursor to change it", and it says outright that for small tweaks you can manually edit the source code.

The shape is closer to a generated mini-app than a generated document.

How Canvases Differ From Text or Code Replies

A text reply is read once and lost in scrollback. A code reply edits a file and lives in the repo. A canvas does neither. It is a UI that exists alongside the conversation, that you can click into, and that Cursor keeps for you afterwards.

That changes how you frame the prompt. With text, you ask "summarize the last 20 PRs and their status." With a canvas, you ask "show me the last 20 PRs grouped by author with status badges and a filter for stale ones." The first answer is one paragraph you read and forget. The second is a panel you keep open for the next two hours, sorting and filtering as your team's work changes underneath it -- and, per Cursor's docs, one you can reopen next week and ask the agent to rerun against current data rather than rebuilding from the prompt.

The canvas also avoids two everyday irritations of chat-shaped output. Long tables wrap badly inside chat bubbles and become hard to scan. Multi-source comparisons that would otherwise require copying numbers between Slack, a dashboard, and a spreadsheet collapse into a single rendered view. The agent does the join in the canvas; you do the looking.

Where Canvases Live and How to Reopen One

At launch, Cursor described canvases as durable artifacts in the Agents Window that "live alongside your other tools like the terminal, browser, and source control". That is still true, and the current documentation adds the part this page originally missed: canvases outlive the conversation that produced them.

Cursor documents three ways to open one:

Behind all three is the workspace canvas list. Cursor's docs state that each canvas appears in it "so you can jump back to past ones without rerunning them", and that Cursor saves the canvas so you can "reopen and rerun it later with fresh data". Rerunning is the interesting half: the canvas is not a screenshot of last Tuesday's numbers, it is a view the agent can repopulate.

The side-panel-as-peer pattern is not unique to Cursor in 2026. The same shape -- a canvas, a terminal, a browser, and source control coexisting next to a coding agent -- shows up in the Warp agentic development environment, and it is becoming the default mental model for where agent-produced artifacts belong.

Sharing a Canvas With Your Team

Sharing did not exist when this page was written. It shipped in the Cursor 3.5 changelog on May 20, 2026, and we covered it separately in Cursor shared canvases.

The documented flow is short: use Publish from the canvas toolbar to publish or refresh a share. Cursor uploads a live snapshot of the view and gives you a link teammates open in the browser with the same layout, charts, and tables, without rerunning the agent or reading the chat history. Everything a team has published is browsable under Shared Canvases on the Cursor dashboard, where recipients have read-only access.

The eligibility rules are the part worth reading before you promise a teammate a link:

• Paid plans only. Shared canvases are available on Pro, Teams, and Enterprise. Cursor states that free accounts cannot create shares.
• You have to be on a team. Each share is team-visible, so a solo Pro seat is not enough; Cursor notes that Pro users who are on a team can share.
• Privacy mode can block it. Sharing requires a privacy mode that allows data storage, and Cursor names Legacy Privacy Mode as one that blocks it.
• Admins can switch it off. Team admins can disable shared canvases for the whole organization from team settings.

Packaging a Canvas as a Skill

The launch post named this on day one and this page omitted it: you can create skills that teach agents how to build a particular kind of canvas. Cursor's example was a Docs Canvas skill that generates an interactive architecture diagram of your repo.

The docs now spell out what a canvas skill contains:

• A trigger description so Cursor knows when to reach for it, such as "quarterly revenue report" or "dependency audit"
• Layout instructions defining the sections, stats, and tables the canvas should contain
• Data sources and queries to populate the view, such as a SQL query, an API call, or a shell command
• Formatting rules like units, date ranges, or sort order

The payoff is consistency across people rather than novelty: a short prompt regenerates the canvas with fresh data, and every teammate using the skill gets the same output shape. If you have a canvas you rebuild by hand more than twice, that is the one to package.

The Four Use Cases Cursor Highlights

Cursor's launch post walks through four jobs its own engineers hand to canvases. They are worth memorizing because they are the shape of the prompts where canvas-versus-text is an obvious win.

1. Incident response dashboard. When something breaks, the data you need is spread across Datadog, Sentry, and a Databricks query. Cursor's account is that before canvases the agent rendered time-series data as a markdown table that was hard to interpret; now it joins data from multiple sources, including local debug files, into a single chart. You stop alt-tabbing between three browser tabs and start asking the chart questions.

2. PR review interface. Cursor's framing is that traditional tools "present all changes equally", leaving you to work out what matters. A canvas groups related changes, prioritizes what to review first, and can write pseudocode representations of tricky algorithms, so you scan the change set at the level of intent before opening any diff.

3. Eval analysis. Eval suites generate hundreds of pass/fail rows that are useless as a flat list. Cursor's engineers had been inspecting request IDs one at a time; they considered building a web app for it and instead operationalized it as a skill that reads every rollout in an eval, groups failures, and builds a canvas for clustering failure modes. Cursor credits it with surfacing harness bugs that had been hidden.

4. Autoresearch experiments. Correction: this page previously called the fourth use case "ML experiment tracking" and described loss curves and checkpoint tables. That was our paraphrase, not Cursor's example. What Cursor actually describes is adapting the ideas in autoresearch so agents can attack complex optimization problems, with the canvas visualizing the agent's research progress while experiments run -- so you can check on progress and see which hypothesis it is currently testing. The job is watching a long-running agent think, not tabulating training runs.

The thread connecting all four is multi-source data the agent can pull together for you, with enough interactivity that you keep coming back to the same canvas.

When to Ask for a Canvas vs Plain Text

Not every question wants a canvas. The choice is mostly about whether you are reading the answer once or working with it.

Ask for a canvas when:

• The answer pulls from multiple sources you would otherwise stitch by hand
• You expect to filter, sort, or re-query the same data several times
• There are many similar items to scan visually -- PR clusters, eval rows, experiment runs
• The output is a reusable view you will want again next week, since Cursor keeps it and can rerun it

Stick with plain text or a code edit when:

• The question has a one-shot answer that fits in a paragraph
• The agent is editing files and the canonical artifact is the diff, not a UI
• The work ends in a commit, a deploy, or a chat message rather than a clickable view
• You do not need to come back to the answer after reading it

The cost of a canvas is the agent's time to assemble it and the screen real estate. For a quick lookup, it is overkill. For a triage pass over 50 alerts, it is the difference between a 10-minute scroll and a 10-second scan. (For a different angle on instructing Cursor, see the Cursor rules tutorial on auto-generating skills from your chat history.)

Canvases vs Claude Artifacts vs ChatGPT Canvas

Canvases sit inside a small but growing category of "durable, interactive, agent-generated artifacts." The conceptually closest cousins are Claude artifacts and ChatGPT canvas. All three give the model a way to emit a persistent, interactive surface instead of more chat.

The differentiator Cursor leans on is the dev environment. A Cursor canvas is tied to the agentic workflow specifically, and that workflow has access to your repo, your terminal, and your source control. A canvas can pull data and context from those surfaces in a way that a chat-window artifact cannot. Artifacts and ChatGPT canvas live inside chat threads. Cursor canvases live alongside the rest of the dev environment, and now also outside it: a published canvas is a browser URL your non-Cursor colleagues can open.

The artifact-vs-canvas naming differences across vendors are still settling, and the safer way to reason about them is by where the artifact lives -- inside chat or alongside the IDE -- and what it can pull from. For a broader read on how Cursor and Claude Code line up across the rest of their feature surface, the cursor vs claude code comparison is the longer treatment. For the broader 2026 agentic-tools context, Claude Code Routines is the other major April 2026 launch worth pairing with this one.

Pricing and Availability

Canvases shipped with Cursor 3.1 in both the Agents Window and the editor, and Cursor's current documentation does not describe canvas creation as tier-gated. What is gated is sharing: publishing a canvas as a team link requires a paid plan (Pro, Teams, or Enterprise), a team, and a privacy mode that permits data storage, and an admin can turn it off org-wide.

The most useful thing to do this week is to take a single recurring task -- a triage queue, an alerts dashboard, a backlog grooming pass -- and try asking for it as a canvas instead of as a text answer. Then come back to it on Friday from the canvas list and ask the agent to rerun it. If the second look is faster than rebuilding the question, you have found the shape of prompt this feature was built for, and it is probably worth packaging as a skill.

Sources

• Cursor docs, "Canvases". Saving and reopening, the workspace canvas list, the three entry points, the Publish flow and share link, the paid-plan and team requirements, the privacy-mode block, the admin toggle, source editing, and the anatomy of a canvas skill. Checked August 26, 2026.
• Cursor changelog, "Shared Canvases and /loop Skill", May 20, 2026. That sharing shipped, the live-snapshot link, read-only access in the Cursor Dashboard, and Pro/Teams/Enterprise availability. Checked August 26, 2026.
• Cursor blog, "Interact with agent-created visualizations in canvases", April 15, 2026. The React-based first-party component library, canvases as durable artifacts in the Agents Window, the four use cases including autoresearch, and canvas skills such as Docs Canvas. Re-checked August 26, 2026.
• Cursor 3.1 changelog, April 15, 2026. The release canvases shipped in. Re-checked August 26, 2026.
• Cursor docs, "Agents Window". The Agents Window surface canvases render beside. Checked August 26, 2026.