JEV Licensing and Deployment Terms
How TypeSafe's licensing terms shape what you can build with its typed AI model.
Jev is a proprietary AI model from TypeSafe AI, and it doesn't work like the language models most engineering teams already have opinions about. Understanding its licensing terms isn't a legal afterthought here: because of how the model is built and delivered, the terms of service function almost like an API contract in their own right, shaping what you can build and what you're exposed to if something goes wrong.
Jev's deployment model and the consequences it has for licensing terms
TypeSafe AI came out of a San Francisco office and launched Jev on September 15, 2026, alongside a $40 million seed round led by DCVC. Forbes put the company's valuation at $200 million around the same time, a striking figure given the product had barely shipped.
Jev isn't a large language model in the sense most people mean now. It doesn't generate paragraphs of text for a person to read. It returns typed values instead: a Choice, a Score, or a Noul (its term for a boolean), each with a probability estimate attached. Choice and Score also come back with confidence scores; Noul returns only the probability. The output is meant to be consumed directly by software, not by a human reading a chat window. TypeSafe describes it as the first "System One model," borrowing the psychology term for fast, intuitive judgment rather than slow deliberate reasoning, which is a reasonable way to describe a model built for bounded decisions rather than open-ended generation.
The company was founded in 2024 by Diogo Almeida, who spent about four years at OpenAI working on RLHF, InstructGPT, and both ChatGPT and GPT-4, along with Erik Gafni and Sasha Sheng. That pedigree matters less for the marketing story and more for what it tells you about the product's design philosophy: a team that spent years on human feedback loops and alignment work built something meant to slot into production pipelines and return a typed answer, fast, instead of prose.
Because Jev is meant to run inside software, not beside a person, its terms of service touch every call your system makes to it. A chatbot's legal exposure is bounded by what a user chooses to type in. A model wired into a decision pipeline, scoring transactions or classifying documents at scale, inherits the licensing terms as an operational constraint.
Access today: from waitlist to open enrollment, and the channels available
Timing matters here because early evaluators operated under different conditions than teams signing up now. When Jev opened in limited early access on September 15, 2026, TypeSafe cleared 140,000 people off its waitlist within 36 hours, a pace that suggests either a very short list to begin with or an aggressive push to get developers testing the product immediately.
Adoption moved fast after that. Within 24 hours, roughly 13% of Vercel's paid AI Gateway teams were already running Jev in some capacity. Within three days, Vercel, Cloudflare, LangChain, and Langfuse had all shipped integrations. Then, on September 20, 2026, the waitlist came down. Anyone can sign up now, and new accounts get $5 in free credit, which TypeSafe says is roughly 120 million input tokens given the pricing structure.
Sign-up happens at console.typesafe.ai. TypeSafe maintains official SDKs in Python and JavaScript/TypeScript, and the ecosystem around it has grown quickly: the Vercel AI SDK supports Jev through the @ai-sdk/typesafe package, and LangChain has a dedicated langchain-typesafe package.
The gateway options are where things get more complicated than a simple SDK install. Vercel's AI Gateway lists Jev as the model typesafe-ai/jev, but use through that channel is subject to both TypeSafe's terms and Vercel's own privacy policy, and the promotional pricing on that channel ends September 25, 2026. OpenRouter serves two TypeSafe models behind a single OpenAI-compatible API at $0.042 per million input tokens, with output tokens free. Cloudflare Workers AI exposes the model as typesafe/jev, with billing that runs through the Cloudflare dashboard rather than TypeSafe's own console. Jev is also reachable through LiteLLM and Netlify's AI Gateway.
That layering puts the request under two sets of data policies at once. Calling Jev through Vercel, OpenRouter, or Cloudflare puts the request under two sets of data policies at once, TypeSafe's and the gateway's. Most teams won't notice this until an audit or a customer contract forces them to trace exactly whose privacy policy applies to a given request, at which point it's a lot more work to untangle than it would have been to check up front.
Pricing structure and rate limits under the standard plan
As reviewed on September 19, 2026, Jev's pricing sat at $42.042 per unit of input, with output tokens free of charge. That promotional pricing is scheduled to end September 25, 2026, so any team budgeting or signing contracts after that date should get current numbers directly from TypeSafe rather than relying on launch-week reporting.
Default rate limits under the standard plan are reported at roughly 250,000 tokens and 200 requests. Teams that need more room; higher-volume production use, latency-sensitive pipelines, whatever the case; can get custom limits and pricing under an enterprise plan by contacting sales@typesafe.ai. The standard plan is clearly built for evaluation and smaller production workloads, not for a team running Jev as the backbone of a high-throughput scoring system.
The four-document legal stack governing every API call
TypeSafe keeps its legal documents on a dedicated page, docs.typesafe.ai/legal, and there are four of them: the Master Customer Agreement, which governs the API product itself; the Data Processing Addendum, which governs how customer data gets handled; the Privacy Policy, covering TypeSafe's own internal data practices; and a Zero Data Retention addendum, available to enterprise customers on request.
One structural point trips people up early. The "Terms of Use" on typesafe.ai governs the marketing website. It has nothing to do with the API. The Master Customer Agreement is the actual operative document for anyone integrating Jev into a product, and in the first days after launch, coverage of the product barely touched it.
Unlike most SaaS signups, the MCA and DPA are separate from the sign-up flow. A team that created an account during open enrollment may need to locate these documents independently. And if that team is calling Jev through a third-party gateway, the legal stack doubles again: TypeSafe's four documents apply, and so do the gateway's own terms, a detail worth checking in TypeSafe's documentation before assuming the overlap is addressed.
What the Master Customer Agreement grants, and to whom
The license grant in the MCA runs one direction: it hands TypeSafe the right to use, copy, store, disclose, transmit, and otherwise process customer data under multiple provisions. Input data can be used during the contract term to perform TypeSafe's obligations under the agreement. Customer Data more broadly can be used during the term to provide the service and calculate fees, which is unremarkable and standard for this kind of contract.
The third provision is the one to read twice. Customer Data can be used to derive and generate usage-related data that TypeSafe retains rights over even after the contract ends. The scope of "Derived Telemetry" isn't fully spelled out in what TypeSafe has published publicly, which makes this the single clause most worth pushing back on before signing anything, particularly for a team sending sensitive or regulated data through the API.
Reinforcing that, the MCA's survival clauses (the sections that keep binding a customer after the contract ends) include Section 4.1, covering use of Customer Data, and Section 4.3, covering Telemetry. The full survival list runs through sections 2.3, 4.1, 4.3, 5, 8, 9, 10.3, 10.4, 11, 12, 13, 14, 15, and 16, which is a long list of obligations that outlive the relationship itself. Data-related duties, in other words, don't end when you cancel.
Data retention, the no-training commitment, and the requirements of "Zero Data Retention"
TypeSafe states publicly that Jev isn't trained on customer requests or responses, and that the model isn't fine-tuned or adapted with a lightweight parameter-efficient tuning technique using customer data. TypeSafe states that customer data is not used to fine-tune or adapt the model for individual accounts. None of that has been independently audited as of this writing. It's a vendor claim, one to take seriously given the source, but not the same thing as a verified certification from a third party.
Zero data retention exists as an option for enterprise customers, reachable through enterprise@typesafe.ai. TypeSafe's legal documentation points to both the DPA and the MCA on the subject, but the fact that ZDR is documented as available doesn't mean it's switched on for any specific account. Activation needs written confirmation, not an assumption based on reading the docs. The same goes for on-premises or private-cloud deployment: if a client needs it, that has to be confirmed directly with TypeSafe, because no public documentation says either option actually exists.
The no-training pledge sits in tension with the perpetual Telemetry clause in Section 4.3 of the MCA. TypeSafe can say, truthfully, that it doesn't train its model on customer input. At the same time, it holds a perpetual right to use that same Customer Data to derive Telemetry. Those two claims don't contradict each other, but they aren't the same commitment either, and a developer who reads only the marketing page and skips the MCA is going to miss that distinction.
EU/GDPR exposure and the transfer compliance burden that falls on the customer
TypeSafe is not certified under the EU-US Data Privacy Framework. Standard Contractual Clauses are in place instead, which makes the transfers lawful on paper. But the Transfer Impact Assessment, the document that has to address exposure under the US CLOUD Act and FISA Section 702, is the customer's responsibility to write. TypeSafe doesn't produce it for you.
That would be a manageable, if tedious, compliance task if the underlying legal ground were stable. It isn't stable. |A top court upheld the Data Privacy Framework's adequacy decision in September 2025, but that ruling is currently on appeal at a higher court. Privacy advocates have raised concerns arguing that recent US Supreme Court decisions undermine the independent oversight requirement the framework depends on. Any EU-based team relying on SCCs here is building on ground that could shift again before the ink on their assessment dries.
Practical recommendations documented by wunderlandmedia.com give EU-based teams a starting checklist rather than a shrug. Push to get Telemetry defined in the contract as anonymized or aggregated, and get the Section 4.1 consent carve-out struck out. Convert the subprocessor objection right into an actual termination right, with a pro-rata refund attached. Insert deletion obligations, a certification requirement, and a 30-day export window directly into the body of the DPA, not left as a vague promise elsewhere. And ask TypeSafe directly for an EU hosting region, or, failing that, for its Transfer Impact Assessment and a SOC 2 report. None of this is exotic. It's the same due diligence any serious legal team would run on a US vendor handling EU personal data, just applied to a company still finding its footing days after launch.
Closed weights and the hard constraint on local or on-premises deployment
Jev's weights are closed. TypeSafe hasn't published a parameter count, and as of the September 15, 2026 release, there's no self-hosting option and no path to building or running the model locally.
The consequence is mechanical and absolute: every call to Jev is an outbound network request, either to TypeSafe's own infrastructure or to a third-party gateway sitting in front of it. On the standard plan, there is no way to keep the processing entirely inside a customer's own environment. For teams working with data that legally or contractually can't leave their infrastructure, that's not a negotiating point, it's a wall.
The open-source project ASD-KONTUR ran into exactly that wall and documented it. The project formally deferred adopting Jev, with a stated trigger for revisiting the decision: reopen the item, the maintainers wrote, "when there is an open-source Jev implementation suitable for fully local deployment (no external API required for project data)." Until that condition is met, the project isn't adopting the model, full stop.
What makes the ASD-KONTUR issue useful beyond its own specific case is the checklist embedded in it, one that any team facing the same decision could reasonably borrow: local or offline inference, licensing on the model and runtime that's actually acceptable for the use case, an internal interface that stays neutral across providers rather than locking to one vendor, some way to measure calibration for the specific domain in question, fail-open or fail-safe behavior when the model call doesn't come back cleanly, and zero external transmission of project data as a hard requirement rather than a preference. Jev, as shipped, can satisfy some of those conditions for some teams. For any team where "zero external transmission" isn't negotiable, the closed-weights, access-through-requests-only model is a core design feature, and teams should treat it as such from the start. It's a disqualifying fact, and it's worth knowing that before the evaluation starts, not after the contract is signed.
