The 5-Floor LLM Guide for Marketers

Pick the right model for each job—by size, performance, cost, speed, and guardrails.

If you build with AI long enough, you learn that “best model” is the wrong question. The right question is: what’s the right model for this job, given my budget, latency needs, context size, and compliance rules? To make that choice fast (and factual), here’s a five-floor framework you can use to evaluate models for marketing work—from quick ad variants to long-context research and agentic automations.

Below, you’ll also find a Model Picker flow, a token-cost cheatsheet, and three mini case studies with dollar-and-cents examples.

Notes on sources & recency: Pricing and features below reference official provider pages updated in August 2025. Specific citations appear inline.

Ground Floor — Size & Context (How much can the model “hold” at once?)

Why it matters: Many marketing tasks benefit from context: brand guidelines, past campaigns, product catalogs, CRM notes, transcripts, and competitive research. The more you can feed in one go, the less stitching you need.

• Google Gemini 2.5/1.5 Pro: up to 2 million tokens of context in the paid tier (with tiered pricing by prompt size). This is currently the largest widely available context window from a major provider. (Google AI for Developers)

• Anthropic Claude Sonnet 4: standard pricing up to 200K tokens; 1 million-token context is available with a separate “long context” pricing tier and access conditions. (Anthropic)

• OpenAI GPT-5: context capacity varies by variant. OpenAI’s product page lists the API family with up to ~400K context; some documentation for chat-oriented variants lists 128K. (In practice: check the exact model ID you’re using.) (OpenAI, OpenAI Platform)

When long context is overkill: If your task only needs a short brief and a handful of examples (e.g., 30 ad variants from a 1-page creative brief), massive windows don’t buy you much—and you can save real money with smaller, cheaper models.

Practical patterns:

• Use RAG (retrieval-augmented generation) so you retrieve only what’s relevant rather than stuffing a full knowledge base into the prompt.

• When you do need huge context (e.g., auditing a 200-page content library), bias toward models with lower input prices and prompt caching (see Cost Floor).

Second Floor — Performance & Task Fit (Who’s strong at what?)

Different providers optimize for different patterns:

• Reasoning & multi-step tasks (brief-to-outline-to-draft, multi-tool agents): GPT-5 is positioned by OpenAI as its best general model for complex, multi-step problems and “thinking” time, with structured tool use in the API. (You still choose the right variant for your latency and context needs.) (OpenAI)

• Long-document understanding (policies, catalogs, transcripts): Gemini’s 2M context and tiered pricing help when you truly must pass very large context inline. (Google AI for Developers)

• Fast, price-efficient drafting (bulk ad copy, product descriptions, summaries at scale): “mini”/“flash” tiers from providers (GPT-5 mini; Gemini 2.5/2.0 Flash; Claude Haiku) are dramatically cheaper and often plenty capable for well-specified outputs. (OpenAI, Google AI for Developers, Anthropic)

• Open-weights / self-hosting: Meta’s Llama 3.x/3.1 models are distributed under the Llama Community License—commercial use permitted, with conditions (e.g., a special license is required if your products exceed 700M monthly active users). They are not OSI-approved open source despite being openly available. (Good for control/compliance needs when you want to host your own.) (Hugging Face, Open Source Initiative)

Reality check: Benchmarks shift frequently and can be cherry-picked. For marketing workloads, the biggest deltas in business performance still come from prompt design, examples, RAG quality, and post-processing, not small leaderboard gaps.

Third Floor — Cost (Token math that marketers can actually use)

How you’re billed: Nearly all providers charge per input million tokens (MTok) and output MTok. Think of tokens as ~4 characters of English on average; 750–1,000 tokens is roughly 500–700 words.

Current reference prices (USD) as of Aug 2025:

• OpenAI GPT-5: $1.25 / 1M input; $10.00 / 1M output. Cached input (prompt caching) is $0.125 / 1M (≈90% off). Batch API: 50% off inputs/outputs for asynchronous runs. (OpenAI)

• Anthropic Claude Sonnet 4: $3.00 / 1M input; $15.00 / 1M output. Batch API: 50% discount; long-context (>200K input tokens) has premium rates. (Anthropic)

• Google Gemini 2.5 Pro: $1.25 / 1M input and $10.00 / 1M output for prompts ≤ 200K (higher tier above that); supports context caching with storage priced separately. Batch mode: 50% of interactive price. (Google AI for Developers)

Cost formula: Total = (Input_Tokens ÷ 1,000,000 × Input_Rate) + (Output_Tokens ÷ 1,000,000 × Output_Rate) If you enable prompt caching and reuse a large system/brief across many jobs, cached portions bill at the cached input rate where supported.

