Jev AI Model Documentation: How to Run, Call, and Get Started (Official Sources)

Reading the official Jev AI model documentation is the best way to understand how this unique system differs from traditional generative tools, allowing developers to route, classify, and score data programmatically. If you want to try jev in a production environment, you will need to learn its core mechanics and constraints. According to the official models reference, Jev’s current API version is jev-1.13.0, with the stable alias jev-latest pointing to it; furthermore, Jev requests are made via the appropriate API endpoint and authenticated with a Bearer token set in the TYPESAFE_API_KEY environment variable, and exceeding its rate limits (around 250,000 tokens/second and 1,200 requests/minute) returns a 429 Too Many Requests response.

Unlike large language models that generate open-ended prose, Jev acts as a strictly typed decision engine for backend infrastructure. It does not write emails, draft code, or chat with users. Instead, it evaluates input context and returns machine-consumable typed decisions in a predictable schema, making it ideal for software logic that requires high reliability without the latency overhead of autoregressive token generation.

This guide maps the complete workflow precisely as the primary developer resources do. You will learn what the architecture entails, where to find the canonical source materials, how to secure an authentication key, the exact endpoint configurations, and how to execute your first call using curl or official SDKs. We will also cover the three foundational primitives, latency expectations, error handling, and gateway alternatives.

What the Jev model is (and what System One means)

Jev is TypeSafe AI’s structured decision model and the first System One model, returning typed values with confidence scores rather than natural-language text. It operates as a strict evaluator, processing a provided state alongside specific questions to yield deterministic, schema-bound answers. Because Jev is developed by TypeSafe AI specifically for programmatic routing, classification, and moderation, it inherently prevents hallucinated string outputs by restricting its response space to predefined categorical or numerical primitives.

This deliberate constraint is what makes the engine so reliable for enterprise pipelines. Instead of parsing a long text string with regex to find an answer, software engineers can simply read a JSON boolean or integer directly from the API response payload.

Jev in one sentence

Jev is a specialized, transformer-based artificial intelligence model that answers strictly typed questions with corresponding probability distributions instead of writing human-readable prose. Its output is designed exclusively to be consumed by downstream software functions rather than read by human end-users.

The model was released in limited early access) on September 15, 2026, alongside a 40 million dollar seed round led by DCVC. Since its introduction, developers have adopted it to replace unreliable, prompt-engineered text models in critical decision paths.

What ‘System One’ means

The designation references the psychological concept of fast, automatic, and intuitive ‘System 1’ thinking popularized by behavioral economics. Jev provides incredibly fast, calibrated decisions meant for immediate routing or classification, completely bypassing the slow, deliberate reasoning processes characteristic of ‘System 2’ chain-of-thought models.

To achieve this capability, the training methodology relies heavily on RLCD (Reinforcement Learning for Calibrated Decisions) applied to vast datasets of synthetic interactions. This approach forces the neural network to express its internal uncertainty accurately across its output probabilities.

• It produces exact confidence intervals for every answer.
• It avoids generating unnecessary explanatory tokens.
• It guarantees the output strictly adheres to the requested data type.
• It minimizes end-to-end latency for real-time applications.

Who is behind it

The engine is engineered by TypeSafe AI, a San Francisco-based research laboratory founded in 2024 by Diogo Almeida, Erik Gafni, and Sasha Sheng. The founding team brings extensive experience in scaled machine learning from previous tenures at organizations like OpenAI.

Their primary thesis revolves around building models that act as reliable software components rather than conversational agents. By focusing on the System One AI architecture and raising significant venture backing, the team is positioning this technology as the default intelligence layer for application backends.

Official documentation and source links

The official Jev documentation is hosted at docs.typesafe.ai, which holds the models reference, quickstart, and API spec. Developers building production systems should always refer back to this central hub for the most accurate and up-to-date information regarding endpoint changes, deprecation schedules, and SDK updates.

Because the ecosystem is evolving rapidly, relying on third-party tutorials or outdated cache data can lead to implementation errors. The official portal provides a unified view of the platform, combining theoretical concepts with practical, copy-pasteable implementation patterns.

Primary (first-party) sources

The canonical domain for all things related to the TypeSafe ecosystem is docs.typesafe.ai. This site contains the comprehensive models reference, which currently documents that Jev’s current API version is jev-1.13.0, with the stable alias jev-latest pointing to it.

Beyond the primary portal, developers should monitor the official model listing endpoint and the TypeSafe SDK repositories hosted on GitHub. These repositories contain the actual source code for the Python and TypeScript wrappers, serving as the ultimate source of truth for library behavior.

