Which AI Model for Which Automation Workflow? OpenAI, Anthropic and Gemini by Job, With Verified Prices (October 2026)

The right AI model for an automation workflow is the smallest one that passes your test for that step, and the provider is whichever vendor makes that model easy to constrain to a schema. Route labels, scores and triage to a small model (GPT-6 Luna, Claude Haiku 5.5 or Gemini 3.5 Flash-Lite). Route extraction, summaries and reply drafts to a mid model (Gemini 3.8 Flash, Claude Sonnet 5.5 or GPT-6.1 Sol). Reserve a frontier model (Claude Opus 5.5 or Gemini 4 Argon, with Claude Fable 5.1 and GPT-6 Astra above them) for the few steps that need multi-step judgment or tools. At list prices read on 16 October 2026, that routing puts 1,000 classification runs at 7 to 23 cents and 1,000 invoice extractions at 40 cents to $8, against $16 for the same extraction on Claude Opus 5.5 and $40 on GPT-6 Astra.

What changed since September 2026

This guide was first published on 12 September 2026. Five weeks later most of the model lineup had turned over, so every price, model name and cost figure below was re-read from the vendors' pricing pages on 16 October 2026.

Sources: OpenAI pricing, Claude pricing, Gemini pricing and Make's release notes, all read 16 October 2026. Gemini 4 Argon did not appear in Make's release notes by that date; until it does, call it through Make's HTTP module or the Gemini app's custom API call. Everything else that changed in Make, n8n and Zapier this month is in our automation platform updates for October 2026, and the full catalog of current models, with API IDs and context windows, is the AI model landscape.

This is the routing we use at Nex after 1,200+ automations for 210+ businesses, most of them on Make.com, Zapier and n8n with an AI step somewhere inside. Prem Patel, Make Level 5 Expert and Zapier Certified, wrote the golden-set method described below for the contract review SaaS that reports a 94.9 percent best run on its test set. Every price on this page carries the vendor page it came from and the date we read it, because these numbers move every few months.

TL;DR: which model for which workflow job

Prices are standard-tier list prices read on 16 October 2026 from developers.openai.com/api/docs/pricing, platform.claude.com/docs/en/about-claude/pricing and ai.google.dev/gemini-api/docs/pricing. Two Gemini rates are introductory: Gemini 4 Argon's $2 / $10 runs to 30 November 2026 ($4 / $20 from 1 December) and Gemini 3.8 Flash's $0.75 / $3.75 runs to 31 December 2026 ($1.50 / $7.50 after). Claude Haiku 5.5's $0.10 / $0.50 applies to prompts up to 100,000 tokens ($0.50 / $2.50 above that). Batch pricing is 50 percent off at all three vendors.

Rules first, then the smallest model that passes

Before any model choice, the cheapest step in a workflow is the one the model never sees. In a typical inbound-email triage we build (our client builds, 2025 to 2026), a filter on sender domain, subject pattern and attachment type settles 40 to 60 percent of items before the AI module runs. That is a Make filter or an n8n IF node, and it costs a credit, not tokens. The model handles the remainder: the messy, ambiguous half where a human would have had to read the message.

Once an item does reach a model, the question is not "which is the best model" but "which is the smallest model that passes the golden set for this step". The answer is different per step in the same scenario. A contract review pipeline routed this way sends clause classification to a small model, clause extraction to a mid model and the final risk judgment on a flagged clause to a frontier model. Three models in one workflow, and the frontier model only sees the clauses the earlier steps flagged.

The rest of this guide is that reasoning, one job at a time, with the settings and the bill for each.

Classification and routing: small model, enum output, temperature 0

