FIGR AI • AI-NATIVE CANVAS
From fixed gallery to shared memory for people and AI increasing attachment adoption from 51% to 73%
My role
Product Designer
Years
May 2026
Platform
Web Application
Scope
Team
4 Engineers & CTO
TL;DR
The Canvas became shared working memory for teams and AI
Figr's Canvas became a shared workspace where teams could organise screens, map flows and annotate feedback while the agent understood every change. It turned AI outputs from static results into editable context that people and AI could build on together.
43%
increase in attachment adoption
4.6×
queries from visual-context users
3.8×
upgrade rate among visual-context users
problem discovery
Slack requests, Mixpanel recordings and query-box workarounds showed that people expected direct control
The interface borrowed whiteboards’ visual language without the interactions people expected. The gap surfaced through three recurring signals:
In our Slack support groups, teams asked for basic canvas controls and better ways to organise screens, connect flows, add headings and mark exact regions.
In Mixpanel recordings, people repeatedly tried to drag and resize artifacts even though those interactions did not exist.
In the query box, users asked the agent to delete or resize objects—basic direct-manipulation actions—because conversation was their only way to control the Canvas.
Together, these behaviours revealed more than a feature gap. People saw a canvas and expected to work spatially, but the product made them describe each change in words. The workspace looked like a canvas and behaved like a gallery.
understanding interaction
The interaction model placed the Canvas—not chat—at the centre of the human–AI loop
I mapped the product as a three-part loop:
Human-Canvas-AI Interaction Loop
AI Prototyping a POC
Using Claude Code, I built a functional POC to test the Canvas and live agent together before committing engineering bandwidth
The opportunity was not a generic whiteboard. Teams needed to bring in the existing product, add context through familiar actions and see what the agent could use.
A static prototype could not test that system. Using Claude Code, I built a working POC with movable nodes, text, sticky notes, connectors, sections and area annotations. The agent received the starting Canvas as structured JSON; each change travelled with the next query as a diff.
Testing both sides together made the model credible and exposed expensive edge cases before engineering committed.
The weakest link was AI → Human. Most AI tools returned static output, forcing people back into chat to continue. In Figr, every response needed to become spatial material—something people could move, connect, annotate and use as the next instruction.
This set the principle for the approach: Figr should never feel like chat with a canvas attached. Every meaningful interaction should either read from or change the Canvas. The Canvas was the medium through which people and AI could think together.
Annotations as Sticky notes in POC
POC Testing - Chat, Agent Inputs and Canvas Activity
POC Compare - With/Without Canvas and Activity
what we learned
User calls validated the familiar Canvas model while the POC exposed two collisions before production
On calls, users needed little guidance. They quickly picked up moving, resizing, connecting and arranging objects because the POC followed canvas conventions they already knew. This validated the core interaction model; the remaining friction appeared where those conventions met Figr's annotations and live agent.
What broke in the POC
What we shipped
Every marked region created a sticky note that had to avoid overlaps, stay anchored and resize with its attachment
A persistent marker opened a lightweight annotation. Annotations informed the agent; team comments remained collaboration-only
The bottom toolbar became unstable as tools grew, while chat competed with the same space
Familiar canvas tools moved left, the work stayed central and the agent moved right
The calls validated the foundation, while these collisions defined its production boundaries. Simplifying them reduced implementation scope and made the hierarchy clear: chat carried the conversation; the Canvas carried the evolving work.
using the canvas state
Every Canvas edit became a diff, so users could show the agent what changed instead of explaining it again
The full Canvas preserved the work's history. Moving a screen, adding a note, connecting nodes or marking a region created a smaller update for the next query.
Spatial changes helped people think; diffs made those changes legible to the agent. Users who sent Canvas edits back did so 3.2 times on average.
Canvas Final
friction in the design system setup
After the New Canvas, use became deeper, not broader: attachment adoption rose from 51% to 73% while events per adopter rose 33%
We compared four complete weeks before the 28 May release with four weeks after it, excluding rollout week.
The active base was smaller: weekly attachment users fell 9%. But attachment events rose 21%, events per adopter rose 33% and artifact-action events more than doubled.
Visual-context users also made 4.6× as many queries, exported 2.2× more often and upgraded at 3.8× the rate of people who added no attachments. This is association, not attribution: concurrent releases, instrumentation changes and user intent could all influence the difference.
9%
30%
63%
73%
51%
34%
5%
1.3%
Added attachments
Acted on an artifact
Artifact full-screen
Used Select & Edit
% active users
0%
20%
40%
60%
80%
Canvas engagement deepened after launch
learnings & reflections
AI-assisted prototyping let me test the whole system before designing every part
I used AI-assisted coding early to make the full Canvas model tangible—direct manipulation, annotations, layout and agent context. Testing a working system helped me explore larger ideas, expose edge cases and discard complexity before detailed design or engineering.
By the time I returned to design, the core model and boundaries were clear. AI expanded what I could explore; judgment decided what should ship. It also revealed the deeper product idea: the Canvas was not another whiteboard, but shared memory between people and AI.
Connect with me