• The official models reference page.
• The TypeSafe AI GitHub organization.
• The live API status dashboard.
• The community cookbook repository.

How to read the docs

Navigating the official portal efficiently requires understanding its core structure. The navigation tree is divided logically into foundational concepts, endpoint specifications, and applied examples.

1. Start with the Concepts section to understand the philosophy behind non-autoregressive decision models.
2. Read the Primitives guide to learn how to structure your questions.
3. Review the API Reference for the exact schemas required by the server.
4. Browse the Cookbooks to see real-world architectural patterns.
5. Check the Changelog to verify the capabilities of jev-1.13.0 before deploying.

Get an API key and authenticate

You authenticate by issuing a TypeSafe API key, storing it in the TYPESAFE_API_KEY environment variable, and sending it as a Bearer token. Jev requests authenticate with Bearer TYPESAFE_API_KEY exactly as defined in the official specification, ensuring that all traffic is securely attributed to a registered billing account.

Handling this key securely is the first critical step in integrating the platform. The infrastructure strictly rejects any request lacking this header or presenting an invalid token, immediately returning an authentication failure response.

Issue your key

To acquire credentials, you must first create a registered developer account on the TypeSafe dashboard. Once logged in, navigate to the API Keys section and click the button to generate a new secret token for your workspace.

Be prepared to copy the key immediately, as the dashboard interface will only display the full character string once for security reasons. Note that while the platform is maturing, certain high-capacity early-access keys may still be gated behind manual approval processes for enterprise clients.

Set the environment variable

Local development workflows dictate that secrets should remain outside your application codebase. On macOS and Linux systems, you typically export the variable in your terminal session by executing export TYPESAFE_API_KEY=”your_secret_key” before running your scripts.

On Windows machines, the equivalent operation utilizes the setx command. The official SDKs are designed to automatically detect and read this specific environment variable, eliminating the need to hardcode credentials directly into your client initialization logic.

• Export the variable in your shell profile for persistence.
• Use a .env file loaded by your application framework.
• Configure secrets management in your deployment environment.

Send it on every request

When interacting with the system via raw HTTP calls, the token must be explicitly included in the request headers. This is accomplished by adding an Authorization header formatted precisely as Bearer followed by a space and your API key.

Security best practices mandate that you never commit these keys to version control systems like Git. Always utilize environment variables or secure vault services in production to ensure your infrastructure remains uncompromised and your billing account safe from abuse.

Endpoint, base URL, and model routes

Jev is called via its designated API endpoint, selecting the model with the model field set to jev-latest (currently jev-1.13.0). The Jev API is called via POST /v1/systemone exclusively, meaning developers do not need to manage multiple disparate paths for different types of queries or interactions. When a request is dispatched to this address, the payload must explicitly declare the target version, and setting it to jev-latest points to jev-1.13.0 seamlessly.

Field Name	Accepted Values	Implementation Notes
POST /v1/systemone	N/A	The primary operational endpoint for all evaluation requests.
GET /v1/models	N/A	A diagnostic endpoint listing all currently available versions and aliases.
model	jev-latest, jev-1.13.0, jev-preview	The required parameter in the JSON body specifying the target engine.

Understanding which identifier to provide is crucial for maintaining stable application behavior. The alias jev-latest acts as a rolling pointer, ensuring that requests benefit from routine bug fixes and minor upgrades without requiring codebase changes. It is highly recommended for initial testing, prototyping, and non-critical environments.

However, for rigorous production deployments, engineering best practices dictate pinning the exact version string, such as jev-1.13.0, directly in the request body. Pinning guarantees absolute deterministic consistency in the model’s behavior and confidence calibrations over time, protecting your application logic from unexpected shifts when the provider eventually updates the rolling alias to a newer major generation.

Your first call: curl, Python, and JavaScript

You make the first call by POSTing a JSON body with model, state, and questions to /v1/systemone, using curl or the official Python/JS SDK. The Jev API is called via POST /v1/systemone, and every single evaluation request contains fields model, state, questions to properly instruct the engine. Furthermore, all Jev requests authenticate with Bearer TYPESAFE_API_KEY natively, regardless of which language or client library you choose to implement the integration.

The payload structure is intentionally rigid. The state field holds the context—the raw text, document, or metadata the model needs to analyze. The questions field holds an array of specific, typed inquiries built from the core primitives.

curl quickstart

Testing the integration from the command line is the fastest way to verify your authentication token and network connectivity. You construct a minimal curl command targeting the POST /v1/systemone endpoint, ensuring the Authorization header includes your Bearer token and the Content-Type is set to application/json.