Classification is the job the small tier was built for. The input is short, the output is one value from a list you control, and volume is high. On 16 October 2026 the small tier from the three vendors reads: GPT-6 Luna at $0.10 input and $0.50 output per million tokens, Claude Haiku 5.5 at the same $0.10 and $0.50 for prompts up to 100,000 tokens (Anthropic describes it as built for classification, extraction and routing) and Gemini 3.5 Flash-Lite at $0.30 and $2.50. Gemini 3.1 Flash-Lite sits at $0.25 and $1.50 but is an update behind. In September the gap between the cheapest and dearest small model was five times; in October Luna and Haiku are level, so the golden set, not the price, picks between them.

How we set it up. The output schema is a single required field with an enum of the allowed labels, plus an optional confidence integer from 0 to 100. Temperature 0 where the vendor exposes it. max_tokens around 50, because the answer is one token and a runaway answer is a bug you want to fail loudly. The system prompt carries the label definitions with one real example each, and the user turn carries only the item. Anything that stays the same across runs goes in the system prompt so caching can pick it up.

Where it goes in the platform. In Make, the OpenAI, Anthropic and Google AI modules all accept a JSON schema on the newer actions; where a module lags, the HTTP module with the raw request body is the reliable path and lets you set every parameter. In n8n the vendor nodes expose structured output through the output parser, and a Code node after it is where we validate. Zapier's native AI actions are the least configurable, so for anything with a schema we use the vendor's own action with a JSON schema field or Webhooks by Zapier. The triggers and actions guide covers the mechanics.

Cost per 1,000 runs. With 600 input tokens (a 350-token system prompt and a 250-token email) and a 20-token answer: $0.07 on GPT-6 Luna, $0.07 on Claude Haiku 5.5, $0.23 on Gemini 3.5 Flash-Lite. The same job on Claude Opus 5.5 is $2.80 and on GPT-6 Astra $7.00. Nobody should be paying frontier prices to sort email.

Lead scoring: a rubric, an integer and a reason

Lead scoring looks like classification with a number instead of a label, and the small tier handles it as long as the input is a form fill plus a few enrichment fields. The mistake we see most often is asking the model for a score with no rubric. The score then drifts between runs and nobody can explain why a lead got 62.

We give the model a written rubric (company size band, role seniority, stated budget, timeline, fit with the services offered) with point ranges per criterion, and ask for a schema with score as an integer 0 to 100, band as an enum (hot, warm, cold) and reason as one sentence under 200 characters. The band drives the routing in the workflow; the reason lands in the CRM note so the salesperson sees why. When the record carries long free-text notes or a call transcript, the job moves to a mid model such as Gemini 3.8 Flash, whose $0.75 input price and 1,048,576-token context make long context cheap.

For a worked example of scoring feeding a reply, the Yelp lead response automation shows the routing rules around the score.

Extraction to JSON: the mid tier, strict schema, validated twice

Extraction is where the model choice starts to matter for accuracy, and where structured outputs earn their place. Invoices, contracts, purchase orders and forms arrive as PDFs or long emails, the schema has ten to forty fields, and one wrong number reaches accounting.

Which model. Gemini 3.8 Flash is our default for document extraction: multimodal input, a 1,048,576-token context window, $0.75 input and $3.75 output on the October 2026 pricing page (an introductory rate to 31 December), and batch at 50 percent off for backfills. Claude Sonnet 5.5 at $2 and $10 is the step up when the document is long and you need page-level citations (the contract review SaaS keeps the page number on every extracted fact), and GPT-6.1 Sol at the same $2 and $10 is the OpenAI equivalent. We covered the PDF pipeline itself in the AI PDF extraction guide.

The JSON contract, per vendor. All three vendors now offer a schema-constrained mode, and all three are different from plain JSON mode:

• OpenAI: text.format with type: "json_schema", your schema and strict: true. The docs call it the evolution of JSON mode; response_format: {type: "json_object"} only guarantees parseable JSON. Safety refusals come back in a separate refusal field rather than inside your schema, so check it before you parse.
• Anthropic: output_config.format with type: "json_schema" and the schema, or strict: true on a tool definition when you want the result as a tool call. The schema cannot use minimum, maximum, minLength or maxLength, and additionalProperties must be false, so numeric range checks belong in your validator. Compiled grammars are cached for 24 hours; the first call with a new schema is slower.
• Gemini: response_format with type: "text", mime_type: "application/json" and the schema on the Interactions API, with enum supported for classification fields. The docs warn that very large or deeply nested schemas may be rejected, and still recommend validating in the application.

