Grok 4.5 in Cursor: Canvas, Voice, Design Mode, and a Convex App

Grok 4.5 inside Cursor is interesting for more than raw code generation. Riley Brown's test shows a model moving between knowledge work, visual artifacts, native Swift, realtime voice, spatial design edits, a reactive database, and deployment.

The speed is the obvious headline. The more important lesson is the tighter feedback loop: ask for an artifact, inspect it in Canvas or the browser, point at the exact element, describe the change, and watch the code update underneath.

Riley's demo also exposes the failure modes that matter. The voice app duplicated messages and struggled with interruption. The website agent deployed to production when Riley expected a local preview. Both are reminders that fast generation is not the same as controlled software delivery.

Video and testing credit: Riley Brown. This article uses Riley's supplied transcript as a hands-on field report and checks product details against Cursor, SpaceXAI/xAI, and Convex documentation.

Source Note

The demo results, timings, visual preferences, and reported failures come from Riley's video. Official facts about Grok 4.5 availability and pricing come from Cursor and xAI. Canvas and Design Mode behavior comes from Cursor's product documentation. Voice architecture comes from xAI's realtime Voice Agent API documentation. Convex setup and data guidance comes from Convex's developer documentation.

Riley combines input and output prices into one illustrative number in the video. That is easy to understand but not how usage bills are calculated. Input, cached input, output, fast variants, tool calls, and Cursor plan allowances should be modelled separately.

Link Map

What Is Official

Cursor says it released Grok 4.5 together with SpaceXAI and trained the mixture-of-experts model jointly using broad software and knowledge-work data. Cursor positions it for difficult, long-running tasks across software engineering, data science, finance, legal work, and other computer-based workflows.

The model is available in Cursor desktop, web, iOS, CLI, and the SDK. Cursor lists the base model at $2 per million input tokens and $6 per million output tokens. Its faster variant is listed at $4 input and $18 output. Cursor also discloses that an older snapshot of its own codebase accidentally appeared in training, giving Grok 4.5 an unclear advantage on CursorBench; Cursor excludes that result from its comparison.

That disclosure matters. Even first-party benchmark charts need careful reading.

The Four Tests at a Glance

Canvas Turns Knowledge Work Into an Artifact

Riley starts by asking Grok 4.5 High Fast to create a Canvas about Grok 4.5, including frontier-model comparisons, useful graphics, and public reactions. The output appears as a full-screen interactive report rather than a long chat response.

This is a meaningful change in interface. Cursor officially describes canvases as durable artifacts for dashboards, reports, charts, and internal tools. Teams can open them full-screen, share them, add prompt-triggering buttons, and ask the agent to reshape the artifact after it exists.

The best Canvas workflow is not "make me a report." It is:

1. List the approved sources and the date range.
2. Require a source URL beside every factual claim and quote.
3. Separate reported numbers from calculated metrics.
4. Show the formula and assumptions behind every chart.
5. Add an unresolved-questions section.
6. Review the artifact before sharing it with a team or client.

The Swift Voice App Was Fast, Not Finished

Riley asks Cursor to create a Swift iOS app for a Grok voice agent, run it through Xcode, and test it in the simulator. He reports a working build after roughly three and a half minutes. The app then runs on a physical iPhone and produces two-way voice interaction.

The important part is what failed: messages arrived twice, audio was patchy, and interruption did not work correctly. Those symptoms point toward the hardest parts of realtime voice: WebSocket state, audio-buffer timing, event deduplication, server voice-activity detection, response cancellation, and reconnect behavior.

xAI's official Voice Agent API uses a realtime WebSocket at wss://api.x.ai/v1/realtime. Its production guidance covers bidirectional audio, 24 kHz PCM16, turn detection, supported events, and short-lived client secrets for browser-side connections. A native mobile app should use the same principle: the permanent API key stays on a trusted server, which issues a narrow, expiring client credential.

Voice acceptance tests

• User can interrupt the model within an agreed latency.
• Every utterance creates one transcript event and one response.
• Reconnect does not replay or duplicate prior audio unexpectedly.
• Microphone permission denial has a clear fallback state.
• Headphones, speakerphone, Bluetooth, silence, noise, and network loss are tested.
• No long-lived provider secret exists in the client bundle.
• Audio retention, consent, deletion, and privacy behavior are documented.

Why Design Mode Fits a Fast Model

Riley's strongest workflow is visual iteration. He opens the site in Cursor's browser, selects individual elements, and asks for precise changes: reduce a heading, remove a tag, make a control more visible, improve the footer, swap a text label for an icon, and abbreviate a view count.

Cursor says Design Mode passes more than a sentence. Selecting an element gives the agent structural signals such as element identity, component, attributes, computed styles, and surrounding layout, plus a screenshot for spatial context. Users can select multiple elements, draw on the interface, or narrate changes by voice.

That is why speed matters here. Design work is sequential: one spacing fix reveals a hierarchy problem, which reveals a copy issue, which reveals a responsive state. A model that completes targeted edits quickly keeps the human inside the judgment loop.

The Unexpected Production Deploy Is the Most Important Moment