Token-cost cheatsheet (examples)

Below are apples-to-apples one-run estimates using the official list prices above. Numbers are small by design to match real marketing tasks.

Example A — 30 ad variants from a 2-page brief
Assume 2,500 input tokens (brief + examples) and 1,500 output tokens (30 variants).

• GPT-5:

  • Input: 2,500 ÷ 1,000,000 × $1.25 = $0.003125

  • Output: 1,500 ÷ 1,000,000 × $10.00 = $0.015

  • Total ≈ $0.018125 (about 1.8 cents)

• Claude Sonnet 4:

  • Input: 2,500 ÷ 1,000,000 × $3.00 = $0.0075

  • Output: 1,500 ÷ 1,000,000 × $15.00 = $0.0225

  • Total ≈ $0.0300 (about 3.0 cents)

• Gemini 2.5 Pro:

  • Input: 2,500 ÷ 1,000,000 × $1.25 = $0.003125

  • Output: 1,500 ÷ 1,000,000 × $10.00 = $0.015

  • Total ≈ $0.018125 (about 1.8 cents)
    (Prices from the official pages cited above.) (OpenAI, Anthropic, Google AI for Developers)

Example B — 5-email sequence
Assume 1,000 input tokens (brief + product facts) and 1,000 output tokens (5 emails × ~200 tokens).

• GPT-5: 0.001 × $1.25 + 0.001 × $10.00 = $0.00125 + $0.01 = $0.01125

• Claude Sonnet 4: 0.001 × $3.00 + 0.001 × $15.00 = $0.003 + $0.015 = $0.018

• Gemini 2.5 Pro: 0.001 × $1.25 + 0.001 × $10.00 = $0.00125 + $0.01 = $0.01125 (OpenAI, Anthropic, Google AI for Developers)

Example C — Sales insights from CRM notes via RAG
Assume 6,000 input tokens (query + retrieved passages) and 800 output tokens.

• GPT-5: 0.006 × $1.25 + 0.0008 × $10.00 = $0.0075 + $0.008 = $0.0155

• Claude Sonnet 4: 0.006 × $3.00 + 0.0008 × $15.00 = $0.018 + $0.012 = $0.030

• Gemini 2.5 Pro: 0.006 × $1.25 + 0.0008 × $10.00 = $0.0075 + $0.008 = $0.0155 (OpenAI, Anthropic, Google AI for Developers)

Batching & caching tip: If you run these at scale, enable Batch/Async (OpenAI & Anthropic: ~50% discount) and prompt caching for repeated system/brand briefs (OpenAI & Google list explicit cache pricing; Anthropic offers prompt caching with specific multipliers). (OpenAI, Anthropic, Google AI for Developers)

Fourth Floor — Speed & UX (How fast does it feel for users?)

For interactive experiences (live chat, on-site assistants, sales enablement tools), perceived speed matters more than raw throughput.

• Realtime/Live APIs:

  • OpenAI exposes a Realtime API for low-latency multimodal experiences (voice/video/streaming). Choose lighter variants if you need snappy responses. (OpenAI)

  • Google exposes Live API pricing for Gemini Flash/Flash-Lite (interactive/streaming), distinct from batch rates. (Google AI for Developers)

Rules of thumb:

• For assistive UI (drafting, rewriting) target first token in < 1s and full response in < 3–5s.

• For agentic, multi-tool flows (search → plan → write → cite), stream progress and parallelize tool calls where possible.

• If a job doesn’t need to feel instant (e.g., bulk ad refresh or report generation), run it in batch at 50% price and deliver when ready. (OpenAI, Anthropic)

Fifth Floor — Guardrails, Privacy & Licensing (What can you safely ship?)

Data usage defaults (API & business tiers):

• OpenAI: For business products (ChatGPT Team/Enterprise/Edu) and API, OpenAI does not train on your business data by default; you own your inputs and outputs (where allowed by law). Opt-in programs exist. (OpenAI)

• Anthropic: Documentation and support pages state Anthropic will not use your inputs/outputs to train Claude unless you explicitly opt in or report content. (Anthropic Privacy Center)

• Google (Gemini for Cloud / Gemini API): Google Cloud’s governance docs state Gemini for Google Cloud doesn’t use your prompts/responses to train models. Gemini API terms include additional data-handling specifics; review your tier and toggles (e.g., “Used to improve our products” settings). (Google Cloud, Google AI for Developers)

Open weights (Llama) & “open source” claims:

• Meta’s Llama 3.1 license permits commercial use, but with notable conditions, including a separate license requirement if your products exceed 700M MAU. The license is not OSI-approved “open source.” (Translation: it’s openly available, not open source in the OSI sense.) (Hugging Face, Open Source Initiative)

Safety controls & compliance:

• Favor providers with clear enterprise privacy docs and regional/data residency options if you operate in regulated environments. OpenAI, Anthropic, and Google maintain public privacy and compliance pages. (OpenAI, Anthropic, Google AI for Developers)

• For brand safety, implement policy-aware prompts and test suites. Many providers expose moderation tools or guidance in docs; you should still add your own pre/post filters for claims, regulated terms, and bias.

The Model Picker (fast decision flow)

Step 1 — Context size

• Need >200K tokens inline? Consider Gemini 2.5/1.5 Pro (up to 2M) or Claude Sonnet 4 with long-context pricing (1M), then weigh costs. (Google AI for Developers, Anthropic)

• If your prompt + inline docs are ≤200K tokens, or you can solve it with RAG (fetching only small, relevant chunks)

Step 2 — Latency vs. depth

• Live UX (<3s perceived): Try mini/flash tiers first (e.g., GPT-5 mini, Gemini Flash/Flash-Lite; Claude Haiku). (OpenAI, Google AI for Developers, Anthropic)

• Deep reasoning / multi-step: Use GPT-5 or Claude Sonnet 4; stream output and cache the long, repeated brief. (OpenAI, Anthropic)

Step 3 — Cost sensitivity

• For bulk generation, prioritize lower input rates and batch/caching. (OpenAI & Anthropic list 50% batch discounts; OpenAI & Google list prompt caching prices.) (OpenAI, Anthropic, Google AI for Developers)

Step 4 — Hosting & control

• Need self-hosting or VPC-only? Evaluate Llama 3.x under the Community License and your compliance needs. Remember: not OSI-approved open source. (Hugging Face, Open Source Initiative)

Step 5 — Data handling

• Strict “no training” posture required? Confirm defaults and agreements: OpenAI business/API (no training by default), Anthropic (no training unless opted in), Google Cloud Gemini (docs state prompts/responses aren’t used to train). (OpenAI, Anthropic Privacy Center, Google Cloud)

Mini Case Studies (with realistic costs)

1) Email Nurture Sequence (5 emails)

Brief: New feature launch sequence; use brand voice and two example campaigns.
Process:

1. Embed a short style guide and feature notes (≈1,000 tokens).
2. Ask for a 5-email plan, then drafts (≈1,000 output tokens).
3. Optional) Run a second pass for compliance language and CTA testing (+500 output tokens).

One-pass cost at list prices:

• GPT-5: $0.01125 (from Example B). (OpenAI)

• Claude Sonnet 4: $0.018. (Anthropic)

• Gemini 2.5 Pro: $0.01125. (Google AI for Developers)

Recommendation: Start with GPT-5 or Gemini for first drafts; escalate to Sonnet 4 if you need deeper reasoning or tool use.

2) Paid Social Variant Factory (30 variants × weekly)

Brief: Weekly refresh of hooks and descriptions for 3 audiences; include 2 example winners.
Process:

• Single prompt with audiences, brand lines, and “do/don’t” rules (≈2,500 input tokens).

• 30 concise variants (≈1,500 output tokens).

• Save brand brief in prompt cache (OpenAI/Gemini) so subsequent weeks bill cached input at ~90% off (OpenAI) or at the provider’s cache price. (OpenAI, Google AI for Developers)

Per-run cost at list prices:

• GPT-5: ≈ $0.0181; with caching, the repeated input can drop ~10× on the cached portion. (OpenAI)

• Claude Sonnet 4: ≈ $0.0300 (consider Sonnet 4 batch if you run this asynchronously). (Anthropic)

• Gemini 2.5 Pro: ≈ $0.0181; cache/storage billed per Gemini’s schedule. (Google AI for Developers)

Recommendation: For steady, repeatable outputs, “mini/flash” tiers crush cost while maintaining quality—especially with prompt caching.

3) Long-Form Insight Synthesis (200 pages of research)

Brief: Turn a 200-page competitive dossier into a 3-page insight memo with citations.

Two viable patterns:

1. True long-context run (only if you must): use Gemini Pro 2.5/1.5 (2M tokens) or Claude Sonnet 4 long-context (1M). Costs rise as input tokens climb above 200K; check tiered pricing. (Google AI for Developers, Anthropic)
2. RAG pipeline (recommended): chunk & embed sources; retrieve only relevant passages per section (typical request: 5–10K input tokens, 1–1.5K output). On per-call math, RAG often costs ~10–50× less than dumping everything into context, and it’s more controllable.