Validate twice. Schema validation proves the shape. It does not prove that the due date is after the invoice date, that line items sum to the total or that the vendor name matches an approved list. That second pass is a Code module in Make, a Code node in n8n or a Formatter plus a Filter in Zapier, and it is the step that turns a demo into a system. When it fails, the first retry sends the model the validator's error message alongside the original input; the second failure goes to a human queue with the raw document attached. We wrote about the failure modes in why Make scenarios fail in production.

Cost per 1,000 runs. With 2,500 input tokens (a 700-token system prompt and schema, plus an 1,800-token invoice) and a 300-token JSON answer: $0.40 on GPT-6 Luna or Claude Haiku 5.5, $1.50 on Gemini 3.5 Flash-Lite, $3.00 on Gemini 3.8 Flash, $8.00 on Claude Sonnet 5.5, GPT-6.1 Sol or Gemini 4 Argon (at its rate to 30 November), $16 on Claude Opus 5.5 and $40 on Claude Fable 5.1 or GPT-6 Astra. The small models are tempting for extraction, and on clean, single-page documents they pass; on multi-page PDFs with tables our golden sets have kept us on the mid tier. Anthropic notes that its tokenizer since Claude Opus 4.7 produces about 30 percent more tokens for the same text (Claude pricing page, read 16 October 2026), so compare vendors on token counts you measured, not on these round numbers.

Summarisation: cheap input beats clever output

A summary of a 40-page transcript is 30,000 input tokens and 400 output tokens, so the input price is nearly the whole bill. Gemini 3.8 Flash at $0.75 input is the obvious first pick, and its 1,048,576-token window means no chunking for anything a workflow will realistically see. Claude Sonnet 5.5 at $2 input with a 1M context is the second choice when the summary needs to follow a strict house format. We ask for a schema here too: headline, decisions as an array of strings, open_questions, next_actions with owner and due fields. A summary that lands in Notion as four fields is worth more than one paragraph of prose.

Support reply drafts: mid tier, always behind a gate

Reply drafting is the job where people reach for the biggest model, and it is rarely justified. The draft is read by a human before it is sent, or it should be, so the model's job is a good first draft in the house voice with the right facts pulled in. Claude Sonnet 5.5, GPT-6.1 Sol and Gemini 3.8 Flash all pass our golden sets for this. What moves the quality is the input shaping: the customer's last three messages, the relevant knowledge base snippets (retrieved by a search step, not pasted wholesale), the order or account facts as JSON and a system prompt with three real examples of good replies.

The output is again a schema: reply as the text, needs_human as a boolean, reason when true and kb_articles_used as an array of ids. The boolean is the gate. If the model says it needs a human, or the confidence rule fires, the draft goes to a queue instead of a send. Temperature can sit slightly above zero for drafts, but not on the routing fields. With 3,000 input tokens and a 250-token reply, 1,000 drafts cost $3.19 on Gemini 3.8 Flash and $8.50 on Claude Sonnet 5.5 or GPT-6.1 Sol, against $17 on Claude Opus 5.5.

Agents with tools: frontier tier, caching on, budget capped

An agent step is different in kind. The model plans, picks a tool, reads the result and loops, often five to ten turns before it is done. Tool choice and recovery from a bad tool result are where small models fail, so this is the one job where we start at the frontier. Anthropic's models overview, read 16 October 2026, says: "If you're unsure which model to use, start with Claude Opus 5.5 for most workloads," and to use Claude Fable 5.1 "when your evals on Claude Opus 5.5 at higher effort still fall short." On the OpenAI side the same ladder is GPT-6.1 Sol, then GPT-6 Astra, and on Google's it is Gemini 4 Argon. Effort is the main cost lever within one model: Claude Opus 5.5 defaults to medium effort and Claude Fable 5.1 to high, per the same overview, so set it explicitly per step.

