Model vs Product: What You're Paying For

The stack from weights to wrapper: base models, APIs, products built on top, and how to read the AI landscape so you spend money in the right place.

TL;DR: When you pay for AI you are almost never paying for the model itself - you are paying for access to it. The model (a frozen set of numbers called weights) lives at the bottom of a stack. On top sits an API, then products built on that API. Knowing which layer your money goes to tells you what you're actually buying - and what you can build.

The Stack, from Bottom to Top

Every AI interaction you've ever had travels through at least three layers. Understanding each one changes how you make decisions about tools, costs, and what to build.

Layer 1: The weights

A trained model is a frozen set of numbers - billions of floating-point values called weights or parameters - plus code that reads them. Training writes the weights; everything after that is inference (reading them to produce an output). The weights themselves do not change when you use a model. You are not modifying anything; you are running input through a fixed mathematical function and getting output back.

This matters because once a lab trains a model, the cost of that training is sunk. Every inference call after that is cheap by comparison. The lab's job shifts from training to serving - which is an entirely different engineering problem.

Layer 2: The API

An API (Application Programming Interface) is the interface the lab exposes so you can send text in and get text out over the network - without touching the weights directly. You send a request, the lab's infrastructure runs inference, you receive a response. You pay per token: roughly one token per four characters of English text.

Anthropic's API, for example, lets you call models like Claude Haiku 4.5 ($1 / $5 per million input / output tokens), Claude Sonnet 4.6 ($3 / $15), or Claude Opus 4.8 ($5 / $25) - each tuned for a different balance of speed, cost, and capability. The API is a commodity pipe: no interface, no memory across sessions by default, no safety guardrails beyond what the lab bakes into the model. Just JSON in, JSON out.

Layer 3: The product

A product is what gets built on top of the API. ChatGPT is a product built on OpenAI models. Claude.ai is a product built on Anthropic's models. Notion AI, Cursor, Perplexity, Superhuman - all products wrapping one or more model APIs. The product adds the interface, memory, workflow integrations, safety filters, billing management, rate limits, and everything else that makes raw model output actually usable.

When you pay $20/month for ChatGPT Plus or $17-20/month for Claude Pro (annual billing is $17/month; month-to-month is $20), you are paying for the product layer: the chat UI, file handling, memory, integrations, and managed compute - not the raw model. The model is just what sits underneath.

Closed vs. Open Weights: Who Controls the Stack

There is a second dimension that cuts across all three layers: whether the weights themselves are publicly released or kept private.

Closed weights (proprietary models)

Anthropic, OpenAI, and Google keep their flagship model weights private. You can access them only through their APIs or products. This means the lab controls the full stack - training, inference, pricing, terms of service, and data policy. If the lab changes pricing, deprecates a model, or goes offline, your app breaks.

The upside: you get frontier capability without running any hardware. The downside: you have no leverage. You are a tenant, not an owner.

Open weights (open-source models)

Meta's Llama 4, Mistral's models, Google's Gemma 4, Alibaba's Qwen 3.6, and others publish the actual weight files. You can download them, run them yourself, fine-tune them, and deploy them anywhere. You own the stack from the weights up.

The tradeoff is infrastructure cost and complexity. Running a capable open-weight model requires serious GPU hardware - typically $10,000+ to buy or meaningful cloud spend to rent. This is where inference providers step in.

Inference providers: the third option

Groq, Together AI, Fireworks AI, and Cerebras are companies that host open-weight models and charge you per token to call them - just like a closed-model API, but the underlying model is one you could download yourself. They compete on speed, price, and catalog depth. Groq, for instance, runs custom Language Processing Units (LPUs) purpose-built for inference speed. Together AI offers tiered endpoints (Reference, Turbo, Lite) at different quality and cost points.

This creates an interesting middle path: open-model capability at API convenience, without committing to your own GPU cluster.

What You're Actually Buying at Each Layer

Here is the practical breakdown of what each payment buys you:

• Consumer product subscription (e.g. Claude Pro at $17-20/mo, ChatGPT Plus at $20/mo): A managed UI, conversation history, file uploads, integrations, and access to multiple model tiers. No API access by default. Built for human-in-the-loop use. The lab handles all infrastructure.
• Direct API access (e.g. Anthropic API, OpenAI API): Raw model calls billed per token. You build the interface, handle memory, manage rate limits, and own the user experience. Data sent via API is not used to train the model by default - which matters for sensitive use cases in healthcare, law, or finance.
• Enterprise seat (e.g. Claude Enterprise at $20/seat + API rates): Product features plus API-level billing, SSO, audit logs, HIPAA options, and compliance controls. The line between product and API blurs here - you get both.
• Inference provider API (e.g. Groq, Together AI): Same per-token model as a direct API, but serving an open-weight model. Often faster or cheaper for specific models. You take on more responsibility for model selection and prompt engineering.
• Self-hosted open weights: No per-token cost after the hardware investment. Full control over the stack. You own the data pipeline end-to-end. The economics work if your volume is high enough that API spend exceeds the cost of compute.

