JS Wei (Jack) Sun

Gemini Hydrogen lists 15× Haiku, IBM bakes LLMON tokens, TRELLIS freezes texture

A premium Gemini tier, a tokenizer-level prompt-injection defense, and a frozen-DiT 3D LoRA ship on the same day without a shared thread.

Gemini Hydrogen lists 15× Haiku, IBM bakes LLMON tokens, TRELLIS freezes texture

TL;DR

  • Gemini 4 Hydrogen lists at $1.50/$7.50 per M tokens, 15× Claude Haiku 5.5 and GPT-6 Luna.
  • Hydrogen burns 1.8× more output tokens than Carbon, producing 3–4.5× bills at the same list price.
  • IBM’s LLMON bakes 6 reserved tokens into Granite 4.1, avoiding 47% more prompt-injection attacks than frontier peers.
  • Granite 4.1 8B preview trails standard Granite on GPQA (35.05) and DeepMind Math (70.86), contradicting IBM’s parity claim.
  • TRELLIS.2 LoRA lifts geometry F-score 0.276→0.803 by freezing Texture Flow DiT, trained in 11 hours on one A100.

Three AI tech launches today don’t share a thread — they share a release day. Google’s Gemini 4 Hydrogen lists at $1.50/$7.50 per million tokens, 15× Claude Haiku 5.5, and burns ~1.8× more output tokens than Carbon on the same prompt; the Antigravity Orchestrator is Google’s own workaround, pairing a Carbon planner with a Hydrogen executor to claw back 24% of quota. IBM’s LLMON hard-codes six reserved single tokens into Granite 4.1’s vocabulary to blunt prompt injection, cutting attack success 47% below frontier peers — though the same 8B preview regresses on GPQA and DeepMind Math against standard Granite. And a Microsoft group’s TRELLIS.2 LoRA recipe triples geometry F-score on held-out shoes by freezing the Texture Flow DiT entirely, a workaround only possible because Google Scanned Objects ships baked-lighting diffuse color instead of PBR.

Gemini 4 Hydrogen launches 15× pricier than Claude Haiku

Source: simon-willison · published 2026-11-12

TL;DR

  • Hydrogen lists at $1.50/$7.50 per M tokens — 15× Claude Haiku 5.5 and GPT-6 Luna at $0.10/$0.50.
  • Carbon burns ~1.8× more output tokens than Argon on the same prompt, producing 3–4.5× bills at identical list prices.
  • Hydrogen scores 57% on Terminal-Bench 4.1, more than tripling Gemini 3.8 Flash’s 18.2%.
  • Google’s Antigravity Orchestrator pairs Carbon planner + Hydrogen executor for Carbon-quality output at 24% lower quota.

The pricing table doesn’t make sense until you squint

Google’s Gemini 4 launch ships three models — Carbon, Argon, Hydrogen — with a pricing scheme Simon Willison calls “really confusing,” and he’s right. Carbon and Argon are listed at identical rates ($2/$10 now, $4/$20 after December 1). Hydrogen, nominally the cheap tier, is only 25% below its frontier siblings today, widening to a 75% discount once the promotional window closes.

The headline grievance from Willison: at $1.50 input / $7.50 output per million tokens, Hydrogen is 15× the list price of Claude Haiku 5.5 and GPT-6 Luna, both at $0.10/$0.50. For a model Google positions as the “fast, disciplined execution engine” for writing code and running tests — the exact workload Haiku and Luna target — that’s a hard number to defend.

Token-burn makes the gap worse, not better

Community telemetry sharpens the pricing complaint rather than softening it. A widely-shared r/ChatGPTCoding breakdown shows Carbon emitting roughly 1.8× more output tokens than Argon for the same task, translating to 3–4.5× bills at identical per-token prices 1. That’s the real answer to Willison’s “why have two models at the same price” question: Argon is the same model tuned to shut up sooner.

That same inefficiency haunts Hydrogen. An r/GoogleGemini thread documents a “Google tier of inefficiency” where Gemini models burn enough extra tokens per task that a single job can run 6.1× more expensive than GPT-6 Sol or Anthropic Fable equivalents despite lower list prices 2. The 15× list-price gap to Haiku is the floor, not the ceiling.

The one asterisk on the Haiku comparison

