Jev Limits and What It Cannot Do

Jev limits enforce a request budget of roughly 32,000 tokens, restrict Choice fields to 255 options, and constrain all outputs to typed probabilities rather than generated text.

Jev is a specialized decision model developed by TypeSafe AI. TypeSafe AI founder Diogo Almeida, formerly of OpenAI, released the model in early access on September 15, 2026. It operates as a bounded decision system rather than a conversational large language model (LLM).

At Layer3Labs, we design production classification architectures for business workflows, where enforcing strict boundary caps determines whether an automated pipeline remains reliable. Designing around Jev requires treating it as a calibrated decision engine. You must handle text formatting, calculations, and date comparisons in application code before dispatching a request.

Request Budget and Hard Caps

TypeSafe AI documents a request budget of roughly 32,000 tokens, which equates to approximately 150,000 English characters.

This token ceiling covers both the input context and question definitions. General language models accept much longer inputs. However, Jev serves a different operational purpose. It evaluates classification criteria against bounded state payloads. All questions in a single API call evaluate against that shared state in parallel.

Adding extra questions to a batch increases token usage slightly while leaving latency largely unchanged. Applications handling massive documents must split text upstream. If a document exceeds the budget, chunk it before dispatching the request.

• Total request budget: roughly 32,000 tokens per call.
• Character equivalent: approximately 150,000 English characters.
• Parallel evaluation: all questions assess the shared state simultaneously.
• Token scaling: extra questions add marginal input tokens without inflating response latency.
• Chunking requirement: documents exceeding 32,000 tokens must be segmented in code.

Rate Limits and Early Access Availability

TypeSafe AI has not published official rate limits or requests-per-minute quotas for Jev.

Engineers designing production integrations must account for this omission. Verify current access rules on TypeSafe AI's site as public availability expands. Access remains restricted. The model operates under an early-access waitlist alongside an interactive browser playground.

TypeSafe AI documents no free tier and no trial credits. Every production call requires paid token billing from the start. The official model alias is jev-latest. A Forbes report noted early adoption by Vercel and Cloudflare, which maintains a documentation page for the model.

• Published rate limits: TypeSafe AI has not published requests-per-minute caps.
• Access tier: early-access waitlist with a browser-based testing playground.
• Free tier availability: no free tier and no trial credits documented.
• Model identifier: accessed primarily through the jev-latest alias.
• Platform distribution: documented on the Cloudflare AI platform and featured in Forbes coverage.

Interface and Question Field Caps

Jev restricts question formats to three typed primitives: Choice, Score, and Noul.

Choice questions select one option from a defined set, with options capped at exactly 255 entries. Choice returns the selected option, a set of confidence scores, and a confidence score. Score places input on an ordered scale with descriptive rubric levels. It returns the tier, a distribution, and a confidence value.

Noul represents a boolean statement. It outputs a probability between 0 and 1 without a separate confidence field. The probability itself serves as the decision signal. Input is strictly text-only, with no support for images or audio. Jev does not support streaming responses.

• Choice ceiling: capped at a maximum of 255 options per question.
• Choice return shape: selected option, full probability distribution, and confidence score.
• Score return shape: rubric level, score distribution, and confidence value.
• Noul return shape: probability value between 0 and 1 with no distinct confidence field.
• Modalities: text input only, with no audio, image, or streaming capabilities.

Capability Limits and Code Workarounds

Jev cannot perform arithmetic, counting, date comparisons, indirect reasoning, or adversarial defense.

TypeSafe AI explicitly instructs developers to keep exact calculations in code and make questions direct. Jev lacks internal execution logic. If an application must evaluate invoice discrepancies, code should calculate whether line items sum to the invoice total. You can then pass that computed boolean result to Jev to evaluate business policy compliance.

Counting items or checking calendar intervals also fails inside the model. If an event must occur within thirty days, calculate the date delta in code before calling the API. The community-maintained open-source tool JevSEO demonstrates these boundaries in practice. While JevSEO cannot execute client-side JavaScript when crawling pages, that constraint stems from its crawler architecture rather than the underlying Jev model.

