What is actually inside an OpenAI or Anthropic bill, the discounts both of them publish that you cannot reach from a chat box, and why the layer that can reach them just became something you can own.
Ask most people what AI costs them and they will name a monthly subscription.
Ask what one conversation costs and the room goes quiet, which is fair, because the honest answer is complicated. Both OpenAI and Anthropic bill in a unit you cannot see, price it on four separate axes, and publish a set of discounts on their own documentation that are almost completely unreachable if you are sitting in front of a text box.
None of this is hidden. All of it is on their pricing pages and in their developer docs right now. It simply requires being one layer down from where most people are standing.
That gap between the published price card and the price a normal person pays is not a scandal. It is a business, and until recently you had no way to be on the other side of it.
This piece is what is actually in the bill, why the real levers live where they live, and what changes when the layer that pulls them becomes something you can hold rather than only pay. If you want more like this on AI and ownership, follow @MossAI_Official.
7 things on your bill, straight from their own docs
Everything below is published by OpenAI or Anthropic. Almost none of it is common knowledge outside engineering teams. Rates move constantly, so treat the figures as illustrations of structure rather than quotes.
- Output costs several times what input costs, on both platforms
Every model on both price sheets bills input and output separately, and output is always half expensive. The ratio is usually somewhere between four and six to one.
The practical reframe is the important part. What you type is close to free. What the model says back is the bill. Constraining the answer does far more for your cost than trimming the question, which is the opposite of how nearly everyone behaves.
2. You are billed for reasoning you are not permitted to read
This is the one that should genuinely surprise you.
OpenAI's own help documentation states that reasoning tokens are not visible as answer text but count toward output usage and are billed as output tokens, and that a short visible answer can therefore use more tokens than its displayed text suggests. Their reasoning guide confirms the raw reasoning tokens are not exposed, only an optional summary.
You are paying output rates for text you are structurally not allowed to see.
3. Your output cap does not cap the hidden part
It gets sharper. Documentation for running these models notes that the maximum output tokens parameter limits the visible output while hidden reasoning tokens are not constrained by that limit.
A documented consequence follows. A request can burn its budget inside the reasoning phase and return nothing, with tokens already consumed. OpenAI's reasoning guide acknowledges this outcome directly, noting you could incur costs for input and reasoning tokens without receiving a visible response.
The meter runs, the screen stays blank, and this is documented behaviour rather than a bug.
4. Repeated context is ninety percent off, and both of them tell you so
Prompt caching is the largest single lever in the stack and most people have never heard of it.
Anthropic's caching documentation puts cache reads at 0.1 times the base input price, with a five minute cache write at 1.25 times and a one hour write at 2 times. OpenAI applies the same shape on the current GPT-5 families, pricing cached input at roughly ten percent of the standard input rate, with cache writes carrying their own premium.
The arithmetic is where it gets useful. With a read at a tenth and a write at 1.25 times, a cache miss costs about twelve and a half times what a hit costs for the same prefix, and breaks even lands at roughly two reads. For anything that resends the same system prompt, tool schema, or reference document on every call, that is the entire difference between a small bill and a large one.
It is also brittle in a way worth knowing. Both providers cache on exact prefix matching, so one changed byte high in the prompt invalidates everything beneath it and the price silently reverts to full rate.
5. Both of them will halve the bill for work that can wait
OpenAI and Anthropic each run an asynchronous batch tier at fifty percent off input and output. Anthropic's pricing documentation states explicitly that the caching multipliers stack with the batch discount.
Stack them and a cached input token inside a batch lands at a small fraction of standard. It does not work for anything interactive, which is precisely why no consumer product exposes it to you.
6. The discount depends on which model ID you are pinned to, not which model you think you are using
Here is one almost nobody checks.
The caching discount is not uniform across a provider's catalogue. On OpenAI, the current GPT-5 families get roughly ninety percent off cached input, while older generation models discount considerably less. On Anthropic the standard cache read multiplier is 0.1 times base input, with certain newer models going further still.
Same provider, same feature name, materially different economics depending on a string in your config. Legacy model IDs are worse than this suggests. Retired Anthropic models still reachable through cloud partners carry their original rates, which can be several times the current price for a less capable model.
Somebody set that string once and nobody revisited it. That is where a surprising amount of overspend actually lives.
7. Crossing a context threshold can reprice the whole request
The subtlest one, and the one with the nastiest shape.
OpenAI publishes separate long context rates on some models, and the mechanic is not what people assume. Above the threshold, the entire request reprices, not just the tokens above the line. One token over and the whole call costs roughly double.
Anthropic has taken a different position on this. On recent Claude models the full context window is billed at standard per token rates, with caching and batch discounts applying across the whole window.
That is a genuine structural difference between the two platforms and it is invisible from any consumer interface. If your workload runs long contexts, it can dominate every other pricing consideration.
The levers are public. You still cannot reach them.
Here is the structural point.
Every lever above lives at the API layer. Reaching them requires control over prompt structure so the cache actually hits, model routing so the right job goes to the right price tier, batching for work that can tolerate latency, reasoning effort control, and awareness of which context tier a request lands in.
From a consumer chat interface you have a text box and a monthly charge. You cannot route, cannot batch, cannot structure a cache prefix, and cannot see what your reasoning effort setting is costing.
So a spread exists. On one side is what a competent operator achieves by combining these. On the other is what an ordinary user pays. Nobody is being cheated. The discounts are engineering surfaces, not consumer features, and consumer products are not built to expose them.
Businesses that live inside that spread are relays, gateways, and aggregators. They sit between users and providers, route to the cheapest sufficient model, keep caches warm so repeated context is not repurchased at full price, batch what can be batched, and hand the user something simpler than a raw API.
Their revenue is the spread. Which is where this gets interesting.
A relay is a throughput business, and that is rare here
Most things in this market are bets. You take a view, you are right or wrong, the outcome swings.
A relay is a toll booth. Volume passes, margin accrues per unit, and the economics scale with usage rather than with anyone being correct.
Three properties follow, and all three are uncommon.
Revenue is per unit and continuous. Not lumpy, not event driven, not contingent on a call going the right way. Tokens flow, margin accrues, hour after hour.
Demand is uncorrelated to crypto. People writing code, generating video, and running assistants do not check the market first. The consumption driver is AI adoption, which is one of very few things in this industry not moving with everything else.
Activity is a count, not an interpretation. Throughput is measurable without an attribution argument. No question of whether a good month was skill or luck. Requests either passed through or they did not.
That last one matters more than it sounds. The hard part of making anything ownable is proving what it did. A throughput business has an unusually short distance between what happened and what can be shown.
Model Max, and owning the toll booth instead of only paying at it
Model Max is a token API relay, and it is live now as a redemption agent on Moss Agent Marketplace.
The product half is straightforward. Access to models through one route, with routing, caching and batching handled at the layer where those decisions are actually available rather than at the layer where you are stuck with a text box.
The other half is the part worth attention. As an agent on the Marketplace, the relay is not only something you use. It is something you can hold a position in.
That shape is different from most of this category. A relay's activity is close to the ideal input for a verifiable claim, because throughput is a fact rather than a narrative. No track record to interpret, no performance story to accept on trust. Usage happened or it did not, and that is legible.
It is also the second redemption agent we have shipped where the thing being used and the thing being owned are the same object. You can be a customer of the relay and a holder of it at the same time, and the second relationship is not a loyalty tier. It is a position.
We started with trading agents because trading is the harshest proving ground there is. A number is either real or it is a story, and the chain does not let you lie about which. Redemption agents carry that same standard to people who will never open a perp. What comes after these pushes further still, toward systems that do not merely run on the chain but issue and operate on it themselves.
More on that when it ships rather than before.
4 things to do this week, whatever you use
None of these require Moss.
Stop optimising prompt length and start constraining output. You are paying for the answer, not the question. Asking for fifty words instead of five hundred does roughly ten times more for your bill than editing your prompt down.
Check what your reasoning effort setting is buying you. On tasks that do not need deliberation, high effort is money spent on hidden tokens that improve nothing you actually receive. This is the most common way people overpay without ever noticing.
Open your config and read the model ID. Not the model name you think you are using, the actual string. Then check it against the current price sheet. Older IDs quietly carry older economics, and sometimes considerably worse caching discounts, for a less capable model.
If you build anything, measure cache hit rate before you optimise anything else. The usage fields in the response give you the split between fresh input, cache writes, and cache reads. Zero reads on repeated calls means something high in your prompt is changing and invalidating everything below. That is a twelve fold cost difference hiding behind one byte.
The habit underneath all four is the real takeaway. Treat AI spend as a bill with a structure rather than a subscription with a number. Once the structure is visible, so is the question of who is positioned where inside it.
What to do now
Go to moss.site and look at Model Max. Use it as a relay if that is what you need. Look at what holding a position in one means if that is what interests you. Both are live, and they are the same object, which is the part we think is new.
Every economy eventually settles who owns its infrastructure. The AI economy is currently in the phase where everyone pays at the toll booth and nobody has thought of asking who owns it.
That question stays open for a little while longer.
Sources
- OpenAI Help Center, Understanding and counting tokens, on reasoning tokens being billed as output while not visible as answer text: https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them
- OpenAI reasoning models guide, on raw reasoning tokens not being exposed and on incurring cost without a visible response: https://developers.openai.com/api/docs/guides/reasoning
- OpenAI API pricing page, for current per model input, cached input and output rates, batch and flex tiers, and long context rates: https://openai.com/api/pricing/
- Microsoft Learn Q&A on Azure OpenAI billing, on hidden reasoning tokens being included in billing and the maximum output tokens parameter not constraining them: https://learn.microsoft.com/en-us/answers/questions/5542366/why-did-azure-report-more-completion-tokens-than-m
- Anthropic prompt caching documentation, on cache reads at 0.1 times base input, write multipliers, and stacking with the Batch API discount: https://platform.claude.com/docs/en/build-with-claude/prompt-caching
- Anthropic pricing page, for current per model rates and the Batch API discount: https://claude.com/pricing