Two settings matter more than the model name. First, prompt caching. On a five-turn agent the same tool definitions and system prompt are resent every turn, and cached input is 0.05x the input price on GPT-6.1 Sol, Claude Opus 5.5, Claude Sonnet 5.5 and Gemini 4 Argon, 0.1x on most other models and 0.025x on Claude Fable 5.1 (its cache read is $0.25 against $10 uncached). Second, a budget cap: max_tokens per turn and a hard turn limit in the workflow loop, because an agent that cannot finish will keep trying at $20 (Claude Opus 5.5) to $50 (GPT-6 Astra, Claude Fable 5.1) per million output tokens.

Cost per 1,000 runs. With five turns averaging 6,000 input tokens each (30,000 per run) and 1,500 output tokens per run: $75 on Claude Sonnet 5.5, GPT-6.1 Sol or Gemini 4 Argon at its rate to 30 November ($150 from 1 December), $150 on Claude Opus 5.5 and $375 on GPT-6 Astra or Claude Fable 5.1. With 70 percent of input served from cache: $35.10 on the first three, $70.20 on Claude Opus 5.5, $186 on GPT-6 Astra and $170.25 on Claude Fable 5.1. Caching halves an agent bill; it is not optional. The Make AI agents guide covers the platform side, and the AI agent cost guide covers what the build itself costs.

Cost per 1,000 runs by job and model (October 2026)

Worked from list prices read on 16 October 2026 and the token counts stated in each section below: classification at 600 input and 20 output tokens, extraction at 2,500 and 300, a reply draft at 3,000 and 250, and a five-turn agent at 30,000 input and 1,500 output tokens per run. Platform credits on Make, Zapier or n8n are billed on top.

"n/a" means we would not route that job to that model, not that it cannot run it. From 1 December 2026 Gemini 4 Argon's row doubles ($16 extraction, $150 per 1,000 agent runs).

Structured outputs, temperature, max tokens and shaping in one list

• Structured output on, always. Use the schema-constrained mode from the vendor, not "reply in JSON" in the prompt. Keep the schema flat, name every field in plain English and put an enum on every field that has a fixed set of values.
• Temperature 0 for anything a workflow branches on. Labels, scores, booleans, extracted fields. On models that expose effort instead of temperature, set effort low for these jobs and raise it only for the reasoning step.
• max_tokens sized to the schema. Around 50 for a label, 300 to 800 for an extraction, 400 for a draft. A cap that is hit is a signal, not a nuisance; log it.
• Shape the input. Send facts as JSON, not prose. Strip signatures, disclaimers and quoted history from emails before the call. Retrieve the three relevant knowledge base chunks, not the whole knowledge base.
• Shape the output. Ask for what the next module needs and nothing else. A reason field costs 40 tokens and saves a support ticket.
• Version the prompt. The prompt and schema live in a data store or a git-tracked file, not inside the module, so a change is a diff and a rollback is one click.

Prompt caching and batching: where the real discounts are

Caching pays whenever a long, stable prefix is resent: a system prompt with examples, a schema, a policy document, tool definitions. OpenAI caches automatically once a prompt passes 1,024 tokens on GPT-5.6 and later, charges 1.25x for the write, and on 16 October 2026 lists cached input at $0.10 on GPT-6.1 Sol (0.05x) and $0.01 on GPT-6 Luna (0.1x). Anthropic uses an explicit cache_control breakpoint (or a single top-level one), 1.25x for a 5-minute write, 2x for a 1-hour write and 0.05x for reads on Opus 5.5 and Sonnet 5.5 (0.1x on Haiku 5.5 and older models). Gemini caches implicitly on 2.5 and newer models once the prompt clears the minimum (4,096 tokens on the 3.x Flash line and 3.1 Pro), and reports hits in usage.total_cached_tokens. The practical rule: put everything static first, everything that changes last and check the usage fields on the first hundred runs to confirm the cache is actually hitting.