Illustrative per-section cost with RAG (≈6K in / 1K out):

• GPT-5: ≈ $0.0155 per section; multiply by the number of sections you compile. (OpenAI)

• Claude Sonnet 4: ≈ $0.0300 per section. (Anthropic)

• Gemini 2.5 Pro: ≈ $0.0155 per section. (Google AI for Developers)

Implementation Patterns That Save Real Money

1. Separate “thinking” from “writing.”

• Plan/outline with a mini/flash model.

• Draft/polish only if needed with a larger model.
  (You’ll cut output-token costs on the expensive model.)

2. Cache what you repeat.

• Brand voice, terminology, compliance notes—keep them stable and cached. OpenAI lists ~90% off cached input; Google publishes cache + storage prices. (OpenAI, Google AI for Developers)

3. Batch when UX doesn’t matter.

• If nobody’s staring at a spinner, schedule generation in batch and take the 50% discount (OpenAI & Anthropic). (OpenAI, Anthropic)

4. Right-size the output.

• Output tokens are the expensive half. If you don’t need a 1,500-token answer, ask for 200–400 tokens and a bullet structure.

5. Use RAG, not copy-paste.

• Embed once, retrieve small. This is the single biggest lever for long work.
  
  

Compliance & Policy Checklist (ship this with stakeholders)

• Data Training Defaults Confirmed:

  • OpenAI business/API: no training by default; outputs owned by you (where allowed). (OpenAI)

  • Anthropic: no training unless you opt in / report content. (Anthropic Privacy Center)

  • Google Cloud Gemini: prompts/responses not used to train; review API/App toggles. (Google Cloud)

• Licenses:

  • If self-hosting Llama, document the Community License terms (and the 700M MAU clause). Note: not OSI open source. (Hugging Face, Open Source Initiative)

• Audits & Logging:

  • Log prompts, retrieved docs, and model IDs. Keep a reproducible paper trail for claims review.

• Moderation & Brand Safety:

  • Add pre-flight checks (e.g., restricted phrases) and post-flight QA (e.g., claim spotting) before publishing.

Putting It All Together — Your “5-Floor” Playbook

Ground Floor: Size/Context

• Pick Gemini Pro or Claude long-context when you must inline huge context; otherwise use RAG and right-size. (Google AI for Developers, Anthropic)

Performance Floor: Task Fit

• GPT-5 / Sonnet 4 for complex, tool-rich tasks; mini/flash tiers for fast drafting. (OpenAI, Anthropic, Google AI for Developers)

Cost Floor: Token Math

• Know your input/output rates; exploit batch and cache. (OpenAI & Anthropic batch 50% off; OpenAI & Google publish cache pricing.) (OpenAI, Anthropic, Google AI for Developers)

Speed Floor: Latency

• For interactive flows, use Realtime/Live APIs and smaller models where possible. (OpenAI, Google AI for Developers)

Guardrails Floor: Safety/Licensing

• Document data-training defaults and Llama license terms; align with legal and IT before scale-up. (OpenAI, Anthropic Privacy Center, Google Cloud, Hugging Face, Open Source Initiative)

Quick Reference — Current Pricing (Aug 2025)

• OpenAI GPT-5: $1.25 / 1M input, $10.00 / 1M output; cached input $0.125 / 1M; Batch API: –50%. (OpenAI)

• Anthropic Claude Sonnet 4: $3.00 / 1M input, $15.00 / 1M output; Batch API: –50%; 1M context tier with premium rates above 200K. (Anthropic)

• Google Gemini 2.5 Pro/1.5 Pro: $1.25 / 1M input, $10.00 / 1M output (≤200K tier); context caching priced separately; Batch Mode: 50% of interactive. Up to 2M context. (Google AI for Developers)

Footnotes on context sizes (why you’ll see different numbers)

Vendors list families of models and variants (chat vs. API, mini vs. large), each with potentially different context windows. For example, OpenAI’s public product page references GPT-5 API family with context listed “up to ~400K,” while a chat-specific doc references 128K for a particular “chat-latest” variant. Always check the exact model ID you deploy and your account limits before promising a number to stakeholders. (OpenAI, OpenAI Platform)

Bottom line: Treat models like tools on different floors of the same building. Start at Ground (context) and move up: Performance, Cost, Speed, Guardrails. Make the choice that fits the job, not the hype—and your team will ship faster, cheaper, and safer.

Prepared with current, primary sources; last verified August 19, 2025.