A question we get regularly, in some form or another:
DeepSeek costs almost nothing per million tokens. Why can't Reverie just be free?
It's a fair question, and it deserves a real answer rather than a shrug. The premise is even partly correct: some models genuinely are inexpensive per token, and that price is public — anyone can look it up.
What that number doesn't show is everything that has to happen around the model call for a conversation to feel like a conversation. This post walks through that, as concretely as we can.
We've touched on this before. Our post on the credit system explained the multipliers and the reward programs, and the one on free models explained why we launched them despite the uncertainty. Both stopped short of the question people keep asking anyway: where does the money actually go? This is that answer, in more detail than we've given it before.
The model bill is one line item, not the invoice
When you send a message, the model call is the visible part. It's also the only part with a published price tag, which is why it dominates the conversation about cost.
Here's a rough inventory of what else is involved in a single exchange on Reverie:
- Retrieving and assembling context — the character definition, your persona, world books, long-term memory entries, the recent transcript, and any active plugins all have to be fetched, ranked, and fit into a token budget.
- Summarization and memory compression — described in detail below; it's its own model call.
- Moderation — and this is more than a filter on messages. Publishing a character runs its images through a vision model. Reporting a character, a plugin, or a creator kicks off an AI triage pass that reads both the content and the complaint before a human ever looks at it. Plugin revisions get reviewed the same way.
- Storage — every message, every image, every character card, every version of every fork, kept and served indefinitely.
- Infrastructure — application servers, the database and its replicas, caches, queues, CDN, streaming connections held open for the length of every reply.
- Monitoring and observability — error tracking, latency and failure metrics, provider health checks, the logging that tells us a model started degrading two hours ago instead of two days ago.
- Engineering — the people who build the features, and the people who get paged when a provider has an outage at 3am.
- Support and operations — answering tickets, handling refunds, reviewing reports, moderation appeals, payment processing fees, taxes, accounting.
That list isn't exhaustive either — it's the part that's easy to name.
None of those appear on a model provider's pricing page. All of them are real, recurring costs, and most of them scale with usage rather than staying flat.
Here's the part that surprises people most: the model call you can see is only one part of what we pay for. Around it sit the servers, the storage, the background model calls nobody is billed for, and the people who keep the platform running. Those costs do not disappear when one model's token price falls.
We're not going to invent a clean percentage for that; the split moves with usage and we'd rather not quote a number we'd have to walk back. What is stable is the distinction: a provider's API price and a platform's operating cost are not the same number. Lower inference prices reduce one part of the bill. They do not remove everything around it.
Summarization: the feature you're not charged for
This one is worth singling out, because it's invisible by design.
Context windows are finite. If a conversation simply grew forever, one of two things would happen: the oldest parts would silently fall out of the window and your character would start forgetting things, or every message would carry the entire history and get progressively slower and more expensive until it stopped working entirely.
So Reverie summarizes. When a thread gets long, the system compresses the older portion into a narrative summary — preserving the state of the relationship, the emotional dynamics, the unresolved threads — and feeds that into context instead of the raw transcript. It happens automatically, in the background, without you asking for it.
That summarization is itself a model call. It reads a lot of tokens and writes new ones. It happens repeatedly over the life of a long conversation.
We don't bill you for it. There's no line item for "memory maintenance" in your credit history. It's absorbed into the cost of running the platform, because charging users for the machinery that keeps their conversations coherent felt like the wrong trade.
The same logic applies to other background work: context optimization, memory extraction, the pass that decides what deserves to be remembered at all.
The model calls that happen when you're not here
Some of what we pay for isn't attached to a request from you at all.
Proactive messages — a character reaching out first — run on a schedule. A job decides who it makes sense to contact, reads enough context to know what to say, and writes something worth opening. That's a model call per message, for a conversation you hadn't started yet.
Character moments work the same way: generated quietly in the background so a character's page has something new on it, whether or not anyone was chatting with them that day.
Neither deducts credits. There's no charge when a character messages you first, and none when a moment appears. They run on our schedule and our bill.
This is worth sitting with, because it inverts the usual mental model. A meaningful share of our model spend has no user request behind it. It exists because a character who only ever answers feels less alive than one who occasionally starts something — and that difference costs real money, spent speculatively, on conversations that may not get a reply.
Moderation triage belongs in this category too, and it's the strangest case of all. When someone reports a character, the first review pass is a model call — triggered by a stranger, against content you may have published months ago. Neither of you is charged. The same is true when a creator publishes a character and its images go through a vision model: the check runs on our bill, on work we hope turns out to be fine.
Suggested replies, first-response tuning, and the other small quality passes are in the same category. Individually cheap, constantly running, never itemized.
Yes, we use prompt caching
A reasonable follow-up: if the character definition and the early transcript don't change between messages, why pay to send them every time?
We don't, where we can. Prompt caching is already in use, and we track cache hit rates per request specifically so we notice when a change we shipped accidentally breaks a cache prefix.
But the hit rate isn't perfect, and it never will be. Requests are routed across multiple providers through OpenRouter, and a cache lives with the specific provider that created it. Route the next message to a different backend and the cache doesn't come with it. Different providers also expose caching with different semantics, different minimum sizes, and different expiry behavior. Beyond that, the parts of a prompt that change most often — the newest messages, an updated summary, a plugin toggled on — sit exactly where they invalidate the tail of the cached prefix.
Caching meaningfully reduces the bill. It doesn't eliminate it, and treating a theoretical 100% hit rate as the baseline produces numbers that don't survive contact with production.
Myth vs. reality
Myth: DeepSeek costs very little, so every AI website should be nearly free. Reality: The model API is one component of the cost of delivering a finished product. Inference is the part with a public price; everything wrapped around it is the part you never see on an invoice.
Myth: If you just cut the API bill to zero, the product becomes cheap to run. Reality: It doesn't. Infrastructure, storage, moderation, support, and engineering don't go away when tokens get cheaper. Even if the message-time model call cost nothing, those surrounding costs — along with the background model calls described above — would remain.
Myth: Summarization and memory are free features, so they must be free to provide. Reality: They're free to you. Summarization, proactive messages, character moments and moderation passes are all model calls we pay for. Proactive messages and moments can run without a request from you; moderation is triggered by publishing or reports, not by a billable chat message.
Myth: Prompt caching means repeated context is free. Reality: Caching helps a great deal and we use it. Multi-provider routing, cache expiry, and the constantly-changing tail of every prompt mean real-world hit rates land well short of perfect.
Myth: Using a cheaper unofficial API would fix everything. Reality: It can lower one number while raising others — latency, instability, data risk, or roleplay quality. Some unofficial endpoints alter requests or resell access obtained without the provider's authorization. More on that next.
Myth: Free users are a cost the platform tolerates. Reality: Free users are how the platform grows. Many become creators and subscribers. The constraint isn't whether free usage exists — it's whether it stays sustainable.
Why we pay official prices
There is a well-known way to make the model bill much smaller: unofficial, reverse-engineered API endpoints. Their sources differ. Some resell access obtained through routes the provider did not authorize; at the abusive end of that market, some capacity is funded with stolen payment methods.
We don't use them, and we're not planning to. Those channels would cut our model costs substantially. We've looked at them and said no, for two separate reasons.
The first is that it's simply wrong. Where access is obtained or funded through fraud, reselling it is theft with extra steps, regardless of how normalized it has become in parts of this industry. We're not going to fund the platform through those channels and then write posts about transparency.
The second is that it degrades the product, which is the part users feel directly even when they never learn where a response came from:
- Latency goes up. Reverse-engineered routes add hops, queue behind pooled accounts, and throttle unpredictably. The gap between a reply that arrives in two seconds and one that arrives in twelve is the difference between a conversation and a form submission.
- They inject their own system prompts. Many unofficial endpoints wrap requests in a default system prompt of their own before passing them upstream. That prompt is invisible to us and to you, and it fights the character definition. Voice flattens out. Characters break tone, refuse things they shouldn't, or drift toward a generic assistant register. Roleplay quality is exactly the thing that suffers first, and it's the hardest kind of regression to debug when you don't control the prompt.
- They vanish without notice when a provider closes the hole, taking your working setup with them.
- Model versions change silently underneath you, so a character that felt right yesterday responds differently today for no reason anyone can explain.
- There is no accountability for your data. No data processing agreement, no retention policy, no one to ask.
Reverie holds conversations people are genuinely invested in. Routing those through an anonymous middleman to save money is not a trade we're willing to make. Official providers cost more. They also answer the phone, and they don't rewrite your character's instructions on the way through.
The shape of this business
The team is small and Reverie is not a highly profitable business.
There's a structural reason the credit price of a message isn't simply the token cost of that message, and it's worth understanding. Inference is the only part of a conversation that can be metered per message. Everything else in this post — the summarization, the proactive messages, the moderation passes, the storage, the servers, the people — has no natural unit to bill against. Nobody can send you an invoice for "the background job that decided what your character should remember."
So the one meterable thing has to account for more than itself. That's the whole reason a credit system exists instead of a flat token passthrough: if a message cost exactly its own tokens and nothing more, everything around it would be running on nothing, and everything around it is most of it.
We're not trying to maximize profit. We're also not able to operate at a permanent loss, because a platform that runs out of money stops existing, and that's a considerably worse outcome for everyone using it than a credit system with limits.
Between those two constraints, we've deliberately picked the side closest to users. Right now the priority is building the best product we can before an official launch, not squeezing monetization. That means shipping features and improving quality ahead of optimizing conversion, and it means the current economics are looser than they'd be if revenue were the primary target.
Free credits are real costs too
There are quite a few ways to use Reverie without paying:
- the daily check-in reward
- the daily lucky draw, which stacks on top of it
- achievements
- official bounties
- creator rewards
- referral rewards, plus commission when someone you referred buys credits
- share rewards
- redeem codes and gift cards
- the Wrapped year-in-review reward
- community contributions, including helping spread the word about Reverie
It's worth being specific about the draw, since it's the one people assume is decorative. It has five tiers — 1,000 / 2,000 / 8,000 / 30,000 / 80,000 credits — weighted 50 / 30 / 15 / 4 / 1. Multiply that out and the expected value is roughly 4,300 credits per draw, per user, per day, on top of the check-in reward.
Stack it up and the free tier isn't a token gesture. The check-in base is 10,000 credits, streak bonuses add on top — +5,000 on day three, +8,000 on day seven, +50,000 at day thirty, +200,000 at day one hundred — and the draw sits above all of that. On day seven, the expected total is roughly 22,300 credits without spending anything; the actual amount varies with the draw.
How far that actually goes
A fair question at this point is what roughly 22,300 credits buys, and we've never spelled it out clearly.
Credits burn as tokens × the model's multiplier. Multipliers on text models run from 0 to 2, and the model picker shows each one before you send anything. So far, so simple.
The part people underestimate is that the token count isn't fixed — it grows with the conversation. A fresh chat sends a couple of thousand tokens: the character, your persona, a little history. A long-running one sends far more, because the recent transcript rides along on every single turn. We cap the raw history at around 10,000 tokens and summarize everything older, which is exactly why summarization exists: without that cap, a six-month conversation would resend its entire history on every message and the per-turn cost would grow without limit.
In practice that means a turn in a new chat on a 0.3× model costs a few hundred credits, while the same turn deep into a long conversation on a 1× model costs ten thousand or more. Same platform, same day, a difference of more than an order of magnitude.
That range is the honest answer to "how far do my credits go," and it's why the answer feels so different depending on who's asking. If your credits vanish faster than you expected, you're probably deep in a long conversation on an expensive model — and now you know which of the two dials to turn.
The check-in screen itself makes a model call, too. That greeting your character writes when you check in isn't a template — it's generated, cached once per day per character, and capped at a few per day so it can't run away. It's still inference we pay for, on a page whose entire purpose is to give credits away.
There's one more detail in how spending works that belongs here: free credits are always spent before paid ones. If you hold both, the faucet drains first. That's deliberate — credits you actually bought stay yours longer — but it also means the free tier absorbs the cost first, every single time.
Every one of these is a real expense. When you claim a daily reward and spend it on a conversation, the model provider still invoices us, the servers still run, the summarization still happens. The credits are free to you; the compute behind them isn't free to anyone.
We fund those programs anyway, because free access is how most people find out whether this platform is for them, and because a healthy share of today's free users become tomorrow's creators and subscribers. That only works if the free tier stays within what the platform can carry. When the numbers move, the programs get adjusted — not because we'd like to give less, but because giving away more than we can sustain ends with giving away nothing.
If costs come down, so does the price
This part is a commitment rather than a description.
Model prices fall over time. Caching improves. Infrastructure gets more efficient. Our own code gets better at not wasting tokens — most of the quiet work on context assembly and summarization over the past months has been exactly this.
When we find a durable way to lower operating costs, our strong preference is to pass it to users rather than book it as margin. Cheaper models, better multipliers, more generous rewards. We've done that repeatedly and we'd rather keep doing it, because a platform people can afford to use heavily is worth more to us than a slightly better spread.
The word doing the work there is durable. Passing along a saving that turns out to be temporary means taking it back later, and that's worse than never having given it.
What you're actually paying for
When you spend credits on Reverie, you're not buying tokens from a model provider at a markup.
You're paying for a conversation that remembers what happened, that stays coherent past the point where raw context would have collapsed, that runs on providers who are accountable for their uptime and your data, that's backed up and exportable, and that gets meaningfully better every few weeks because there are people working on it full-time.
You might still want more free credits. That's completely reasonable, and we'd like to give you more — we're working on it from the cost side rather than the pricing-page side.
But we'd rather you know why the answer isn't as simple as the number on a model provider's pricing page.
Have questions about a specific charge, or think our numbers are wrong somewhere? Your credit history shows the actual token counts behind every message, and our Discord is open. We'd rather argue about real numbers than vague impressions.
Reward amounts and credit multipliers cited here reflect the platform at the time of publication, and get adjusted as costs move. The app always shows the current values.