An assistant sold on stamina rather than wit. Hand it a job that needs dozens of rounds and it splits the steps, checks its own output and delivers, and along the way it has quietly taken over writing code as well.

Most assistants work in single exchanges — you ask, it answers, and then you take the work back. Hand over a whole piece of it and you end up watching, because by the fifth or tenth step it forgets the original constraint, or goes round and round inside one error message.

This release aims at that stretch. The announcement is unusually direct about the positioning: built on the previous model, with a particular focus on long-running agents, plus more ambitious interactive and visual work.

Dozens of rounds without you stepping in

The old failure of long tasks has a name, context degradation: after the fifth or tenth tool call the model starts dropping the original constraints, repeating the same mistake, or forgetting what the request even was. The approach here is to make it audit itself before acting. It surveys the structure of the codebase, its architectural conventions and type definitions, breaks the requirement into separately verifiable subgoals, makes precise edits to the target files, then runs the local tests, reads the stack trace, corrects itself, and only then continues. Over longer trajectories the team reports a shift: this version produces noticeably more self-testing and self-verification, checking whether what it just did was right before moving on.

Its stronger use is turning one broad sentence into a first version that runs. The announcement is specific about it: give the model an unfamiliar product direction and it studies the field, scaffolds the application, implements the core interaction, then keeps revising across several rounds of feedback. On visual and interactive projects the first draft is, by the team's account, clearly better than the previous generation — one concrete idea is enough for it to establish structure and visual language in a single pass.

Running longer also costs more, so the economics deserve their own paragraph. By the official figures a long-horizon task averages around fifty-three rounds and roughly five hundred million input tokens, measured at about eighty-four cents per task. API pricing is two dollars per million input tokens and six per million output, and cached input falls to fifty cents per million. The context window stays at 500K tokens rather than growing, the stated intent being to spend the budget more precisely instead of leaning on a bigger window.

The part that takes coding away

The coding work itself belongs to Grok Build, an agent made for that scene, with a panel for running several sessions in parallel so multiple jobs advance at once. It was usable on release day, with double quota for the first week. One detail is worth remembering: when you orchestrate it through the API or an editor's rules, put the verification requirement into the instruction — ask it explicitly to run a static type check and the unit tests before proposing a file write — and the internal self-verification loop fires at full strength.

Real time is the part that needs no explanation

The other main line is live information. Search reads the open web and the public social timeline at the same time, and the answers cite primary sources rather than last year's training data. Ask about something happening right now and the relevant posts are embedded in the reply with their engagement figures, so you can keep pulling at that thread.

Not only chat: files, images and voice in one box

It works fine as an everyday assistant. Documents, spreadsheets, code and audio can all be uploaded for summarising, extraction or explanation. An image can be part of the question itself — send one and ask what it says, and it reads the content before continuing, instead of talking around the picture in generalities.

Voice is the other solid piece: round trips come in under a second and you can cut in mid-sentence instead of waiting for the reply to finish. Image and video generation happen in the same conversation, up to 2K resolution and fifteen seconds. Dozens of languages, memory across conversations and a canvas for long-form editing round it out.

Key facts

The developer is xAI. Platforms are web, iOS and Android. The model line and the phone app follow separate tracks, so the digits in a store listing have nothing to do with the model release. The context window is 500K tokens; the coding agent is Grok Build with parallel sessions; API pricing is two dollars per million input tokens and six per million output, fifty cents when the cache hits. There is a free tier with a capped allowance, SuperGrok costs about thirty dollars a month and SuperGrok Plus about a hundred, with team and enterprise plans above that. The main product is closed source.

How far the free tier actually reaches

The free tier needs no card: sign in and it works, live search and voice mode included, but the allowance is capped and a heavy session meets the ceiling quickly. Above that sits SuperGrok at roughly thirty dollars a month for higher limits, more multi-agent reasoning and the features reserved for paid accounts, then SuperGrok Plus at about a hundred, adding video work and priority at peak times.

One trap is worth naming: the subscription and the developer API are billed separately. SuperGrok buys access to the consumer app; wiring the model into your own software runs on a different account entirely.

What this release sells is not being smarter but lasting longer. Hand over a job that needs dozens of rounds, keep your hands off it, and it arrives verified — with the code going to a companion agent and one task landing under a dollar, which is where it wants to be used.