Reading the Model Naming Game

Model names are not random - they encode the lab's tier strategy. At Anthropic:

• Haiku (Claude Haiku 4.5) - fastest, cheapest, near-frontier intelligence. Best for high-volume tasks where latency matters: classification, routing, extraction.
• Sonnet (Claude Sonnet 4.6) - the workhorse. "The best combination of speed and intelligence," per Anthropic's docs. Covers most production workloads.
• Opus (Claude Opus 4.8) - complex reasoning, long-horizon agentic coding, high-autonomy work. More expensive, slower, worth it for hard problems.
• Fable / Mythos (Claude Fable 5, Claude Mythos 5) - the frontier tier, released June 9, 2026. Both share the same underlying capabilities and pricing ($10 / $50 per million input / output tokens). Fable 5 is generally available; Mythos 5 includes safety classifiers removed, and is available only to approved customers in Project Glasswing in collaboration with the US government.

OpenAI uses a similar pattern: mini / nano / standard / plus / pro variants within a generation. The naming changes; the tier logic is consistent. When you see a model name, ask: where does this sit on the speed-cost-capability curve?

The Hidden Costs That Bite Builders

Token pricing is only the starting point. Real-world API costs include several things the headline price obscures:

• System prompt tokens: Every request includes a system prompt (your instructions to the model). Those tokens are billed as input on every single call. A 2,000-token system prompt sent 100,000 times costs 200 million input tokens.
• Tool use overhead: When you use tools (function calling, web search, code execution), the API adds extra tokens for the tool schema and results. Anthropic publishes exact counts per model - Claude Opus 4.8 adds 290 tokens for tool use with auto mode.
• Retry and error tokens: Malformed responses, rate limit retries, and context re-sends all bill normally. Budget 15-20% overhead for real traffic.
• Context window management: Longer conversations cost more because the whole history is re-sent on every turn. Prompt caching (available on Anthropic's API at 0.1x the input rate for cache hits) can cut this dramatically for repeated context.

Enterprise AI deployment audits regularly find that hidden costs add 40-60% on top of the headline token spend. Price your product accordingly.

Choosing Your Layer

The right entry point depends on what you are building:

# Decision heuristic
if you just need the capability for yourself:
    use the consumer product (claude.ai, chatgpt.com)
elif you are building something for others:
    start with a direct API (anthropic.com/api, openai.com/api)
elif you need a specific open model, lower latency, or lower cost:
    try an inference provider (groq.com, together.ai, fireworks.ai)
elif you have high volume + data sovereignty requirements:
    evaluate self-hosted open weights (Meta Llama 4, Mistral, Qwen 3.6)
elif you need enterprise controls (SSO, HIPAA, audit logs):
    use an enterprise tier of the closed-model product

Most builders start at the direct API and stay there. The economics of self-hosting only favor the open-weight route at serious scale - and even then, the infrastructure burden is real. The inference provider middle path is underused: you get open-model flexibility without running hardware.

Key Takeaways

• A model is a frozen set of weights. You never "own" a closed model; you rent access to it.
• There are three distinct layers: weights, API, and product. Your money goes to a different party and buys different things at each layer.
• Closed-model APIs (Anthropic, OpenAI, Google) do not use your data to train by default - an important distinction from consumer product tiers.
• Open-weight models (Llama 4, Mistral, Gemma 4, Qwen 3.6) let you own the stack. Inference providers (Groq, Together AI, Fireworks) let you use them without running hardware.
• Model naming tiers (Haiku / Sonnet / Opus / Fable, mini / standard / plus / pro) encode speed-cost-capability tradeoffs. Match the tier to the task, not to status.
• Headline token pricing is the floor, not the ceiling. System prompts, tool use, retries, and context management add 40-60% in real workloads.
• Start at the direct API. Move to self-hosting only when API spend exceeds compute cost - and when your team can absorb the infrastructure burden.

Try this next: once you know the layer you are working in, the next question is how to structure what you send to the model. Prompting Basics covers how tokens, context windows, and system prompts interact - the mechanics that determine whether your API spend actually buys useful output.