What the AI can do

The built-in agent is not a chatbot that hands you code to paste. It acts on your canvas directly, through the same operations you run by hand, and everything it makes stays fully editable. This page is the full range. To try it, head to Your First AI Chat.

Create designs

Describe an outcome and the agent builds it as native, editable elements: full UIs, pages, dashboards, illustrations, diagrams, and wireframes. There is no import step and nothing is flattened to an image; every layer, frame, and text run is yours to nudge afterward.

You: "Create a pricing page with three tiers."

Result: three aligned cards with headings, feature lists, and call-to-action buttons, laid out on the canvas and ready to restyle.

Flip between the prompt and its result below. The result is real, editable elements compiled live on the same engine that draws your canvas, not a flattened screenshot: the frame, every text run, the checkmarks (real vector paths), and the button are all yours to nudge, recolor, and restyle.

View

The prompt, then the real editable result. Live on a desktop browser with WebGPU. Flip a control and the canvas recompiles in place.

Edit existing work

The agent reads your current design and changes it in place: adjusting properties, reparenting, renaming, deleting, and reordering. Point it at something with your selection or an @ mention and describe the change.

"Make @Card into a dark-mode variant."

"Tighten the spacing on the second column and match its heading to @Hero."

"Rename these layers to something sensible."

Read your selection and search

The agent can read what you have selected and look elements up across canvases by name, text, type, color, or component. That lets it act on the right thing without you spelling out ids.

"Apply the color palette from @Dashboard to @Card."

"Find every text layer using the old brand blue and switch it to the new one."

Run canvas commands

Beyond drawing, the agent can invoke Brilliant's own commands, over a hundred of them: align, distribute, flip, corner radius, opacity, blend mode, tool changes, and frame and component operations. Each runs through the exact path a button or shortcut does, with full undo.

"Align these to the left and distribute them evenly."

"Group the header and turn it into a component."

Export

The agent can render selected elements to PNG, JPEG, WebP, SVG, PDF, or HTML/React markup.

"Export @Card as SVG."

"Give me the hero section as React."

Generate images

The agent can generate raster images with Google's image model and apply them as image fills on target elements. Generated images are saved to the project's Assets/ folder.

Requires a connected Google provider (API key or sign-in), whichever chat model is active.
Sizes run roughly from 512px up to 4K; larger is slower and more detailed.
Reference images: the agent can pass existing canvas elements as visual references to steer style, or to "edit" a prior generation one change at a time.
Use for photos, realistic scenes, and complex textures.

Generate and trace vectors

The agent can generate editable vector graphics and place them as native vector elements, so you can move, resize, recolor, and reshape them like anything you drew by hand. It can also vectorize an existing raster element into editable paths, leaving the original intact.

Requires a connected Quiver provider, whichever chat model is active.
Use for icons, logos, illustrations, and diagrams: anything that should stay crisp at any zoom and stay editable.

Image or vector? Reach for image generation when you want a photo or a rich texture, and vector generation when you want something crisp and editable like an icon or logo. Have a raster you want to edit as paths? Vectorize it.

Spawn sub-agents

For large tasks, the main session can launch parallel helper agents that each work on a slice and return a summary, shown as collapsible cards in the transcript. You do not manage them directly; you just get a faster path through big jobs.

Send feedback to the Brilliant team

When you hit a wall, want a feature, or spot a bug, you can send feedback to the Brilliant team without leaving the app, and the agent can help you get it to the right place.

The feedback card is a notification in the rail at the top of the window: one text field, a Send button, and Cancel. Four things can open it:

The palette-only Send Feedback command (no default shortcut).
The agent's send_feedback tool. Despite its name, this tool never transmits anything: it opens the card in front of you (with an optional draft pre-filled) and returns. Nothing is sent until you press Send yourself.
A CTA that appears after an error.
A prompt the Brilliant team raises remotely to ask you one targeted question. The app checks for these periodically, and when one matches it surfaces as the same card.

Typing /feedback in the chat is different: it does not open the card. It first asks you to classify the feedback (bug, feature request, question, or praise) on a quick card, then hands routing to the agent with that class as context. The agent figures out the best destination (the card, a GitHub issue, email, or Discord) and asks you a single "where should this go?" question only when the destination is still not obvious. It uses one message.

The rule underneath all of it: nothing leaves your machine until you press Send. Your words move by your own act, and any context you attach (app version, error log, chat transcript, screenshot) rides along only per item, when you tick it. Privacy and consent is exact about what a submission carries.

Understand exactly what gets sent: Privacy and consent.
Connect a model to unlock all of this: Providers and models.