The JSON body passed in the curl request must contain the required structure. You define the model key, provide a simple text string in the state key, and define a basic Noul or Choice in the questions array. The response will return immediately to your terminal, displaying the typed output block and associated probabilities.

Python SDK

For backend environments, installing the official TypeSafe Python SDK via pip provides a robust, typed interface for constructing payloads. When you initialize the client in Python, it automatically searches your system environment for the TYPESAFE_API_KEY, meaning you do not need to pass it explicitly in your script.

You instantiate the client, call the systemone method, and pass your parameters as native Python dictionaries or objects. The SDK handles the serialization, network transit, and deserialization automatically, allowing you to access the typed answer and the confidence distribution directly as object attributes in your application logic.

JavaScript / TypeScript SDK

Node.js and frontend-adjacent environments utilize the official TypeSafe JavaScript SDK, installable via npm or yarn. Similar to the Python library, the JS client executes a fetch-style call under the hood, managing headers and payload formatting automatically based on your initialized configuration.

For TypeScript users, the library is particularly powerful because it infers the exact return types based on the specific primitives you included in the questions array. This means your IDE will provide autocomplete for the response object, ensuring you handle the exact schema correctly without relying on manual interface definitions or guesswork.

The three primitives: Choice, Score, and Noul

Jev answers questions built from three primitives — Choice, Score, and Noul — each returning a typed value with a probability distribution and confidence. Jev exposes primitives Choice, Score, Noul to cover virtually any discrete classification task, and in every case, Jev returns typed values with confidence scores rather than unstructured text. This deterministic output schema allows developers to write robust control flow logic based on statistical certainty.

Because the system never generates freeform strings, the entire evaluation process is heavily optimized for speed. Jev exposes three primitives — Choice (up to 255 options), Score (several ordered levels), and Noul (0–1 probability) — each returning typed answers with confidence, at 70–500 ms latency.

Choice

The Choice primitive is utilized when the application needs to select exactly one option from a mutually exclusive, predefined set. You can provide up to 255 distinct options in the question definition, making it exceptionally powerful for complex categorization and intelligent request routing.

When evaluated, the API returns the winning string along with a complete probability distribution and confidence breakdown across all provided options. For example, a customer support router might use Choice to categorize an incoming ticket as ‘billing’, ‘technical’, or ‘refund’, allowing the backend to instantly forward the state payload to the correct department.

Score

The Score primitive provides a mechanism for rating or grading the state text along a strict ordinal rubric. Developers define between 2 and 10 ordered levels, such as low, medium, and high, allowing the engine to assess qualitative attributes systematically.

The return payload for a Score request includes the selected level and a probability-weighted position across the entire rubric. This is highly effective for risk-rating user submissions or evaluating the quality of a generated document, as the smooth probability curve gives deeper insight into the model’s internal assessment than a flat categorical choice.

Jev is TypeSafe’s flagship model and the first System One model. Every model on this page is served by the same endpoint, POST /v1/systemone.TypeSafe AI

Noul

The Noul primitive represents a fundamental yes-or-no belief regarding the provided state. It is the simplest and often most efficient way to extract a binary decision, returning a probability value strictly between 0 and 1.

The numerical value returned by a Noul evaluation serves directly as the confidence metric; a result of 0.98 indicates a near-certain ‘yes’, while 0.12 indicates a strong ‘no’. This primitive is heavily employed for content moderation pipelines, flagging inappropriate material, or gating user actions based on policy adherence.

Reading the response

Parsing the payload returned from the endpoint is straightforward because the schema maps perfectly to the requested questions. For every primitive submitted in the array, the response object contains a corresponding key holding the typed answer and its specific confidence metrics.

Crucially, parsing errors or hallucinated formats are effectively 0% by construction. Because the neural network’s output layer is constrained to the allowed primitive types at the architectural level, it is mathematically impossible for the response to deviate from the expected JSON structure or invent unauthorized categories.

Limits, latency, pricing, and errors

Jev responds in 70–500 ms, charges per input token with free output, and returns 429 when rate limits (about 250k tokens/sec, 1,200 req/min) are exceeded. Because Jev responds in 70–500 ms, it can be placed directly in synchronous user paths; however, developers must account for the fact that exceeding rate limits returns 429 Too Many Requests instantly. Understanding these operational boundaries is essential for designing resilient software architectures.

The economic and performance profile of a purely evaluative system differs significantly from generative tools. By eliminating the autoregressive output phase, the API allows for massive concurrency and highly predictable cost modeling.

