Jev's pricing model is unusual and it changes the design conversation. Once you understand that input tokens are the cost and that questions in one call run in parallel, a lot of "should we be doing this" becomes "how do we ask it." The API reference and the models page are the source numbers; this is how to reason with them.
Input is the bill, output is free
A Jev answer is a small set of floats under the question ids you sent, and Jev does not generate tokens to produce them. That is the whole reason output is free and the reason the one-request-many-questions design is not a micro-optimization but the default.
So the cost of a decision is roughly the size of the state plus every question, measured in input tokens. Shrinking either one is the only real lever.
The state is where the money is
A long document passed whole is hundreds or thousands of tokens; the same document pre-split with only the relevant field passed is a fraction of that. The pre-parsed extraction cookbook is a cost story as much as a quality one: parsing in code is free, and passing the parsed values keeps the request small.
The practical rule is to send the material a question judges and nothing else. Do not ship the whole ticket history to classify the last message.
Questions are cheap; round trips are not
Every question added to a request costs its own tokens, but asking five questions in one call beats five calls on every axis that matters — one latency, one state, and no duplicated context. The parallel questions cookbook batches them deliberately.
The break-even is straightforward: a second call re-sends the entire state. If both questions share the state, batching them is closer to free than to a doubling.
Estimate before you ship
Work out, on a representative request, the token count of the state and the questions together, multiply by your daily volume, and compare it to whatever the current pipeline costs. The catalog's deployments are candid about where the line falls: a per-tick game loop and a 126-call browser test both live or die on this number, and the testing article walks through how they kept it down.
| Design | What you pay for | When it wins |
|---|---|---|
| One broad question per call | Full state re-sent every call | Never, unless states are tiny and rarely shared |
| Many atomic questions, one call | State once, questions once | Almost always |
| Pre-parsed fields in state | Only the fields judged | Large documents |
| Ask everything the branch needs | A few unused answers | Branchy logic with a fast path |
Do not pay to be told yes
A cheap pattern that wastes money is asking a question whose answer you could have computed. Do not ask Jev whether an amount is over a limit, whether a date is in the past, or whether a list is empty. Those are code. Reserve the spend for the judgments code cannot make, which the use-case map frames as the boundary between deterministic control and model judgment.
The output being free is a design constraint
Because you never pay for output, there is no incentive to ask one question that returns a paragraph. Ask the ten atomic questions you actually need and assemble the answer in code. The composite scoring and fan-out patterns exist because the billing model rewards them.
Read the current per-model input price, count your tokens, batch your questions, and move every arithmetic decision into code. That is the entire cost model.