---
type: "post"
id: "cost-per-task-using-cheap-classifiers-to-route-45b43e"
slug: "cost-per-task-using-cheap-classifiers-to-route-45b43e"
title: "Cost per task: Using cheap classifiers to route across Gemini models and thinking levels"
description: "Google describes a 50-question experiment using Jev, a lightweight classifier, to route coding-agent tasks between Gemini configurations."
retrieval_nugget: "Google describes a 50-question experiment using Jev, a lightweight classifier, to route coding-agent tasks between Gemini configurations. The reported results suggest that explicit low thinking may be a better first optimization than a router, while routing can help on short, standalone tasks when its accuracy and overhead are measured against a strong baseline."
published_at: "2026-11-04"
updated_at: "2026-11-04"
record_date: "2026-11-04"
date_kind: "published_at"
topics: ["google","gemini","coding-agents"]
entities: ["Google","Google Antigravity","Gemini 3.8 Flash","Gemini 3.1 Pro","TypeSafe Jev","DiffusionGemma"]
related_patterns: ["agent-economics-moves-to-completed-work"]
novelty_label: "new_fact"
what_changed: "Google describes a Jev classifier routing Gemini calls by task complexity, with a 50-question benchmark; the cited prior pieces discuss model routing generally but not this classifier, setup, or results."
prior_refs: ["memory:4b94e8f7-0bec-8796-aea8-4d86bb18a942","memory:1bf64c18-b949-89ba-aa02-0046ebc5d1c4"]
source_url: "https://developers.googleblog.com/cost-per-task-using-cheap-classifiers-to-route-across-gemini-models-and-thinking-levels"
source_urls: ["https://developers.googleblog.com/cost-per-task-using-cheap-classifiers-to-route-across-gemini-models-and-thinking-levels"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:cost-per-task-using-cheap-classifiers-to-route-45b43e"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/cost-per-task-using-cheap-classifiers-to-route-45b43e/","markdown":"https://newruntime.com/posts/cost-per-task-using-cheap-classifiers-to-route-45b43e.md","json":"https://newruntime.com/posts/cost-per-task-using-cheap-classifiers-to-route-45b43e.json"}
---

# Cost per task: Using cheap classifiers to route across Gemini models and thinking levels

## Retrieval answer

Google describes a 50-question experiment using Jev, a lightweight classifier, to route coding-agent tasks between Gemini configurations. The reported results suggest that explicit low thinking may be a better first optimization than a router, while routing can help on short, standalone tasks when its accuracy and overhead are measured against a strong baseline.

## Summary
Google describes a 50-question experiment using Jev, a lightweight classifier, to route coding-agent tasks between Gemini configurations. The reported results suggest that explicit low thinking may be a better first optimization than a router, while routing can help on short, standalone tasks when its accuracy and overhead are measured against a strong baseline.

## What happened
In a November 3, 2026 Google Developers Blog post, Google Cloud technical solutions author Sergio Villani presents a routing pattern for coding agents: use a lightweight classifier to decide whether a task can go to a cheaper, faster model configuration or should be escalated. The example uses TypeSafe’s Jev classifier in front of Google Antigravity model calls. Google says it has no partnership with TypeSafe and that Jev is an example, not an endorsement; it also points to Google-native classifier approaches, including a codelab using the open-weights DiffusionGemma model.

The post reports tests on 50 auto-graded coding-agent questions. A broad “simple or complex” classification prompt routed nearly everything to the simple path. Breaking the decision into one atomic yes-or-no question—whether a task requires more than one sequential calculation, simulation step, or deduction—improved the separation. Jev agreed with the hand labels on 13 of 16 initial tasks, then 14 of 16 on a second pass, and classified all 34 unseen tasks correctly. That brought its result to 48/50, or 96%, across the full suite. A keyword and prompt-length heuristic scored 15/16 on the 16 tasks used to devise it, but fell to 70.6% on the 34 held-out tasks.

Google also tested output limits as a supposed way to reduce reasoning expense. Setting Gemini 3.8 Flash’s maxOutputTokens to 300 instead of 4096, with thinking configuration left at its default, did not reduce thinking tokens on the 27 tasks Jev labeled simple. It cost slightly more on those tasks and caused seven of the 25 hard tasks to fail: six ran out of room while reasoning, and one returned a wrong answer. A router that sent easy tasks to the capped model and hard ones to normal Flash still cost slightly more and ran slower than normal Flash alone.

