Gemini 4 Argon benchmarks explained for people who don't read benchmarks

Google announced Gemini 4 Argon on 30 September 2026, and the blog post reads like most AI launches: a page of percentages, model names and test names most of us have never heard of. Can and I are designers. We wanted to know what the numbers mean, and we wanted a way to show them to people without making another slide deck.

So we did 2 things. We gave the post to Claude Opus 5.5 and asked for an animated explainer, with 1 prompt. Then we checked what we said on camera against the sources. 3 things changed. The index I called the "Walls Index" is the Vals Index. The legal benchmark gap is bigger than I said. And the music in our animation probably makes it harder to learn from.

What is Gemini 4 Argon?

Gemini 4 Argon is the first model in Google's Gemini 4 family. Google pitches it at long, multi-step work: software engineering, finance, legal drafting and cybersecurity. It can write up to 1 million tokens in one answer, up from 64,000 on earlier models, according to Google's announcement (30 September 2026).

The introductory API price is $2 per million input tokens and $10 per million output tokens. Google says this goes up to $4 and $20 later, and hasn't said when. Independent tester Artificial Analysis puts Argon level with GPT-6 Astra on its Intelligence Index, at 60% of the cost per task at the current price (Engadget, 30 September 2026).

Gemini 4 Argon benchmarks: where it wins and where it loses

In the video I said Argon wins everything except ML engineering, science and maths. That's close, and it's missing a part. Argon also trails on some coding tests.

The wins:

• Harvey's Legal Agent Benchmark: Argon 19.6%, GPT-6 Astra 5.4%, Claude Opus 5.5 3.8% (DataCamp). I said the gap was around 12%. It's 14.2 points, and Argon's score is more than 3 times Astra's.
• GraphWalks (long-context reasoning): Argon 99.7%, GPT-6 Astra 98.7%, Claude Fable 5.1 91.4%, Opus 5.5 90.6% (SiliconANGLE, 30 September 2026).
• DeepSWE v1.1 (real-world software tasks): 77.9%, according to Google.

The losses, from VentureBeat:

• FrontierSWE v2: Argon 55.0%, GPT-6 Astra 65.5%
• Terminal-Bench Science 0.1: Argon 57.6%, GPT-6 Astra 68.1%
• Terminal-bench 4.0: Argon 57.4%, Opus 5.5 66.4%
• PostTrainBench: Argon 45.3%, Opus 5.5 49.3%

One thing on the Harvey number. Every model fails most of that test. A 19.6% score means the model met the criteria on about 1 in 5 legal tasks. It's a lead, and it's still nowhere near handing a contract over unsupervised.

How big is a 1% difference on an AI benchmark?

This was our honest question in the video, so we went and read about it.

Near the top of a test, look at the errors. On GraphWalks, Astra gets 1.3% wrong and Argon gets 0.3% wrong. Out of 1,000 tasks, that's 13 mistakes against 3. A 1-point gap in the score is a 77% drop in errors. If a company runs a model millions of times a day, that difference is real money and real cleanup work.

There's a catch. Once scores pass about 90%, the remaining questions are often the ambiguous or badly written ones. At that point a 1-point gap can be noise, a model getting lucky on edge cases (The Neural Base). Evan Miller at Anthropic argued in a November 2024 paper that labs should publish error bars with every score, because most results are a single number with no sense of how much it would move if you ran the test again. Launch posts, Google's included, rarely show them.

My reading for designers: a 1-point gap near 100% can matter a lot or not at all, and the launch post alone doesn't tell you which. A 14-point gap on a hard test like Harvey's is much harder to explain away.

What does the Vals Index measure?

I called it the "Walls Index" on camera. It's the Vals Index, from Vals AI. It's a single score for a model's potential economic impact. It tests agents on finance, coding, legal and tax tasks, and weights each sector by its share of US GDP, using Bureau of Economic Analysis data. The latest update was 29 September 2026, with 30 models tested.

The weighting is the interesting part. A model that's brilliant at a small sector and average at a big one scores lower than the reverse. Google says Argon leads it.

Who can use Gemini 4 Argon, and when?

Most of us can't, yet. Argon goes first to security teams in Google's Fairwind Program, which opened on 3 September with a smaller model and now has more than 650 organisations, including CrowdStrike and Palo Alto Networks (SiliconANGLE). Those testers get a version without the cyber guardrails, so they can use it to find and patch vulnerabilities. Wiz has already used it to find a critical bug in healthcare software.

Next come paid API customers and Google AI Ultra subscribers, "as soon as possible", with no date. In the video I mentioned Accenture and McKinsey as testers. I couldn't find a source that confirms that, so treat it as unconfirmed.

How to turn a tech announcement into an animated explainer with 1 prompt

This is what we did, step by step.

1. Pick 1 source. We used only Google's blog post. More sources give the model more chances to mix up numbers.
2. Give it a motion library. We pointed Opus 5.5 at a set of animation skills on our GitHub. Without them, the output looked much more generic.
3. Ask for the key points only. Our prompt asked it to turn the technical language into something like a presentation, not to explain everything.
4. Name the audience. Say who will watch it: a client, a boss, a team outside design.
5. Run it once, on high effort, and wait. Ours took about 90 minutes. We didn't send follow-ups.
6. Check every number against the source. The model reads the post for you. You still present it.
7. Decide on the music last. See the next section.

The full prompt

This is the exact prompt we used, ready to copy. It uses our free 02ui-video-copy skill on GitHub. It also asks for a CLAIMS.md file, so every number on screen has a quote from Google's page next to it. The blind rule is there because we gave the same prompt to other models for a side-by-side test.

Make a 30–60 second launch video for Gemini 4 Argon, and make it as beautiful as you can.

