Stop Paying Agents to Make Yes-or-No Decisions (2026)
Gemini Decision 1 costs $0.10 per million input tokens and returns routing labels in under 250ms. Run hard rules first, then Decisions API, then send low-confidence cases to a full agent. 1,000 lead routing decisions cost about $0.05.
Stop Paying Agents to Make Yes-or-No Decisions
Google's Gemini Decisions API costs $0.10 per million input tokens. It returns closed-set decisions in 150–250 milliseconds, with no output-token charge.
That makes it a cheap decision layer for lead routing and compliance QA. It acts as a bouncer before your expensive agent.
Step 1: Separate Decisions From Reasoning
Most agent workflows waste money before the agent does useful work.
They send every lead to a frontier model. The model reads the record, explains its thinking, and picks a route.
You don't need an essay. You need one of four labels.
Google built Gemini Decisions API for that job. Gemini Decision 1 scores fixed options without generating text token by token.
It supports three decision types:
- Yes or no: Is this message compliant?
- Choice: Should this lead go to sales, nurture, partner, or reject?
- Score: How strong is purchase intent from zero to four?
Each answer includes probabilities or confidence data. Your code decides what happens next.
The API accepts text, images, audio, video, and PDFs. Google says one request can include up to 1,000 questions against the same input.
That limit applies to questions about shared input. For example, you can ask 12 compliance questions about one email.
Don't send 1,000 separate contacts as if they were one record.
Cheap classifiers can handle routine traffic. Full agents can handle cases that need research, judgment, or action.
The pattern isn't new.
Decision models can replace brittle rule piles. Keep rules and human review where they make sense.
Step 2: Put the Decision Layer Before the Agent
A safe setup has four gates.
```text CRM or outbound webhook | v Hard rules and data checks | v Gemini Decisions API | +----+------------------+ | | High confidence Low confidence | | v v Route automatically Human or full agent | | +-----------+-----------+ | v Write result to CRM ```
Start with hard rules.
If an email address is missing, reject it in code. If the contact opted out, block the message without asking Gemini.
Laws and clear company policies belong in deterministic checks. Don't make a probability model rediscover `opt_out = true`.
Send fuzzy questions to the decision layer:
- Does the job title suggest buying authority?
- Does the message contain an unsupported performance claim?
- Is the lead asking for pricing or general education?
- Which product team best matches the stated problem?
- Does this email pressure the recipient with false urgency?
Use a full agent for difficult cases.
A full agent might research the account, inspect past CRM notes, or rewrite an email. That work needs a generative model.
Google uses Decisions as a control layer. Gemini Notebook routes requests between model tiers. Google Search checks MCP tool activity for adversarial behavior.
LangChain also added a beta `GoogleGenAIClassifier`. Its middleware can route models and block risky tool calls.
The beta requires LangChain 1.5.0 or later. It also requires `langchain-google-genai` 4.5.0 and `google-genai` 3.2.0 or later.
The API isn't a universal safety system. It only checks the questions and tools you put behind it.
Step 3: Build Lead Routing With Closed Choices
A good Gemini Decisions API for lead routing setup starts with a small label set.
Use routes that lead to a clear action:
1. `sales_now` 2. `agent_outreach` 3. `marketing_nurture` 4. `partner_route` 5. `reject`
Include an escape label such as `other` or `unclear`. Without one, the model may force a bad choice.
Your decision definition should describe each route.
```yaml decision: lead_route type: choice
options: sales_now: description: Clear buying intent, valid market, and sales-ready timing.
agent_outreach: description: Fits our market but needs qualification before human follow-up.
marketing_nurture: description: Relevant interest without current buying intent.
partner_route: description: Better served by a named reseller or referral partner.
reject: description: Spam, student research, vendor outreach, or unsupported market.
unclear: description: Evidence conflicts or required data is missing. ```
Your webhook adapter can follow this pattern:
```javascript async function routeLead(lead) { if (!lead.email || lead.optedOut) { return { route: "reject", source: "hard_rule" }; }
const result = await decisionsClient.evaluate({ model: "gemini-decision-1", input: normalizeLead(lead), questions: [leadRouteQuestion, intentScoreQuestion] });
const route = result.questions.lead_route; const intent = result.questions.intent_score;
if (route.confidence < 0.85) { return queueForReview(lead, result); }
if (route.choice === "sales_now" && intent.score < 2.5) { return queueForReview(lead, result); }
return updateCRM(lead.id, route.choice, result); } ```
The code shows the control pattern. Map field names to Google's current SDK before shipping.
Salesforce cut lead assignment time from 20 minutes to 20 seconds. Sellers now focus on roughly the top 25% of leads.
The other 75% go to nurture or agent-first outreach.
Don't make your best sellers classify form fills.
Step 4: Add Outbound and Compliance QA
Outbound QA works best as a set of narrow checks.
One giant question like "Is this email safe?" hides why the system rejected it. It also makes testing harder.
Ask separate questions:
```yaml questions: opt_out_language: type: yes_no true: The message includes clear opt-out language.
unsupported_claim: type: yes_no true: The message states a result without supplied evidence.
false_urgency: type: yes_no true: The message invents a deadline, scarcity, or consequence.
sensitive_inference: type: yes_no true: The message infers health, race, religion, or another sensitive trait.
personalization_quality: type: score rubric: 0: Generic message with no recipient relevance. 1: Weak personalization based only on title or company. 2: Relevant personalization supported by supplied data. 3: Specific, useful, and directly tied to the recipient's role. ```
Set thresholds based on risk.
A weak personalization score might trigger a rewrite. A likely sensitive inference should block the message and send it for human review.
Don't use the same threshold for every question.
A probability near 0.50 means the model is uncertain. It doesn't mean the risk is medium.
Use rubric scores for severity. Use yes-or-no probabilities for conditions.
Store every decision with:
- Model version
- Decision definition version
- Input record ID
- Probabilities
- Chosen route
- Final human outcome
- Timestamp
This record gives you an audit trail. It also gives you data to tune your thresholds.
Outbound trust is fragile. Bad AI can damage it faster because bad messages can go out faster.
Cialdini's influence principles still apply. Trust comes before persuasion, whether a human or model writes the email.
Step 5: Measure Cost, Drift, and Exceptions
Gemini Decision 1 pricing is simple. Google lists $0.10 per million input tokens and zero billed output tokens.
Assume 1,000 lead records contain 500 tokens each.
That's 500,000 input tokens. The decision cost is about $0.05.
Now assume 1,000 outbound emails use 1,000 tokens each. That includes the email, policy, and supporting context.
That's one million tokens. The compliance QA cost is about $0.10.
Both workflows cost roughly $0.15 in decision inference. Storage, CRM calls, and human review cost extra.
Google reports 150–250 milliseconds end to end. Model compute reportedly takes 50–100 milliseconds under tested conditions.
Measure your own network and queue time. A vendor benchmark isn't your production result.
Track five numbers each week:
1. Automatic routing rate 2. Human-review rate 3. False approval rate 4. False rejection rate 5. Cost per accepted decision
Run monotonic tests too.
If you add stronger buying intent, the readiness score shouldn't fall. If you add an unsupported claim, compliance risk shouldn't improve.
Build test pairs where only one fact changes. Score both versions.
Your first version won't be perfect. A 60% to 70% first-release accuracy rate is normal.
Salesforce keeps tuning its routing thresholds as products and campaigns change. You should do the same.
The best setup is boring. Cheap decisions handle normal traffic. Expensive agents handle the exceptions.
FAQ
What is the Gemini Decisions API, and when should I use it?
The Gemini Decisions API uses Gemini Decision 1 for bounded choices, yes-or-no checks, and rubric scores. Use it when your code needs a label or probability instead of generated prose.
How much does Gemini Decision 1 cost?
Google lists Gemini Decision 1 pricing at $0.10 per million input tokens. Output tokens aren't billed because the model scores options instead of writing responses.
What latency does the Gemini Decisions API have?
Google reports 150–250 milliseconds of end-to-end latency. Its reported model-compute latency is 50–100 milliseconds under tested conditions.
Can Gemini Decisions replace a sales agent?
No. Gemini Decisions can route, score, or block work before a sales agent acts. Use a full agent for research, writing, tool use, and uncertain cases.
How should I connect it to Salesforce or HubSpot?
Trigger a webhook when a lead or email changes. Run hard rules first, call Gemini Decisions second, then write the route and confidence back to the CRM.
Related Reading
How much does the Gemini Decisions API cost per 1,000 leads?
Google prices Gemini Decision 1 at $0.10 per million input tokens. At 500 tokens per lead, routing 1,000 leads costs about $0.05. Output tokens are not billed.
How fast does the Gemini Decisions API return a result?
Google reports 150 to 250 milliseconds end to end. Model compute alone takes 50 to 100 milliseconds under tested conditions. Measure your own network and queue time before relying on that benchmark.
Can the Gemini Decisions API replace a full AI sales agent?
No. Gemini Decision 1 returns a label or probability, not reasoning or action. Use it to route, score, or block work before an agent runs. Send research, writing, and uncertain cases to a full agent.