Gemini Decision 1 vs Jev: Pricing, Latency, and Python Setup
Use Gemini Decision 1 for bounded multimodal decisions and benchmark Jev for text routing. Compare direct token prices and Artificial Analysis results, calculate shared-input costs, run a Python tool-selection example, and check quotas, confidence thresholds, and gateway differences.
Contents
Try Gemini Decision 1 for multimodal routing and many independent checks over one input. Keep Jev as your first text-routing baseline when latency and cost matter most. Use a generative model when the result needs code, explanations, arbitrary extracted values, or tool arguments.
Google launched Gemini Decision 1 on November 11, 2026. As of 2026-11-13, its Decisions API is available through the Gemini API, with Python support in google-genai 3.2.0 and later. It is a decision endpoint, not a replacement model for a coding chat session.
What does Gemini Decision 1 return?
Gemini Decision 1 scores predefined outcomes instead of generating an answer token by token. You supply shared input and up to 1,000 independent questions. The context window is 262,144 tokens, commonly described as 256K; keep the input and questions within that budget.
The Decisions API guide documents three question types:
| Type | Define in the request | Read from the answer |
|---|---|---|
noul | A yes/no question; optional criteria clarify each outcome. | noul, the probability of yes, plus confidence. |
choice | Between 2 and 255 named options with descriptions. | The winning choice, normalized probabilities, and confidence. |
score | An ordered rubric whose first level has index 0. | A probability-weighted score, per-level probabilities, and confidence. |
For a coding agent, these can answer separate questions: Does this task need repository context? Which tool should run next? How much investigation does the task need?
The questions are independent. One question cannot consume another question’s answer within the same request. Combine the results in application code, or make another request when a later decision needs an earlier result.
A high noul confidence does not necessarily mean “yes.” The SDK defines noul as a probability between 0.01 and 0.99. Its confidence is max(noul, 1 - noul). A result of noul = 0.03 therefore means a confident “no,” with confidence 0.97.
For score, the value can fall between rubric levels. Its confidence is the highest individual level probability, not a probability that the continuous average is exactly correct. These distinctions matter when your code applies thresholds.
Readers familiar with Jev can map these primitives to the patterns in our guide to Jev decision-model use cases. Similar concepts do not make the providers’ request formats interchangeable.
Gemini Decision 1 vs Jev: what do the measurements show?
Jev is the stronger starting baseline for a text-only router when your own quality results are comparable. Gemini deserves a separate trial when native multimodal input changes the work.
The direct rates below come from Google’s pricing page and TypeSafe’s pricing explanation. Benchmark figures come from Artificial Analysis’s Gemini Decision 1 profile and Jev 1.14 profile. All were checked on 2026-11-13.
| Measure | Gemini Decision 1 | Jev 1.14 |
|---|---|---|
| Direct model ID | gemini-decision-1 | jev-1.14.0 |
| Direct input price, USD per 1M tokens | $0.10 | $0.042 |
| Direct output-token charge | $0 | $0 |
| Artificial Analysis Decision Index | 66 | 66 |
| AA cost per 1M benchmark tasks, USD | $345 | $156 |
| AA Time per Task | 211 ms | 92 ms |
The AA figures favor Jev on cost and time at the same rounded index score. They do not establish equal accuracy on your tool-selection questions. Benchmark tasks also differ from HTTP requests; do not multiply these figures by your request count.
Google reports a lead across its own launch benchmark suite. It also reports nearly 5x lower cost than Gemini 3.5 Flash-Lite through the Interactions API on shared benchmarks. That is a different comparison from AA’s index and does not establish a universal lead over Jev.
In its November 12 launch analysis, Artificial Analysis reported a Brier score of 0.18 for Gemini and 0.19 for Jev. Lower is better on this probability-error measure. That small aggregate difference does not supply a safe confidence threshold for your application.
Google’s latency claim also has a specific scope: 50–100 ms median model compute and 150–250 ms end to end. It covers contexts up to 16K tokens, with latency nearly flat from 1 to 100 questions. Do not extend that claim to 1,000 questions or a full 256K context.
For multimodal work, the distinction is clearer. Google documents native text, image, audio, video, and PDF input. TypeSafe’s model reference lists text and images, but no native audio or video. TypeSafe also labels the image features in its Jev 1.14 announcement as experimental.
Start with Gemini for decisions over recordings, videos, or PDFs. Start with Jev for an existing text router. Reverse either choice when a labeled test shows a better error rate, acceptable latency, and lower total workflow cost.
How does shared input change the bill?
Send related questions together when they evaluate the same input. Google bills that shared input once per request. Each question still adds its own instructions, criteria, and formatting tokens.
At the direct paid rate verified on 2026-11-13:
request cost in USD =
(shared input tokens + all question tokens) × $0.10 / 1,000,000Consider an estimate with 10,000 shared input tokens and 100 questions. Assume each question contributes 80 billed tokens, including formatting.
| Request design | Estimated billed input | Estimated direct cost |
|---|---|---|
| One request containing 100 questions | 10,000 + 100 × 80 = 18,000 tokens | $0.0018 |
| 100 separate requests repeating the input | 100 × (10,000 + 80) = 1,008,000 tokens | $0.1008 |
This compares two Gemini request designs. It does not claim that shared-input evaluation is unique to Google.
The estimate excludes retries, downstream model calls, and gateway fees. It assumes no discount or free allowance. Use result.usage.total_input_tokens to replace the assumed token count with observed usage.
Combining questions in one interactive request is also different from submitting an asynchronous batch job. Google’s pricing page states that Gemini Decision 1 does not support the Batch API.
Run a Python tool-selection example
Use the direct Gemini API for the first test. This keeps gateway schema translation out of the initial success check.
You need Python 3.11 or later for the pinned SDK below. Create a key using Google’s API key instructions, and check the supported regions.
Use synthetic input for the trial. Review the Gemini API service terms before submitting private repository content.
Install the SDK and load the key
Run these commands in Bash. The key entry stays hidden and does not become a literal in the command history.
python3 -m venv .venv
source .venv/bin/activate
python -m pip install "google-genai==3.2.0"
read -rs GEMINI_API_KEY && export GEMINI_API_KEYThe example passes that environment variable explicitly to the client. It uses v1beta and client.decisions.create, rather than a text-generation method. The direct REST equivalent is POST https://generativelanguage.googleapis.com/v1beta/decisions.
Turn the response into a routing plan
Save this as route_decision.py. It asks all three question types, validates the response types, and prints a machine-readable routing plan.
import json
import os
from google import genai
from google.genai.decisions import ChoiceAnswer, NoulAnswer, ScoreAnswer
api_key = os.environ.get("GEMINI_API_KEY")
if not api_key:
raise SystemExit("Set GEMINI_API_KEY before running this script.")
client = genai.Client(
api_key=api_key,
http_options={"api_version": "v1beta"},
)
try:
result = client.decisions.create(
model="gemini-decision-1",
input=(
"Task: Explain why parse_config rejects an empty YAML file. "
"Repository: Python service with src/config.py and "
"tests/test_config.py. No file contents are provided. "
"Start with read-only investigation."
),
questions={
"needs_repo": {
"type": "noul",
"instructions": "Must the next step inspect repository files?",
},
"next_tool": {
"type": "choice",
"instructions": "Choose the next read-only investigation step.",
"criteria": {
"read_repo": "Inspect existing source files or tests.",
"read_docs": "Look up public API behavior.",
"no_tool": "The supplied text is sufficient.",
"human_review": "The task is ambiguous or outside these options.",
},
},
"effort": {
"type": "score",
"instructions": "Rate the investigation effort this task needs.",
"criteria": [
"Simple lookup or local explanation.",
"Investigation across source code and tests.",
"Architecture or security analysis with several dependencies.",
],
},
},
)
except Exception as exc:
raise SystemExit(
f"Decision request failed ({type(exc).__name__}); no action selected."
) from None
answers = result.answers or {}
repo = answers.get("needs_repo")
tool = answers.get("next_tool")
effort = answers.get("effort")
if not (
isinstance(repo, NoulAnswer)
and isinstance(tool, ChoiceAnswer)
and isinstance(effort, ScoreAnswer)
and result.usage is not None
):
raise SystemExit("Incomplete decision response; send this task for review.")
# Illustrative thresholds. Tune them on labeled traffic before deployment.
next_tool = tool.choice if tool.confidence >= 0.85 else "human_review"
if next_tool == "read_repo" and repo.noul < 0.85:
next_tool = "human_review"
if next_tool not in {"read_repo", "read_docs", "no_tool", "human_review"}:
next_tool = "human_review"
model_tier = (
"reasoning"
if effort.score >= 1.5 or effort.confidence < 0.80
else "small"
)
print(json.dumps({
"next_tool": next_tool,
"model_tier": model_tier,
"repository_probability": repo.noul,
"tool_confidence": tool.confidence,
"effort_score": effort.score,
"input_tokens": result.usage.total_input_tokens,
"output_tokens": result.usage.total_output_tokens,
}, indent=2))Run it from the same Bash session:
python route_decision.pyA successful call returns answers under the three requested keys and reports zero output tokens. The script should print a tool label, a model-tier label, probabilities, and usage. Do not treat a particular probability or route as a guaranteed result.
The thresholds 0.85, 0.80, and 1.5 are illustrative application policy, not vendor recommendations. The small and reasoning strings are local routing labels, not API model IDs.
The program produces a plan; it does not read files, execute commands, or invoke the selected model tier. Your agent controller must map these labels to approved tools and deployed models. Keep filesystem permissions and command approval separate from the model’s judgment.
The same separation applies to business automation. Our Jev ticket-routing workflow explains how classification fits into a larger process with validation and escalation.
What are the free-tier limits and likely failures?
Check both the request allowance and token allowance before load testing. A high question limit does not remove rate limits.
Google’s published Gemini Decision 1 limits, checked on 2026-11-13, include:
| Usage tier | Requests per minute | Input tokens per minute | Requests per day |
|---|---|---|---|
| Free | 200 | 50,000 | 10,000 |
| Tier 1 | 1,500 | 1,000,000 | 50,000 |
Check the project’s active limits in AI Studio before deployment. Google warns that published limits do not guarantee capacity. Additional paid tiers appear in the linked reference.
If the client has no decisions attribute, inspect the installed package with python -m pip show google-genai. Upgrade the package in the same virtual environment that runs the script. Decisions support entered the SDK in 3.2.0.
For rate-limit failures, reduce request frequency or input volume before retrying. Google’s troubleshooting guide recommends exponential backoff, jitter, and bounded retries for transient failures. A daily quota exhaustion needs a quota reset or an increase, not a tight retry loop.
For content moderation, plan an additional failure branch. The Decisions API can return 400 Bad Request when its input safety filters block a request, instead of returning answers. A blocked request is not a negative policy classification. Route it to review or another approved handling path rather than treating missing answers as permission to proceed.
Can OpenRouter or Vercel use the same request?
Both list google/gemini-decision-1, but their interfaces differ from Google’s direct Python example. Choose a gateway for an existing integration, not by changing only the base URL.
OpenRouter’s model page lists the model. Its Decisions API reference documents POST https://openrouter.ai/api/alpha/decisions, with shared content in state. The endpoint is alpha and its schema may change. The model page also says EU in-region routing is not currently available.
Vercel’s launch documentation lists the same model ID. PDF, audio, and video inputs require the AI SDK 7 route described there. Its TypeSafe-compatible and Decisions APIs support text and images.
Vercel’s decision interface documentation also uses different shapes across interfaces. The AI SDK uses state and boolean; its HTTP Decisions interface uses input and predicate. Do not copy Google’s noul request into either without adapting the documented schema.
A gateway listing does not establish access from every country or satisfy a data-residency requirement. Check eligibility, data handling, and any gateway charges before moving production traffic.
What should you measure before replacing a router?
Run the candidate router without letting it control actions first. Compare its proposed routes with labeled examples and the decisions your current system makes.
Measure incorrect automatic actions at a fixed automation rate. Also record fallback frequency, end-to-end p50 and p95 latency, retries, and total cost. Recheck thresholds after changing a model version, question wording, or candidate list.
Keep deterministic work in code. A decision model adds little value to checking a known exit code or matching an exact permission rule. A generative model remains appropriate when the required output is a patch, explanation, or tool call with newly constructed arguments.
For coding workflows, include the selected executor’s cost and failures in the comparison. Our guide to coding-agent cost per task explains why a cheaper routing call can still produce a more expensive completed task.