Willison’s 15× line deserves one piece of missing context. Claude Haiku 5.5 carries a hard pricing cliff at 100K tokens: cross that threshold and the entire request reprices at $0.50/$2.50 — a 5× jump 3. Hydrogen’s flat $1.50/$7.50 across its 1M-token window narrows the gap considerably for long-context agent work. It does not close it, but it means the comparison isn’t apples-to-apples for every workload.

Benchmarks and the Orchestrator reframe

Outside Willison’s pelican SVG test, Hydrogen’s hard numbers are stronger than the post implies. VentureBeat reports 57% on Terminal-Bench 4.1 versus 18.2% for Gemini 3.8 Flash — more than tripling the predecessor on a serious agentic eval 4. And Google’s new Antigravity Orchestrator, which routes planning to Carbon and execution to Hydrogen, hits Carbon-only quality with 24% lower quota consumption and 19% faster completion 5.

That reframes the awkward 25% launch discount: Hydrogen isn’t priced to compete head-to-head with Haiku. It’s priced to be the subordinate worker inside Google’s own orchestration graph, where the economics only pencil out if you’re already committed to Carbon as the planner.

Free-tier friction

The “Hydrogen powers Search AI and the free tier” story has cracks. Notebookcheck reports free-app users complaining that auto-model-selection downgrades most prompts to Flash-Lite rather than actually routing to Hydrogen, producing inconsistent quality 6. If you’re not paying, you’re probably not getting the model Google is marketing.

Willison’s llm-gemini 0.37 lets you bypass all of that from the CLI and address Carbon, Argon, and Hydrogen directly at three effort levels — which, given the routing opacity, is where serious evaluation should happen anyway.


IBM’s LLMON hardens Granite 4.1 against prompt injection

Source: huggingface-blog · published 2026-11-12

TL;DR

  • IBM shipped LLMON, a markup format replacing JSON brackets with six reserved single tokens baked into Granite 4.1’s vocabulary.
  • Granite 4.1 LLMON previews avoided 47% more attacks than frontier models on the OPI prompt-injection benchmark.
  • Defense is learned behavior, not a sandbox, leaving adaptive jailbreaks open at 3B/8B preview scale.
  • The 8B preview trails standard Granite on GPQA (35.05) and DeepMind Math (70.86), contradicting IBM’s parity claim.

A markup language that lives in the tokenizer

IBM’s pitch for LLMON (LLM Object Notation) is that JSON was never designed for models. Brackets, quotes, and commas are made of ordinary characters a transformer has to count across long contexts — and that any attacker can also type into a retrieved document. LLMON replaces them with six reserved single-token delimiters (<|open|>, <|:|>, <|close|>, etc.) added directly to Granite 4.1’s vocabulary, so structure becomes unspoofable by subword composition.

The load-bearing idea is the execution block: two-character block IDs bind instructions to the specific data payloads they’re allowed to act on. Anything not bound inside an exec block — retrieved documents, tool outputs, user-supplied material — is tagged as passive “material to read,” not commands to follow. During post-training, IBM deliberately salted the data with unbound decoy instructions so the model learned to ignore them, then ran five GRPO stages and a DPO pass on preference pairs sourced from real injection attempts.

flowchart LR
    U[User prompt] -->|bound in exec block| X{{Granite 4.1 LLMON}}
    T[Tool output] -->|unbound: data channel| X
    D[Retrieved doc] -->|unbound: data channel| X
    X -->|executes| A[Authoritative action]
    X -. ignores decoy instructions .-> I[/Injected commands/]

The security numbers, and their asterisks

On the Over-the-shoulder Prompt Injection (OPI) benchmark, LLMON-equipped Granite models scored near-perfect robustness, avoiding 47% more attacks than tested frontier models and 95% more than open-source peers. Similar gains appeared on ASB and StruQ.

Two caveats matter. First, LLMON’s privilege separation is a training-time property, not an architectural one. As n1n.ai puts it, this is “learned behavior rather than an enforced guarantee” — adaptive jailbreaks could still confuse structural boundaries, a risk amplified by the preview being capped at 3B and 8B 7. The natural contrast is Google DeepMind’s CaMeL, which splits a Privileged LLM from a Quarantined LLM and tracks capabilities in a Python interpreter; CaMeL held 77% task success vs 84% undefended on AgentDojo with provable guarantees 8. IBM’s ASR number is better, but it comes from a single model trusting itself.