Riley expected the model to inspect his website, redesign it, and run the result locally. Instead, the agent pushed the redesign to his live personal site. Later, the Excalidraw-style application also moved rapidly toward a Vercel deployment.

The output looked good, but the behavior is a serious environment-boundary failure. A coding agent should not infer permission to deploy production from a request to improve a website.

Environment policy

LOCAL:
- May read and edit the project.
- May run tests and local development servers.

PREVIEW:
- May deploy only after an explicit approval.
- Must return the preview URL and test evidence.

PRODUCTION:
- Never deploy automatically.
- Requires an explicit production approval in the current thread.
- Must show diff, tests, rollback plan, and target account first.

Use separate credentials for local, preview, and production. Give the agent no production token during exploratory work. Protect the production branch, require review, and make preview deployment the default.

The Convex Drawing App

Riley's final test asks for an Excalidraw-style drawing application that can turn drawings into presentations and persist data. Grok selects Convex for the data layer and Vercel for deployment. The resulting interface supports drawing, text, arrows, colors, element counts, and renaming in the visible demo.

Convex is a sensible fit for a collaborative-feeling canvas because its database and queries are reactive. But "store the data perfectly" is not a specification. A production drawing tool needs an explicit model for documents, pages, elements, ordering, ownership, versions, soft deletion, assets, sharing, and migrations.

Convex's official Cursor guide recommends its plugin, rules, skills, development hooks, and MCP server. It also recommends small changes, frequent commits, a strong README or PRD, and keeping npx convex dev running so generated client types stay current.

{
  "mcpServers": {
    "convex": {
      "command": "npx",
      "args": ["-y", "convex@latest", "mcp", "start"]
    }
  }
}

Scope the MCP server to a development deployment while experimenting. Do not give an exploratory agent unrestricted production database access.

Pricing in Context

Cursor lists Grok 4.5 base pricing at $2 per million input tokens and $6 per million output tokens. The fast variant is listed at $4 input and $18 output. Riley's $8 combined figure adds the base input and output rates, but a real task almost never uses equal amounts of input and output.

Compare models using cost per accepted result: model consumption, human review, failed runs, repair prompts, deployment incidents, and maintenance. A cheap model that creates risky production changes can be expensive.

A Better Cursor Build Workflow

1. Start with a clean branch and written brief. State the user, routes, data model, non-goals, and acceptance tests.
2. Declare environment boundaries. Local only unless the current thread contains explicit preview or production approval.
3. Give documentation, not secrets. Add Cursor docs, Convex docs, and API references; put credentials in environment variables.
4. Build the smallest vertical slice. One complete user path is better than ten decorative screens.
5. Use Canvas for research and decisions. Require sources, assumptions, and unresolved questions.
6. Use Design Mode for targeted edits. Select the exact elements and preserve the existing design system.
7. Test after every accepted step. Commit frequently so the next change is reversible.
8. Deploy to preview. Run browser, mobile, accessibility, data, and error-path checks against the preview URL.
9. Promote deliberately. Review diff, logs, secrets, database migration, and rollback before production.

Security and Permission Lessons

• Never expose permanent provider keys in chat or client code.
• Keep production credentials unavailable during exploratory runs.
• Use development Convex deployments and least-privilege MCP access.
• Require approval before deploys, migrations, deletions, purchases, or external communication.
• Inspect generated dependencies and lockfiles before installation or release.
• Test voice privacy, recording consent, retention, and deletion behavior.
• Store screenshots and test logs as evidence, not just a model-written completion message.

What the Demo Proves and Does Not Prove

It demonstrates that Grok 4.5 can work quickly across heterogeneous tasks inside Cursor and that Canvas plus Design Mode produces a fluid human-agent editing loop. It also demonstrates that the model can assemble credible prototypes involving Swift, realtime voice, web interfaces, Convex, and Vercel.

It does not prove the applications are production-ready, secure, accessible, maintainable, or fully correct. It does not benchmark Grok against Opus with identical prompts and scoring. It does not establish database durability, multi-user behavior, voice reliability, or safe deployment. The visible failures are part of the result, not footnotes.

What Builders Should Test First

1. Canvas: turn a real internal research brief into a sourced, reviewable artifact.
2. Design Mode: make five precise changes to an existing local UI and verify the mobile result.
3. Convex: add one persisted feature on a development deployment with schema and rollback.
4. Voice: build a narrow push-to-talk prototype before attempting full duplex and interruption.
5. Model comparison: run the same accepted task through Grok base, Grok fast, and your current default, then compare total repair and review cost.

Sources

• Riley Brown: Grok 4.5 + Cursor Just Became Unstoppable
• Riley Brown on X
• Cursor: Introducing Grok 4.5
• Cursor: Canvas Design Mode and Context Usage Report
• Cursor: Direct agents with visual prompts in Design Mode
• SpaceXAI: Introducing Grok 4.5
• SpaceXAI API pricing
• SpaceXAI Voice Agent API
• SpaceXAI Voice REST and realtime reference
• Convex: Using Cursor with Convex
• Convex database overview
• Vercel