If you want to use the new TypeSafe JEV AI Model in your formulas, this pack (aka ‘connector’) provides an interface to the API for the model.
This is a new type of AI model that takes a text prompt just like an LLM, but also receives a STATE object to run the inference against. You then pass it a set of QUESTIONS which it evaluates. But unlike an LLM, it does not return a text response.
Instead, it returns a JSON object containing quantified answers to your specific questions that you can then use in your formulas downstream of the inference.
We have found this approach to be excellent for Business Operations Agentic Workflows where we are looking for maximal determinism and minimal latency.
We are still running prototyping tests, so we have yet to determine our final position on this new approach to AI. We also expect that the major labs will incorporate this paradigm into their mainstream products.
You’ll need to parse the result with Coda’s ParseJSON() / FormulaMap() to pull individual answers back out — reach for the simpler formulas above unless you’re specifically batching several questions per row to save on calls.
JEV FOR SUPERHUMAN DOCS
Connects your doc to Jev, TypeSafe AI’s “System One” model. Jev doesn’t write text — it answers typed yes/no, multiple-choice, and rating questions about text you give it, and returns calibrated probabilities instead of prose. Use it for routing, triage, scoring, and classification inside a doc, not for drafting content.
SETUP
Get a TypeSafe API key from console.typesafe.ai/settings/keys (or your TypeSafe-compatible LangChain access, if that’s how your org provisions it).
In this doc, click Insert, then Packs, then Jev, then click the account icon and paste in your API key.
You’re ready to use the formulas below in any column, button, or canvas formula.
Ask a yes/no question. Returns a probability from 0 (no) to 1 (yes) — not a boolean, so you decide your own threshold.
Example:
JevNoul(thisRow.Email, “Does this convey urgency?”)
JevNoul(thisRow.Ticket, “Is this a refund request?”, “Explicitly asks for money back”, “No refund mentioned”)
Use it as a column formula on a table — it recalculates automatically whenever the source column changes, no button needed.
Pick one option from a list you define (up to 255). Returns choice (the winning option), confidence (0 to 1), and probabilities (a JSON string of every option’s share).
Example:
JevChoice(
thisRow.Ticket,
“Which team should handle this?”,
List(“billing”, “technical”, “sales”),
List(“Payments, invoicing, refunds”, “Bugs, outages, integrations”, “Pricing, upgrades, new accounts”)
)
descriptions is optional — skip it if your option names are self-explanatory.
JevScore(state, question, levels)
Rate text along an ordered rubric (2 to 10 levels, low to high). Returns score (can land between levels, e.g. 1.4), confidence, and legend (a JSON string mapping each level number to its description).
Example:
JevScore(thisRow.Message, “How frustrated is the customer?”, List(“Calm”, “Frustrated”, “Very angry”))
JevAsk(state, questionsJson)
Advanced. Send several questions as a single API call.
I would reccomend spending some time getting to know the LEV model and its different approach to AI inferences by using the public CONSOLE to try it out, before trying to use the pack.
Ok, it looks like the official JEV sign-up site has been taken down due to the crazy demand for accounts.
So we have had to build an alternative pack that uses the similar (not identical) OpenJev model (also known as SemiIF).
You can play with OpenJev / SemIf online at openjev.com
The usage is the same and the results are reported to be 85% the same because it using a different, smaller, open source model.
But for early adopter exploration use cases it is an excellent alternative.
It is hosted on LangChain, so you will need to register an account there and get your API key, before you can use this pack.
OpenJev / SemIf AI For Superhuman Docs
This pack connects your doc to SemIf, an independent open-source model that answers typed yes-or-no, multiple-choice, and rating questions about text you give it, and returns calibrated probabilities instead of written prose. Use it for routing, triage, scoring, and classification inside a doc. It is not a writing tool and will not draft content for you.
WHAT SEMIF IS, AND WHAT IT IS NOT
SemIf, formerly called OpenJev, is an MIT-licensed open-source project built by an independent developer. It reproduces the request-and-response pattern used by TypeSafe’s Jev model using an open model, Qwen3.5-4B, running underneath. It is not made by TypeSafe, it is not affiliated with TypeSafe, and it is not a proxy or gateway to the real Jev model. It is a separate model that happens to speak a compatible interface, so the same kind of formula that would call Jev can call SemIf instead with no changes to how you use it.
This pack calls a hosted copy of SemIf that LangChain runs on its LangSmith Gateway. That hosting is currently offered at no charge through September 28, 2026. Access requires only a free LangSmith account and an API key, not a TypeSafe account, and it works even while TypeSafe’s own signups are closed to new users. If LangChain’s free hosting period ends or changes, this pack will need an update to keep working, since it depends on that hosted endpoint rather than running anything locally.
WHY THIS EXISTS
TypeSafe’s Jev model is currently not accepting new signups due to demand. Anyone who already has direct API access to Jev should use a pack built for that endpoint instead, since it calls the real thing. This pack is for everyone else: it gives you the same three-question-type workflow, callable today, without waiting on a signup queue, using a different model underneath.
SETUP
First, create a free LangSmith account at smith.langchain.com if you do not already have one, and generate an API key from your account settings.
Second, in this doc, click Insert, then Packs, then Agile OpenJev, then click the account icon and paste in your LangSmith API key.
Third, you are ready to use the formulas below in any column, button, or canvas formula.
THE FORMULAS
SemIfNoul asks a yes-or-no question about a piece of text and returns a probability from 0, meaning no, to 1, meaning yes. It is not a plain boolean, so you choose your own threshold for what counts as a confident yes. You can optionally describe what a yes and a no each mean, which sharpens the answer on ambiguous cases.
Example: SemIfNoul(thisRow.Email, "Does this convey urgency?")
SemIfNoul(thisRow.Ticket, "Is this a refund request?", "Explicitly asks for money back", "No refund mentioned")
Used as a column formula on a table, it recalculates automatically whenever the source column changes. No button is required.
SemIfChoice asks the model to pick exactly one option from a list you supply, up to 255 options. It returns the winning choice, a confidence score from 0 to 1, and the full probability breakdown across every option as a JSON encoded text string.
Example: SemIfChoice(thisRow.Ticket, "Which team should handle this?", List("billing", "technical", "sales"), List("Payments, invoicing, refunds", "Bugs, outages, integrations", "Pricing, upgrades, new accounts"))
The descriptions list is optional. Skip it when your option names are already self-explanatory.
SemIfScore rates a piece of text along an ordered rubric you define, with between two and ten levels running from low to high. It returns a score that can land between levels, such as 1.4, along with a confidence value and a legend mapping each level number back to its description.
Example: SemIfScore(thisRow.Message, "How frustrated is the customer?", List("Calm", "Frustrated", "Very angry"))
SemIfAsk is the advanced option. It lets you send several questions about the same piece of text in a single call, which is both faster and cheaper than calling the formulas above separately, since the model only has to read the shared text once. It takes a raw JSON object describing your questions and returns a raw JSON object of answers, which you will need to parse yourself with a formula such as ParseJSON. Reach for the simpler formulas above unless you are specifically batching several questions per row.
TIPS FOR USE
This is a classifier, not a chat model. It cannot answer open-ended questions and will not produce written responses. Every question needs a closed set of possible answers, whether that is yes or no, a list of named options, or an ordered scale.
Pay attention to the confidence value on choice and score answers. A low confidence result means the model saw the available options as genuinely close together, which is worth a second look or a human decision rather than blind trust in whichever option happened to score highest.
Batch related questions together with SemIfAsk when you can. Asking several things about the same row in one call is more efficient than several separate formula calls.
A column built from these formulas recalculates automatically whenever its inputs change. You only need a button if you specifically want control over exactly when a call fires, such as running it once on demand across a large table rather than continuously as rows are edited.
QUALITY AND LIMITATIONS
SemIf is a much smaller model than Jev, and its own published benchmarks are transparent about the resulting quality gap. On a public evaluation subset where TypeSafe has released Jev’s results, SemIf’s direct-logit readout using the 4 billion parameter model agreed with Jev’s published answers on roughly eighty five percent of cases. That is a solid result for an open, self-contained model of this size, but it is a real accuracy gap from the closed, purpose-trained Jev model, not merely a difference in branding or hosting. If your workflow has a low tolerance for classification error, especially in cases with real financial, safety, or compliance consequences, treat SemIf’s answers as a strong first pass that a person should be able to review rather than as a final, unattended decision.
The probabilities SemIf returns are conditional on exactly the options and criteria you provide in your request. They are not independently calibrated against your specific workload out of the box. If you plan to rely on a particular confidence threshold to trigger automated actions, validate that threshold against a sample of your own real data before trusting it broadly, rather than assuming a given confidence number means the same thing across every type of question you might ask.
LICENSING AND ATTRIBUTION
SemIf is released under the MIT license by its original author as an independent research project. It is not endorsed by, affiliated with, or built by TypeSafe, and it does not reproduce Jev’s underlying model or training. The name SemIf, TypeSafe, and Jev remain the property of their respective owners, and no affiliation or endorsement between them and this pack is implied. This pack simply calls the hosted copy of SemIf that LangChain currently makes available through its LangSmith Gateway.
TROUBLESHOOTING
An error reading SemIf error 401 means your API key is missing, expired, or invalid. Reconnect your LangSmith account from the Pack’s account settings and generate a fresh key if needed.
An error reading SemIf error 422 means the request itself was malformed, most often because state was left empty, no options or levels were supplied to a Choice or Score formula, or the JSON passed to SemIfAsk
Use Of TypeSafe JEV & Open JEV in our Superhuman Agentic Workflows
We are sticking with the default Superhuman Docs AI Columns as the main AI engine for our Agentic Workflows.
But our auditors have come up with very specific criteria that must be used when automating critical SOPs using AI workflows.
As well as logging every inference (its inputs and results), they now require every agent to have its results evaluated by a different agent to test the result and provide an extra level of evidence of its correctness.
THAT is where we are now finding the TypeSafe JEV model to be extremely useful (and the open-source alternative OpenJEV aka SimIf).
What we need is SPEED and a high level of DETERMINISM. As well as enough intelligence to understand the inputs, outputs, and the instructions for the test.
On top of that, the tests do not need to generate any structures, texts, or other complex outputs. All we need is a SCORE (0%..100%) or a BOOLEAN (true or false) or a SELECTION from a limited range of options { Pending, In-Progress, Stalled, Completed, On-Hold, …).
For this purpose, the ‘System One Thinking’ models are perfect.
They are very fast and very cheap and way more deterministic than LLMs.
The difficulty is teaching our non-techie makers how to define these tests correctly.
We are also experimenting with using these system one models as part of the core of our agents. But that introduces a ‘routing’ problem - deciding reliably which parts of the inference should use the JEV model, and which part should use the Superhuman model.
We continue to experiment & evolve our approach.
As I have said before, what a wonderful time to be alive and involved in the new revolution!
Max