Second, OPI itself has critics. The public harness “appends malicious payloads to every non-final observation,” which inflates baseline attack success rates relative to realistic one-shot threats 9. Treat the 47%/95% gaps as directional, not head-to-head.

LLMON isn’t the first channel-separation attempt either. Berkeley’s StruQ used [INST]/[INPT] delimiters plus fine-tuning and already drove injection ASR near zero in its paper 10. The novelty here is pushing those delimiters into the vocabulary rather than the character stream.

The capability tax nobody advertises

IBM claims LLMON models perform “on par with standard Granite 4.1 Instruct.” Independent benchmarks suggest otherwise: the 8B preview reportedly scored 35.05 on GPQA and 70.86 on DeepMind Math, trailing the vanilla Instruct variants, and testers describe it as “rigid” because it refuses to infer when instructions aren’t explicitly bound 11. That rigidity is arguably the feature working as designed — but it’s a tradeoff, not a free lunch.

The sleeper feature

The injection story will get the headlines; structured output may drive adoption. Third-party testing reports 15–30% fewer tokens than equivalent JSON and a parsing error rate under 2% at 3B, versus 8–12% for similarly sized JSON generators 12. Every agent builder feels JSON brittleness daily. A tokenizer-native format that round-trips losslessly (IBM ships an LLMON-converters library for JSON interop) and parses cleanly at 3B is the kind of quiet infrastructure win that outlasts a benchmark cycle.

What LLMON still owes the field: an adaptive-attack evaluation at scale, and a larger model to prove the learned boundaries hold under real pressure.


TRELLIS.2 LoRA freezes texture, triples geometry F-score

Source: huggingface-blog · published 2026-11-12

TL;DR

  • F-score jumps 0.276 → 0.803 on held-out GSO shoes after LoRA adapters are added to just two geometry stages.
  • Texture Flow DiT stays frozen because Google Scanned Objects ships diffuse color with baked lighting, no PBR maps.
  • ~9.3M trainable parameters (rank 8 + rank 16) finish training in ~11 hours on a single A100-80GB.
  • Recipe is bounded by GSO’s “breadbox” rig — sub-50 cm, rigid, Lambertian objects only.

The numbers are real, and they’re about geometry

Hugging Face’s new TRELLIS.2 LoRA guide reports a jump from 0.276 to 0.803 on F-score@0.02 after fine-tuning on 179 shoes from the Google Scanned Objects (GSO) dataset, with Chamfer distance falling from 0.174 to 0.033 and normal consistency rising from 0.530 to 0.804 13. Those are not marginal gains — they are the difference between a generic blob with a shoe silhouette and a mesh whose sole treads line up with the reference scan. The adapters add roughly 9.3M trainable parameters against a frozen base, split rank-8 on the Sparse-Structure Flow DiT and rank-16 on the Shape Flow DiT, and train in about 11 GPU-hours total on an A100-80GB 13.

Why the texture head had to stay frozen

The more interesting decision is what the authors didn’t train. TRELLIS.2’s Texture Flow DiT predicts base color, metallic, and roughness channels — a physically based rendering (PBR) stack. GSO can’t supervise that. Google’s original release captured objects with DSLR photography under controlled lighting, producing diffuse surface color with illumination already baked in, not the roughness/metallic/normal maps a PBR head expects 1415. The dataset is also explicitly biased toward “rigid, opaque, Lambertian-like surfaces,” which excludes most of what makes a real shoe visually interesting: mesh uppers, patent leather, translucent rubber 16.

So the quote the guide ends on — “choosing what to freeze matters as much as choosing what to fine-tune” 13 — is less a general aphorism than a description of the only move available. The dataset’s affordances dictated the adapter placement. Anyone wanting to also adapt texture needs a different corpus (ABO, Objaverse-XL subsets, or captured PBR scans).

The pipeline, and where adapters land

flowchart LR
    I[Input image] --> P[BiRefNet<br/>bg removal]
    P --> E[DINOv3-L<br/>encoder]
    E --> S[Sparse-Structure<br/>Flow DiT ★]
    S --> G[Shape Flow DiT ★<br/>512³ O-Voxel]
    G --> T[Texture Flow DiT<br/>frozen ❄]
    T --> O[GLB / PLY /<br/>NeRF / 3DGS]
    style S fill:#ffd
    style G fill:#ffd
    style T fill:#dde