Why: this video goes into a YouTube video for a large audience. It plays side by side with three other frontier models that got this identical prompt. Viewers judge craft: motion, type, rhythm and sound. The best video is the one a motion designer would believe a human studio made.

### The blind rule
The comparison is blind. Never put your own model name, your company's name, or any hint of which AI made it anywhere in what you build: on-screen text, credits, page title, file names, folder names, code comments or file metadata. Gemini 4 Argon and Google appear in the video because they are its subject. That is the only exception.

### The skill: follow it step by step
1. Clone https://github.com/02ui/02ui-video-copy into `.claude/skills/02ui-video-copy` in this folder. Set `S=.claude/skills/02ui-video-copy/scripts`.
2. Read, in full and in this order, before you write any code: `SKILL.md`, `references/motion-feel.md`, `references/living-stills.md`, then the one type file you pick.
3. Use **Original mode** (there is no reference video). Follow its steps: pick the category, measure 1–3 donor videos, write the script, write BREAKDOWN.md, make 3 storyboard variants, build in HyperFrames, render, review, fix. End with step 7 (LESSONS.md).

### The source
Every word, number and product name in the video comes from Google's launch page:
https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon/
Before you write the script, make `CLAIMS.md`: one row per on-screen claim, with the exact quote from the page next to it. If a claim has no quote, it does not go in the video. Never invent a feature, a stat or a benchmark.

### Motion: use the repo's tools on every round
- Copy `lib/motion.js` into `hf/` and build every moving value with it. Draw everything as a pure function of the frame. Use no CSS transitions, no timers and no Math.random.
- Give each role its own easing. Do not use one ease for everything:
  - entrances: `E.out4` or `E.expoOut`, 25–35 frames at 60 fps
  - exits: `E.in3`, shorter than the entrance
  - camera: `path()` with `E.io3`, so it never stops at a middle key
  - anything that settles: `spring()`, with the shot length sized from `springFrames()`
  - big zooms: `logScale()`
  - groups: `stagger()` with jitter, so no two items start on the same frame
- Each shot cuts in ON motion (`cutIn()`). There is no ease-in from zero after a cut.
- Nothing is ever fully frozen. Still elements get `wobble()` or `drift()` at a level the eye feels but does not notice.
- Run every render with `LINT=original $S/round_mb.sh` (or `round.sh` for drafts). Fix every motionlint ERROR before you render again.
- After every render, run `python3 $S/rhythm.py <render-analysis> --donor <each donor analysis> -o RHYTHM.md`. Fix every flag, or write in LOG.md why it is deliberate.

### Rhythm and type
- Pick the BPM first and put every cut on the beat grid in BREAKDOWN.md (frames, not seconds).
- Vary shot length: short punches around one long hero shot. Shot lengths must not all be equal.
- Reading time: every text hold lasts at least 0.3 s per word plus 0.6 s.
- Show the biggest outcome in the first 3 seconds. Do not open with a logo. Show, do not explain.
- Use 1 display face and 1 text face, loaded from font files, with tracking and sizes set on purpose. Never use a default system font.

### Banned (the generic AI-video look)
No glassmorphism or frosted panels, no cards sliding up from below, no gradient blobs, no stock HyperFrames or Remotion template look. Test every shot: if it could appear in any AI launch video, rebuild it. Use code-drawn motion graphics, shaders, generated plates (an image generator is provided) and 3D only where they make the shot better.

### Sound
Make the music and the sound design with ElevenLabs (SKILL.md step 6). Place every sound to the frame. Finish at -14 LUFS with true peak under -1 dBTP.

### Format
1920x1080, 60 fps, 30–60 seconds, with sound. Render the final with real motion blur (`round_mb.sh`), never with a CSS blur.

### Deliver, in this folder
- `final.mp4`
- `hf/`, the HyperFrames project that renders it
- `storyboard/`, the stills of all 3 variants, and the one you picked with the reason
- `BREAKDOWN.md`, `CLAIMS.md`, `RHYTHM.md`, `LOG.md`, `LESSONS.md`

### Working rules
Work end to end without asking me questions. Do not ask permission for steps you can undo. Stop only for something destructive or irreversible. Stop after 6 render rounds and report what is still off.

### DONE when all of these are true
- `final.mp4` renders from `hf/` and plays start to finish with sound.
- Every on-screen claim has a matching quote in CLAIMS.md.
- motionlint with `--original` reports 0 errors.
- rhythm.py reports 0 flags that LOG.md does not explain.
- A final review pass, with only one job (find any shot that looks like a generic AI launch video), finds none.

When you finish, start your report with the outcome: the length, the shot count and the remaining issues. The details come after.

Does animation explain better than slides?

Partly yes. Tim Höffler and Detlev Leutner pooled 26 studies in 2007 and found animation beats static pictures by a medium amount (d = 0.37). The gain was bigger when the animation shows the thing itself rather than decorating it (d = 0.40), and much bigger for teaching a process (d = 1.06). A bar that grows from 5.4 to 19.6 shows the gap. That's the kind of motion that helps.

Here's the correction for us. Richard Mayer's coherence principle says people learn better when extra material is cut, and that includes background music. In 13 of 14 tests, the shorter, cleaner version won, with a median effect size of d = 0.97 (Mayer, Cambridge University Press). Our animation has music. It makes the video feel finished. For a client pitch where you want the numbers to stick, the research says turn it off.

His signalling principle helps us: cues that show the structure, like headings and arrows, improved learning in 24 of 28 tests (Mayer, 2008). Animated labels that appear in order do exactly that.

What we take from this

What stays with me is how little of this needed us to be motion designers or engineers. We needed to be honest about what we didn't understand, and then go and check. The model did the drawing. The checking was still our job, and it changed 3 things we said on camera.