• Arithmetic calculations: compute mathematical totals in code and pass results as context.
• Object counting: calculate array lengths and counts upstream before prompt evaluation.
• Date comparisons: determine timestamp intervals using application code.
• Indirect logic: structure prompts with direct, unambiguous evaluation criteria.
• Adversarial defense: filter untrusted user inputs before passing them into the request state.

Confidence Scores and Calibration Boundaries

Confidence scores in Jev reflect probability distribution shapes rather than verified factual accuracy.

TypeSafe AI trained Jev using Reinforcement Learning for Calibrated Decisions (RLCD). This method targets decision accuracy and probability calibration rather than text generation. However, calibration is a training objective. It is not an accuracy guarantee on individual tasks. A predicted probability of 0.85 indicates model certainty based on training data. It does not ensure that 85 percent of predictions will be empirically correct across your unique production dataset.

On TypeSafe AI's internal workflow dashboard, Jev achieves an aggregate accuracy of 67.8 percent against 74.1 percent for an unidentified best comparator. Individual task accuracy ranges from 61.7 percent to 76.0 percent. TypeSafe AI publishes these figures openly, showing that Jev trades some raw accuracy to achieve lower latency and lower token costs. No third-party or independent benchmark of Jev exists as of September 2026.

• Training objective: Reinforcement Learning for Calibrated Decisions targets probability distribution calibration.
• Confidence calculation: derived directly from distribution spread on Choice and Score fields.
• Accuracy guarantees: calibration does not guarantee empirical precision on novel tasks.
• Internal benchmark results: 67.8 percent aggregate accuracy compared to 74.1 percent for an unidentified comparator.
• Independent verification: no third-party benchmarks have been published as of September 2026.

Pricing Structure and Token Cost Math

Jev pricing is fixed at $0.042 per million input tokens, with output tokens provided at no charge.

To understand the cost ceiling, consider a workload of 100,000 requests where each request consumes 1,000 input tokens. That volume totals 100 million input tokens. On Jev, that pipeline costs exactly $4.20.

Compare that workload against general LLM alternatives, assuming each general model returns 50 output tokens per request. OpenAI charges $0.20 per million input tokens and $1.20 per million output tokens for GPT-5.6 Luna. That same workload on Luna costs $20.00 for input tokens and $6.00 for output tokens, totaling $26.00. Anthropic charges $1.00 per million input tokens and $5.00 per million output tokens for Claude Haiku 4.5. On Haiku 4.5, that workload costs $100.00 for input tokens and $25.00 for output tokens, totaling $125.00. However, Luna and Haiku can generate conversational prose and write code, which Jev cannot do.

• Base pricing: $0.042 per million input tokens.
• Output billing: zero charge for output tokens.
• 100k workload baseline: 100,000 requests at 1,000 tokens costs $4.20 on Jev.
• OpenAI GPT-5.6 Luna: $26.00 for 100k requests ($20.00 input plus $6.00 output).
• Anthropic Claude Haiku 4.5: $125.00 for 100k requests ($100.00 input plus $25.00 output).

Where a Scoring Model Wins and Where It Does Not

Systems built within Jev limits behave more predictably than pipelines reliant on open-ended general models.

Jev eliminates the formatting drift and parsing failures common in conversational models. However, it is not built for teams needing text generation, document summaries, or customer messaging. If your application requires freeform responses or multi-step reasoning, choose a general LLM instead.

Our recommendation would change if TypeSafe AI added generative capabilities or if general models dropped token pricing below dedicated decision endpoints. For teams managing pure classification, start by isolating calculations in your application code. Chunk large documents into 32,000-token payloads and route structured evaluations to Jev endpoints.

• Who this serves: high-volume classification, content triage, and policy routing workflows.
• Who this is not for: teams requiring generative copy, conversational responses, or coding output.
• Trigger for re-evaluation: price decreases on general models or new native reasoning features in Jev.
• Implementation hygiene: isolate math and date logic in code before sending payloads.
• Next architecture step: audit existing classification pipelines to identify boundable decision tasks.