LoRA adapters attach to the two starred DiTs; the texture stage is untouched. Everything upstream — BiRefNet background removal, the DINOv3-L image encoder — is also frozen, so the encoder’s priors on general object appearance carry over to footwear without catastrophic forgetting.

Where the recipe stops working

Two caveats temper the F-score. First, GSO’s scanning rig is constrained to objects “roughly the size of a breadbox” 14, so the same recipe won’t transfer unchanged to furniture, vehicles, or industrial parts. The 9 held-out objects used for evaluation are drawn from the same shoe distribution as training; generalisation to in-the-wild product photography is not demonstrated. The original GSO authors framed the dataset as a sim-to-real resource for robotics 17, not as a generative-model training set — the 188-asset footwear slice is being pushed beyond its design intent, even if it works.

Second, reproducibility has rough edges upstream. TRELLIS.2 issue #138 reports that fine-tuned checkpoints don’t emit .safetensors shards in the layout the inference loader expects, requiring manual surgery before adapters can be served 18. The guide’s Docker images and Hugging Face Jobs scripts 13 paper over this plumbing — a meaningful contribution precisely because the base repo gets it wrong — but anyone running the recipe outside HF Jobs should budget time for the packaging friction.

The takeaway isn’t “LoRA works for 3D.” It’s that in 3D generation, your dataset chooses your adapter topology before you do.

