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

Route each step to the smallest model that passes your test: a small model (GPT-5.6 Luna, Gemini 3.5 Flash-Lite, Claude Haiku 4.5) for labels and scores, a mid model (Gemini 3.8 Flash, Claude Sonnet 5, GPT-5.6 Terra) for extraction, summaries and drafts, then a frontier model (Claude Opus 5, GPT-5.6 Sol) only for agents with tools. At list prices read 12 September 2026 that puts 1,000 classifications at $0.14 to $0.70 and 1,000 invoice extractions at $3 to $8.60, against $40 on a frontier model.

Last verified: 12 September 2026 · Prem Patel, Nex Automations

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-5.6 Luna, Gemini 3.5 Flash-Lite or Claude Haiku 4.5). Route extraction, summaries and reply drafts to a mid model (Gemini 3.8 Flash, Claude Sonnet 5 or GPT-5.6 Terra). Reserve a frontier model (Claude Opus 5 and GPT-5.6 Sol, 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 12 September 2026, that routing puts 1,000 classification runs at 14 to 70 cents and 1,000 invoice extractions at $1 to $8, against $40 for the same extraction on a frontier model.

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 12 September 2026 from developers.openai.com/api/docs/pricing, platform.claude.com/docs/en/about-claude/pricing and ai.google.dev/gemini-api/docs/pricing. Gemini 3.8 Flash's $0.75 / $3.75 is the rate the pricing page shows through 31 December 2026, with $1.50 / $7.50 listed after 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, 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 12 September 2026 the small tier from the three vendors reads: GPT-5.6 Luna at $0.20 input and $1.20 output per million tokens (the OpenAI models page says it corresponds to the earlier nano tier), Gemini 3.5 Flash-Lite at $0.30 and $2.50, and Claude Haiku 4.5 at $1 and $5. Gemini 3.1 Flash-Lite is cheaper still at $0.25 and $1.50 but sits an update behind.

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.14 on GPT-5.6 Luna, $0.23 on Gemini 3.5 Flash-Lite, $0.70 on Claude Haiku 4.5. The same job on Claude Opus 5 is $3.50 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 September 2026 pricing page, and batch at 50 percent off for backfills. Claude Sonnet 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-5.6 Terra at $2 and $12 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.86 on GPT-5.6 Luna, $1.50 on Gemini 3.5 Flash-Lite, $3.00 on Gemini 3.8 Flash, $4.00 on Claude Haiku 4.5, $8.00 on Claude Sonnet 5, $8.60 on GPT-5.6 Terra, $20 on Claude Opus 5 and $40 on Claude Fable 5.1 or GPT-6 Astra. Luna is tempting for extraction, and on clean, single-page documents it passes; on multi-page PDFs with tables our golden sets have kept us on the mid tier.

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 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, GPT-5.6 Terra 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, $8.50 on Claude Sonnet 5 and $9.00 on GPT-5.6 Terra, against $21.25 on Claude Opus 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 own models overview says to start with Claude Opus 5 for most workloads and reach for Claude Fable 5.1 when evaluations on Opus 5 at higher effort still fall short; on the OpenAI side the same ladder is GPT-5.6 Sol, then GPT-6 Astra. Both vendors expose an effort level on these models (low to max on GPT-6 Astra per its model page, low to max with a default of high on Claude Opus 5 per the models overview), and effort is the main cost lever within one model.

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.1x the input price at OpenAI and Anthropic, 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 $25 per million output tokens.

Cost per 1,000 runs. With five turns averaging 6,000 input tokens and 1,500 output tokens per run: $75 on Claude Sonnet 5, $150 on GPT-5.6 Sol, $187.50 on Claude Opus 5 and $375 on GPT-6 Astra or Claude Fable 5.1. With 70 percent of input served from cache: $37.20, $74.40, $93.00 and $186 or $170.25 respectively. 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.

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 0.1x for cached tokens and 1.25x for the write, and keeps the entry 30 minutes by default. 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, 0.1x for reads. 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'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 97 percent of the time, and the 3 percent break 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-5.6 Luna at $0.20 in and $1.20 out per million tokens, Gemini 3.5 Flash-Lite at $0.30 and $2.50, Claude Haiku 4.5 at $1 and $5), a mid model for extraction and drafts (Gemini 3.8 Flash, Claude Sonnet 5, GPT-5.6 Terra) and a frontier model only for the steps that need multi-step judgment (Claude Opus 5, GPT-5.6 Sol). Prices read on the vendors' pricing pages, 12 September 2026.

What is the cheapest LLM for classification and lead routing?

At list price on 12 September 2026, GPT-5.6 Luna ($0.20 per million input tokens, $1.20 output) and Gemini 3.5 Flash-Lite ($0.30 and $2.50) are the cheapest current models from the three main vendors. On a 600-token classification with a 20-token answer, 1,000 runs cost about $0.14 on Luna 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 12 September 2026: 1,000 invoice extractions at 2,500 input and 300 output tokens cost about $0.86 on GPT-5.6 Luna, $3 on Gemini 3.8 Flash, $8 on Claude Sonnet 5 and $20 on Claude Opus 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.1x the normal input rate at OpenAI and Anthropic (0.025x on Claude Fable 5.1), and 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

• 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