Batching is 50 percent off at all three vendors and returns within 24 hours (Anthropic reports most batches finish inside an hour). It is the right shape for a nightly enrichment of new CRM records, a backfill over last year's invoices or a weekly re-score, and the wrong shape for anything a person is waiting on. In a workflow it looks like a scheduled scenario that writes a JSONL file, submits the batch through the HTTP module and a second scenario that polls and processes results. Both discounts stack with each other at OpenAI and Anthropic.

Golden-set testing: the method that picks the model for you

Every routing decision above is provisional until it is scored. The method is the one Prem built for the contract review product: a golden set of real documents with hand-verified expected outputs, scored on every prompt or model change, with failures broken down by type (missed field, wrong value, wrong page, hallucinated value, schema failure). That project reports a 94.9 percent best run and a 79.5 percent mean across runs on its golden set, and the gap between those two numbers is exactly why a single demo run proves nothing.

For a workflow step, the golden set is 50 to 200 items. Build it from real data, redacted, including the awkward cases nobody wants to talk about. Score each candidate model on it at the settings you will use in production. The smallest model that clears your threshold, by failure type not by average, is the model you ship for that step. Re-run the set whenever a vendor changes a model version, because they do without asking, and when your own inputs change shape. This is the same logic as the AI agent vs automation rule: if you can draw the flowchart, build an automation; the golden set tells you which boxes need a model at all.

Fallbacks and retries inside Make, Zapier and n8n

An AI call fails in four ways: rate limit or timeout, a schema-invalid reply, a valid reply that fails business rules and an outage. Each gets a different handler.

• Rate limit and timeout. Make: error handler route with a Break directive and a retry interval, or a Sleep module plus a second attempt. n8n: the node's retry-on-fail with a wait, and an Error Trigger workflow for anything that escapes. Zapier: Autoreplay on the plan tiers that include it, plus a Paths branch on the error.
• Schema-invalid reply. Rare with structured outputs on, but the handler is one retry with the error appended to the prompt, then a human queue.
• Business-rule failure. No retry. Route to the review queue with the reason; a second model call will produce the same wrong answer with more confidence.
• Vendor outage. A fallback route to a second vendor on the same tier with the same schema. This is the strongest argument for keeping the schema vendor-neutral and the prompt in a data store: Gemini 3.8 Flash can take Sonnet 5.5's extraction traffic for an hour without a rebuild.

Every branch logs the model id, the prompt version, input and output token counts and the cost. That log is what makes the per-run price on our homepage a real number and lets a client see model spend beside platform credits. If you want the platform side of that bill, the platform cost calculator works it from run counts.

The mistakes we see in the audits

1. One model for everything. Usually the biggest one, because it was the one that worked in the first demo. Routing by step is the single largest saving in most audits.
2. "Reply in JSON" in the prompt instead of a schema. Works most of the time, and the rare miss breaks the next module at 2am.
3. No validator after the model. The schema proves shape; nobody checks the totals add up.
4. Temperature left at the default for routing decisions. The same email gets a different label on Tuesday.
5. Whole knowledge base pasted into every call. Retrieval is a search step, not a paste. This is also why caching is not hitting.
6. No golden set. The prompt was tuned against the three emails the founder had to hand.
7. No cost log. The invoice from the vendor is the first time anyone sees the number.
8. Agent loops without a cap. One stuck run can cost more than a month of normal traffic.

What this means for a project

If you are scoping an AI step for a workflow, bring three things to the call: a sample of 20 real items, the list of fields or labels you need out and what an error costs you. Those set the tier and the vendor, and the golden set follows from the sample. See the AI agents for business use cases list for where each job shows up, our services for how the build is scoped and priced, or book a free 30-minute call and we will route your first step on the call.

