Draw, don't describe.

“An icon is not literally the figure it represents, but it provides a medium of interacting with the actual figure.” — David Canfield Smith, Pygmalion, 1975

In 1975, a Stanford graduate student named David Canfield Smith wrote a thesis that mostly went unread. In it he redefined a word that until then had meant only religious imagery — icon — and argued that a good creative tool must be three things: generative (its output changes with your input), interactive (cause and effect are immediately visible), and inherently positive — it must never tell you “you did that wrong,” but instead simply respond, and let you figure out why.

Fifty years later his idea conquered the world. When you drag an app into a folder, you don't distinguish the icon from the thousands of lines of code it stands for. As far as you're concerned, the icon is the app. But with the rise of large language models, the gap between the symbol and the substance has quietly widened again — because the dominant interface to the most capable software ever built is a text box that looks exactly like a search bar, a login form, and a credit-card field.

Three ways of knowing

The psychologist Jerome Bruner described three modes by which humans represent the world:

• Enactive — you recreate the thing through action. Walking a route.
• Iconic — you represent it by resemblance. A map of the route.
• Symbolic — you neither recreate nor resemble it. Spoken directions.

Every leap in human thought — Arabic numerals over Roman, the Cartesian plane fusing algebra and geometry, the desktop metaphor — came not from a new idea but from a better interface to an old one: a shift down the ladder, from the symbolic toward the iconic and enactive, closer to the physical world we evolved to understand.

Chat is purely symbolic. You manipulate strings; the meaning lives elsewhere.

Why every current answer falls short

Judge the field against three requirements. An interface for AI should (1) capture the full space of what a model can produce, (2) mix persistent and ephemeral elements, and (3) enable incremental, back-and-forth collaboration.

Chat fails the last two — it's a single linear stream, and nothing persists to point at. Voice is not a new paradigm at all, just chat with a different microphone; worse, it's unrevisable — you can't scroll back through a sentence or select a clause. Sidebars (Canvas, side panels) fix persistence but are iconic in display and symbolic in control: you see a picture, but to change it you go back to the text box and describe your edit. Artifacts get closest — a live, running program you can touch — but drag a box inside one and the change is forgotten, because the source of truth was always the conversation, never the canvas.

And node graphs — the reflexive answer of the AI era, from Agent Builder to n8n to FLORA — were never truly iconic. They're text logic arranged in two dimensions: boxes that are nouns from the program's internals, arrows that are its control flow. You end up arranging plumbing, not the thing you came to think about. The model's real gift was never that it draws better wires. It's that it can infer them — so the moment the connections become the model's job, you have no reason left to draw them at all. The graph doesn't get smarter. It dissolves into the model, and disappears.

The interface we're missing

In every existing paradigm the canvas is an output and the chat is the input. You think in the symbolic register — typing — and the model translates your sentences into something iconic. The visual layer is always downstream of the language layer, so you never actually think in pictures.

The missing interface is iconic and enactive: a canvas you act on directly, where dragging, drawing, grouping, and connecting are themselves the program — and where the model treats those actions as first-class input, not noise to be re-described in chat. The model generates the skeleton; you rearrange it by hand; the model reads the rearrangement and generates the next layer. The canvas becomes the shared, persistent artifact that both of you can point at.

Ask about a place, and an iconic canvas spatializes the answer — people as avatars you drag into groups, events as cards on a timeline, locations pinned to a map. Drag a person next to an event, and the model fills in how they're connected. You are no longer reading about the information. You are thinking with it — the way a child rearranges animals onto Noah's Ark.

Notice what is not on this canvas: wires. No arrows to route, no nodes to connect, no execution graph to debug. The plumbing has gone silent and underground. What remains in your hands is only the picture — the people, places, and events you actually came to think about. The chat box doesn't disappear; it recedes to where it belongs, one tool among many on a canvas you can finally touch.

This is what Ovid is for

Ovid — named for the poet of the Metamorphoses, the story of a sculptor whose creation is brought to life — is our attempt at the successor to that unread 1975 paper. You don't merely read a visual representation of your intent; you act on the canvas directly, and watch the system respond in kind. Real videos that play. Tables with real data. Diagrams that render. The icon, at last, containing the substance rather than pointing at it.

After fifty years of describing our intentions to the machine in words, we can begin, once again, to draw them.