zv1 can see your sketches
Whiteboards are usually where context goes to be invisible: the diagram that explains everything exists only as pixels nobody's AI can read. Napkin closes that gap. Ask zv1 about a sketch — from the docked assistant in any tool or full-screen at chat.zerowidth.ai — and it finds the board and actually looks at it: the layout, the arrows and what they connect, the handwriting-register strokes, the sticky notes, the reference cards and which real entities they point to.
That means you ask about what's drawn:
- "Look at my triage sketch — which path has no failure handling?"
- "The stickies on the retro board — group them into themes."
- "Does the architecture we sketched yesterday match how the flow is actually wired?" — the sketch names the real flow via its reference card, so zv1 can compare the drawing against the thing.
zv1 looks with your access: it can only see sketches you can see, and a reference card resolves for it exactly as it would for you.
Sketch cards in chat
When zv1 refers to a sketch, its reply carries the board as a clickable card with a live thumbnail — the conversation and the drawing stay attached, and one click drops you onto the canvas. The same card appears when you paste a sketch's URL on its own line in chat, and in a Compass page body — so a workflow page can show the diagram that explains it, thumbnail and all.
Whiteboard-to-work patterns
The point of an AI that reads the board is that a sketch can be the input to structured work:
- Sketch review
Rough out an agent architecture in a working session, then ask zv1 to critique it: unhandled branches, steps that belong in one node, the place a classifier should sit. You're getting review on the napkin version — before anything is built.
- Whiteboard to dataset
Sketch a grid of tricky cases during a brainstorm — inputs down one side, expected behavior on stickies. Ask zv1 to read the board and draft the Caliper dataset from it. It proposes; you approve the writes.
- Diagram to documentation
After the sketch settles, ask zv1 to turn it into prose — a Compass page describing the workflow the boxes and arrows show — and attach the sketch to the page so the drawing and the write-up travel together.
The common shape: the sketch is where the thinking happened, so pointing zv1 at the sketch is faster than re-explaining the thinking.
zv1 and decks
Decks get the same treatment, both directions:
- Reading — ask about a deck and zv1 reads it slide by slide: titles, text, speaker notes, what's drawn where, and which text areas are still empty. "What's slide 3 missing?" is a fair question, and so is "does this deck actually say what we decided?"
- Making — ask for a deck and zv1 builds one: real slides, real layouts, your workspace's brand color on the titles, handed over as a clickable card. From there it's yours — every slide is an ordinary Napkin canvas to reshape, draw over, and present. It can also work on a deck that exists: add a slide, or fill in the text areas a layout left open.
- Drawing — zv1 can also pick up the pen: strokes, shapes, arrows, and labels, on a slide or on a sketch. Ask it to circle what's weak on slide 2, mark up the diagram you drew, or rough out a quick figure of its own. What it draws is ordinary ink on the board — attributed, movable, and undoable like anyone else's.
A deck zv1 drafts and a deck you build by hand are the same thing on the same canvas — there's no separate "AI deck" format to escape from.
Programmatic access
Sketches and decks are reachable through the MCP server: with napkin:boards:read, agents can list boards, render any board or single slide to an image, and read a deck as a markdown outline; with napkin:boards:write, they can create boards, author decks, and draw on any board — the same capabilities zv1 uses, available to your own tooling.