Frequently asked questions

Which AI model is best for automation workflows in 2026?

There is no single best model. Route by job: a small model for labels, routing and scores (GPT-6 Luna or Claude Haiku 5.5 at $0.10 in and $0.50 out per million tokens, Gemini 3.5 Flash-Lite at $0.30 and $2.50), a mid model for extraction and drafts (Gemini 3.8 Flash, Claude Sonnet 5.5, GPT-6.1 Sol) and a frontier model only for the steps that need multi-step judgment (Claude Opus 5.5, Gemini 4 Argon). Prices read on the vendors' pricing pages, 16 October 2026.

What is the cheapest LLM for classification and lead routing?

At list price on 16 October 2026, GPT-6 Luna and Claude Haiku 5.5 (both $0.10 per million input tokens and $0.50 output, Haiku for prompts up to 100,000 tokens) are the cheapest current models from the three main vendors, with Gemini 3.5 Flash-Lite at $0.30 and $2.50. On a 600-token classification with a 20-token answer, 1,000 runs cost about $0.07 on Luna or Haiku 5.5 and $0.23 on Flash-Lite. The bigger saving is structural: constrain the output to an enum so the answer is one label, and put rules in front of the model so half the items never reach it.

Should I use JSON mode or structured outputs?

Structured outputs. JSON mode only promises the reply parses as JSON; it does not promise your fields. OpenAI uses text.format with type json_schema and strict true, Anthropic uses output_config.format with a json_schema (or strict true on a tool), Gemini uses response_format with mime_type application/json and a schema. All three still need a validator on your side for business rules the schema cannot express, such as a due date after the invoice date.

What temperature should I use for extraction and classification?

The lowest the vendor allows, usually 0, because you want the same input to give the same output on every run. The newest Anthropic and OpenAI models add an effort level, alongside or instead of temperature; set it low for labels and extraction and reserve high effort for the steps that need reasoning. Creative drafts can run slightly warmer, but a support reply that goes to a human gate does not need it.

How do I test which model is good enough for my workflow?

Build a golden set: 50 to 200 real, hand-checked examples with the expected output for each, including the awkward ones. Run every candidate model and every prompt version against it and score by failure type, not a single percentage. That is the method behind the contract review SaaS we built, which reports a 94.9 percent best run and a 79.5 percent mean on its golden test set. The smallest model that passes your threshold on the golden set is the model you ship.

How much does an AI step cost per 1,000 runs?

Cents to a few dollars for classification, single-digit dollars for extraction and drafts, tens to hundreds of dollars for tool-using agents. Worked at list prices read on 16 October 2026: 1,000 invoice extractions at 2,500 input and 300 output tokens cost about $0.40 on GPT-6 Luna, $3 on Gemini 3.8 Flash, $8 on Claude Sonnet 5.5 or GPT-6.1 Sol and $16 on Claude Opus 5.5. Platform credits on Make, Zapier or n8n are billed on top; our cost calculator covers that side.

Does prompt caching or batching help inside Make, Zapier or n8n?

Caching helps whenever the same long system prompt or reference document is sent on every run: cached input costs 0.05x the normal input rate on GPT-6.1 Sol, Claude Opus 5.5 and Sonnet 5.5, 0.1x on most other models (0.025x on Claude Fable 5.1). Gemini caches implicitly above a minimum prompt size. Batching gives 50 percent off at all three vendors but returns results asynchronously within 24 hours, so it suits nightly enrichment or backfills, not a live lead router. Both are set through the HTTP module or the vendor node rather than the platform UI.

Related reading

• The AI Model Landscape, October 2026
• How Much Does an AI Agent Cost to Build in 2026?
• AI PDF Extraction with Make.com and Gemini
• Make.com AI Agents Guide
• Why Make Scenarios Fail in Production
• Zapier vs Make vs n8n in 2026
• iPaaS for AI Agents in 2026