Latency and context budget

The end-to-end latency for a standard request typically falls strictly within the 70 to 500 millisecond window, depending largely on the size of the input payload and network transit times. Furthermore, the endpoint enforces a strict 64k-token per-request context budget.

This budget is divided implicitly: the system allocates a large portion of tokens for the state field, while the remainder accommodates the longest question in the array. It is important to note that the API only accepts text inputs; any images, audio, or complex binary formats must be pre-processed and transcribed before being submitted in the state payload.

Metric Type	Constraint Value	Implementation Notes
Latency Range	70–500 ms	Highly dependent on input token count and geographical routing.
Context Budget	64,000 tokens	Maximum combined limit for state context and question definitions.
Error Threshold	429 Status Code	Triggered automatically when throughput exceeds account allowances.

Pricing

The billing structure is uniquely optimized for evaluation workloads. Users are charged exclusively for input tokens at a specific rate for the tokens processed by the network.

Because the model does not generate conversational prose, output tokens are entirely free. This makes the platform incredibly cost-effective for large-scale classification tasks where massive documents are analyzed to produce a single boolean flag or category choice. Developers looking to optimize their pricing and payment options should focus entirely on trimming unnecessary text from their state payloads.

Errors and 429 handling

Integrating the API requires robust error handling, particularly regarding throughput restrictions. Exceeding Jev’s rate limits (around 250,000 tokens/second and 1,200 requests/minute) returns a 429 Too Many Requests response, halting further processing until the window resets.

To mitigate this, applications should implement exponential backoff strategies and batch multiple questions into a single request payload where logically appropriate. Additionally, if the server returns a 400-level error, it generally indicates a malformed schema; developers should strictly validate their JSON structures against the documentation before dispatching.

Alternative access and when to choose Jev

The primary endpoint is not the only path to the model. Besides the first-party API, Jev can be reached through gateways such as OpenRouter, Vercel AI Gateway, and Cloudflare Workers AI, and is best chosen when you need a fast, typed decision instead of generated text. While Jev is the first System One model available directly from the creator, the broader ecosystem has quickly embraced it, offering developers flexible routing choices. Because Jev returns typed values with confidence scores, it integrates seamlessly into generic LLM orchestration layers that support structured outputs.

Gateways offer unified billing but alter the integration specifics. Jev is also available through third-party gateways including OpenRouter, listed there as jev-1.13. Utilizing services like Vercel AI Gateway, Netlify AI Gateway, Cloudflare Workers AI, or AIMLAPI allows you to manage multiple provider keys in one place. However, developers must be aware that authentication headers, endpoint URLs, and specific routing parameters will differ entirely from the first-party documentation when accessing the model through these intermediaries.

• Configure your OpenRouter routing guide settings for jev-1.13.
• Adjust base URLs for Vercel AI Gateway.
• Update bearer tokens to match the gateway provider.
• Test latency overhead introduced by the proxy layer.

Choosing the right model dictates architectural success. You should choose this specific architecture for gating user actions, classifying support tickets, scoring content quality, and driving conditional logic paths where a fast, strictly typed answer drastically outperforms parsing prose. Conversely, you should stick to a traditional Large Language Model when your application fundamentally requires generating text, drafting emails, engaging in open-ended chat, or performing complex, multi-step chain-of-thought reasoning that cannot be reduced to a single probabilistic choice.

FAQ

Which model identifier is recommended for production?

You can use either jev-latest or jev-1.13.0, as the stable jev-latest alias currently points to version jev-1.13.0. Choosing the specific version ensures fixed behavior, while the alias automatically tracks the latest release.

Why am I seeing a 429 status code?

A 429 Too Many Requests response occurs when your application exceeds Jev’s rate limits. To resolve it, reduce your traffic below 1,200 requests per minute and 250,000 tokens per second or implement exponential backoff.

Can I query Jev directly via HTTP without a dedicated client library?

Yes, you can interact with Jev using standard HTTP tools like curl without an official SDK. All calls are standard POST requests to the /v1/systemone endpoint authenticated with a Bearer token.

Is Jev accessible through external aggregators?

Yes, Jev is available through third-party gateways including OpenRouter. On that platform, the model is listed under the identifier jev-1.13.

What is the expected latency for Jev requests?

Jev delivers typed responses with confidence scores at a latency of 70 to 500 ms. The exact response time depends on the specific primitive invoked, such as Choice, Score, or Noul.

How many options can I evaluate with the Choice primitive?

The Choice primitive supports up to 255 options in a single request. It returns typed answers alongside corresponding confidence metrics.