The more useful comparison was against lighter configurations. Gemini 3.8 Flash with thinking set to low solved all 50 questions without a router. Jev routing every task through Flash-Lite and escalating flagged complex tasks to Flash on low thinking also solved all 50. Google says this router can reduce cost and response time relative to running low thinking on every task, though the cost difference was small for these short prompts. Flash-Lite alone missed six of the 25 hard tasks; Jev flagged all six for escalation.

The post cautions that long-context agent workloads differ. Context caching can reduce the cost of resending repeated context by 75% to 90%, but a cache belongs to one model. Switching between Flash-Lite and Flash can require separate caches or forfeit the discount. Google therefore suggests routing short, self-contained jobs such as log parsing or schema checks, while keeping long context-heavy turns on one model. It also notes that Gemini 3.1 Pro may be a better fit for deep multi-step reasoning and that, in this run, Pro declined two short code-security review prompts that Flash answered.

## What the archive adds
This is a new fact on a known theme, not a repeat of a Gemini launch. Our earlier [Gemini 4 Carbon note](https://newruntime.com/posts/google-announces-gemini-4-carbon-with-cybersecurity-and-long-horizon-1d2789/) covered Google’s model capabilities; the current post instead offers a small, specific experiment in routing tasks across model configurations. An earlier channel post also argued that routing needs an evaluation loop and outcome traces, a concern this experiment addresses only partially through its small benchmark.

## Trend signal
The experiment supports the pattern that agent economics should be measured as cost per verified completed task, not token price alone: [Agent economics moves to completed work](https://newruntime.com/patterns/agent-economics-moves-to-completed-work/). Google’s results also show why the denominator matters: a cheaper path that misses tasks is not a saving, and a router can add overhead without improving on a well-chosen baseline.

## Why now
The post frames the problem as a production-economics issue: falling per-token prices do not guarantee lower bills when autonomous agents make repeated calls, retries, and reasoning passes. Its practical timing is therefore tied to teams choosing model settings and routing policies for deployed coding agents.

## Why it matters
For teams building agents, the post argues for testing the least expensive adequate configuration before adding orchestration. In this benchmark, low thinking solved every task and beat the premise that a router is always the route to savings. Where a router is justified, atomic classification questions and held-out tasks matter more than fitting a heuristic to a few examples.

The caching caveat is operationally important: routing across models can trade per-call savings against duplicated or lost context-cache discounts. A useful evaluation should therefore reflect real task lengths, shared context, retries, tool calls, and verification—not just isolated prompts. The reported 50-task result is a starting hypothesis for a team’s own workload, not evidence that Jev or this exact model pairing will generalize.

## Limits and uncertainty
The source reports one run per setup, 50 prompts, hand-assigned difficulty, and simple automatic grading. It does not establish performance on production coding agents, longer tasks, varied languages, or robust outcome verification. The reported Jev benchmark is not an independent comparison, and the blog’s author works at Google, whose models are part of the test. Cost and latency depend on prompt length, caching, and production load; the article says comparisons across its two test rounds are approximate. It gives no universally applicable break-even point for router cost versus savings.

## Skill to build now
Build a small held-out routing evaluation before deploying a classifier: collect representative short tasks, label which require multi-step work, and compare a no-router low-thinking baseline against a routed setup on correctness, latency, and total cost per accepted task. Keep long-context tasks separate in the analysis, because model switching can change cache economics. Do not treat a low output-token ceiling as a substitute for lowering thinking effort.

## Reader takeaway
Start with the cheapest configuration that passes your own verification, then prove that routing improves the full task economics. A classifier is useful only when its decisions generalize and the savings survive latency, retries, and context-cache effects.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Google](https://newruntime.com/topics/google.md): Explore the google topic hub.
- topic hub: [Gemini](https://newruntime.com/topics/gemini.md): Explore the gemini topic hub.
- topic hub: [Coding Agents](https://newruntime.com/topics/coding-agents.md): Explore the coding-agents topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Source Ledger](https://newruntime.com/source-ledger.json): Inspect the public source evidence graph.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)