Footnotes

  1. Reddit r/ChatGPTCoding — ‘Same price per token, 3-4.5x the bill’ — https://www.reddit.com/r/ChatGPTCoding/comments/1xtlk8o/same_price_per_token_345x_the_bill_gemini_4/

    Carbon produces roughly 1.8x more output tokens than Argon for the same tasks… total cost for a single task can be 3 to 4.5 times higher than on Argon for simpler queries.

    ↩
  2. Reddit r/GoogleGemini — https://www.reddit.com/r/GoogleGemini/comments/1xumqwo/hydrogen_is_2x_more_expensive_than_38_and_about/

    Google tier of inefficiency, where Gemini models frequently burn significantly more tokens per task than OpenAI’s GPT-6 Sol or Anthropic’s Fable series, potentially making a single task 6.1x more expensive than competitors despite lower per-token list prices

    ↩
  3. Medium — ‘Claude Haiku 5.5 is 90% cheaper… until your prompt hits 100K tokens’ — https://medium.com/@chinmayshringi4/claude-haiku-5-5-is-90-cheaper-until-your-prompt-hits-100k-tokens-bb2d3f111ce8

    crossing the 100,000-token threshold triggers a five-fold price increase to $0.50 and $2.50 for the entire request

    ↩
  4. VentureBeat — ‘a faster, smarter, pricier Flash successor’ — https://venturebeat.com/technology/google-launches-gemini-4-hydrogen-a-faster-smarter-pricier-flash-successor

    Hydrogen reaching 57% [on Terminal-Bench 4.1], more than tripling the performance of its predecessor [Gemini 3.8 Flash at 18.2%]

    ↩
  5. Unite.ai — Antigravity Orchestrator rollout — https://www.unite.ai/google-antigravity-rolls-out-orchestrator-for-dynamic-model-handoffs/

    the Orchestrator achieved success rates comparable to using the flagship Carbon model alone, but with 24% lower quota consumption and 19% faster completion times

    ↩
  6. Notebookcheck — ‘What free users and Google AI Plus get’ — https://www.notebookcheck.net/Gemini-4-Hydrogen-What-free-users-and-Google-AI-Plus-get.1449493.0.html

    some free users have complained that the ‘auto selection’ logic frequently downgrades them to Flash-Lite, leading to inconsistent response quality

    ↩
  7. n1n.ai analysis — https://explore.n1n.ai/blog/ibm-granite-llmon-prompt-injection-security-2026-11-13

    the defense is a ‘learned behavior’ rather than an ‘enforced guarantee’ … critics argue that sophisticated adversarial jailbreaks could still potentially confuse the model into crossing these structural lines, especially as the technology is currently restricted to smaller 3B and 8B parameters

    ↩
  8. af.net (CaMeL comparison) — https://af.net/realtime/ibm-granite-releases-experimental-llmon-models-to-thwart-indirect-prompt-injections/

    CaMeL separates privileges between two distinct model instances [via a Privileged LLM and Quarantined LLM]; LLMON teaches a single model to enforce ‘execution binding’ … CaMeL solved 77% of tasks with provable security, a slight dip from the 84% achieved by an undefended system

    ↩
  9. nhimg.org on OPI benchmark — https://nhimg.org/faq/why-do-public-prompt-injection-benchmarks-become-unreliable-over-time/

    the released OPI harness artificially inflates attack success rates by appending malicious payloads to every non-final observation, rather than injecting a single strategic payload into a specific tool output

    ↩
  10. DeepInspect on Spotlighting/StruQ — https://www.deepinspect.ai/blog/spotlighting-prompt-injection-defense

    StruQ enforces a strict ‘two-channel’ separation between instructions and data using special delimiters like [INST] and [INPT] … reducing prompt injection success rates to near zero in benchmarked scenarios

    ↩
  11. ExplainX benchmark breakdown — https://explainx.ai/blog/ibm-granite-llmon-markup-language-preview-2026

    the 8B preview scored lower on GPQA (35.05) and DeepMind Math (70.86) compared to the standard Granite 4.1 Instruct variants … developers have characterized the models as ‘rigid’ and ‘slower,’ noting they lack the ‘magic’ of general-purpose models because they refuse to make inferences where instructions are ambiguous

    ↩
  12. n1n.ai (structured output analysis) — https://explore.n1n.ai/blog/llmon-granite-4-1-structured-llm-outputs-2026-11-13

    Reports indicate a 15% to 30% reduction in token consumption compared to JSON … the 3B model demonstrated a parsing error rate below 2%, whereas similarly sized models often see 8% to 12% failure rates when generating complex JSON

    ↩
  13. Hugging Face blog — 3D LoRA Fine-Tuning guide (primary) — https://huggingface.co/blog/3d-lora-finetuning

    Choosing what to freeze matters as much as choosing what to fine-tune.

    ↩ ↩2 ↩3 ↩4
  14. Google Research blog — Scanned Objects dataset announcement — https://research.google/blog/scanned-objects-by-google-research-a-dataset-of-3d-scanned-common-household-items/

    The dataset consists of over 1000 3D-scanned household items… captured with a custom scanning rig constrained to objects roughly the size of a breadbox.

    ↩ ↩2
  15. arXiv 2204.11918 — Google Scanned Objects paper (HTML) — https://arxiv.org/html/2204.11918v1

    Our pipeline captures diffuse surface colour using DSLR photography under controlled lighting; it does not produce the roughness, metallic or normal maps required for physically based rendering.

    ↩
  16. arXiv 2204.11918 abstract — Google Scanned Objects — https://arxiv.org/abs/2204.11918

    The dataset is biased toward rigid, opaque, Lambertian-like surfaces, limiting its utility for training models of specular, transparent, or deformable objects.

    ↩
  17. ResearchGate — Downs et al., ‘Google Scanned Objects’ (ICRA 2022) — https://www.researchgate.net/publication/360216542_Google_Scanned_Objects_A_High-Quality_Dataset_of_3D_Scanned_Household_Items

    We expect these models will enable a wide range of robotics and computer vision research, including sim-to-real transfer, where high-quality 3D models with realistic physical properties are needed.

    ↩
  18. GitHub — microsoft/TRELLIS.2 issue #138 — https://github.com/microsoft/TRELLIS.2/issues/138

    After fine-tuning the checkpoint folder structure doesn’t match what the inference pipeline expects — the .safetensors shards aren’t produced in the layout the loader needs.

    ↩
Jack Sun

Jack Sun, writing.

Engineer · Bay Area

Hands-on with agentic AI all day — building frameworks, reading what industry ships, occasionally writing them down.

Digest
All · AI Tech · AI Research · AI News
Writing
Essays
Elsewhere
Subscribe
All · AI Tech · AI Research · AI News · Essays

© 2026 Wei (Jack) Sun · jacksunwei.me Built on Astro · hosted on Cloudflare