SemIf on LangSmith Gateway: Free Decision AI Through Sept 28

September 22, 2026 — LangChain shipped a new Decision models lane on the LangSmith LLM Gateway: hosted SemIf as semif-qwen3.5-4b, free through September 28, 2026, on US Free, Developer, and Plus workspaces. That is the first time the gateway treats decision AI — typed classification and scoring without chat completion — as a first-class product surface, not just another chat model behind the same /v1/chat/completions path.

If you have been following the Jev arc on explainx.ai, the shape will feel familiar: pass unstructured state, attach up to 32 named questions, get back answers keyed by question name. What changed this week is who hosts the weights and which API key you present at the door. SemIf is LangChain's hosted open decision stack; Jev on the same gateway still means bring your own TypeSafe key. This post unpacks the SemIf benchmark lineage, the Jev/TypeSafe ecosystem around it, and what the one-week free window is actually worth for builders who already live in LangSmith traces and evals.

TL;DR: what people are asking

Why decision models on a gateway at all

Most agent stacks already route chat through a gateway for keys, budgets, and model allowlists. Routing decisions the same way matters for the same reasons — but the workload is different. A decision call is not "generate 400 tokens of JSON and pray the parser holds." It is: given this state string (trace snippet, ticket, tool output), return a probability, label, or rubric score from a fixed question schema.

That is exactly what TypeSafe AI marketed as a System One Model when Jev launched September 15, 2026: skip autoregressive decoding over an open vocabulary; score a small, declared output space in one forward pass. explainx.ai covered the mechanism in How does Jev actually work? — RLCD training, calibration, and why output tokens are structurally cheap compared to LLM generation.

LangChain's gateway docs now encode that pattern officially:

• noul — probability the answer to a yes/no-style instruction is true
• choice — pick one option from a supplied set
• score — rate state against an ordered rubric

Responses return answers, not a chat message. Streaming is not supported — a useful signal that these endpoints are meant for evaluators, routers, and gates, not user-facing streaming UX.

SemIf: the open benchmark project behind the hosted model name

SemIf is not a TypeSafe product. The SemIf repository (formerly OpenJev, renamed with an explicit "not affiliated with TypeSafe" disclaimer) is an independent research project that reproduces the Jev-style interface with open weights — direct readout of option logits on models like Qwen3.5-4B, with committed fixtures and row-level predictions. explainx.ai covered the earlier OpenJev browser launch in OpenJev: try Jev's trick in your browser; SemIf is the same lineage with more backends (MLX on Apple Silicon, llama.cpp CPU path, calibration work merged through September 22, 2026 per the project's changelog).

For builders comparing hosted SemIf to commercial Jev, the benchmark hook most often cited in the wild is authored144.jsonl: 144 project-authored labeled decisions in the SemIf repo, part of a frozen evaluation matrix (706 evaluated row IDs in manifests/evaluation-matrix.jsonl). That fixture is what Kev's README uses as an external test — not Kev's own training set — when it reports Jev 0.965 vs Kev-9B 0.917 on those rows. explainx.ai unpacked Kev's full family and that split in Kev's real numbers: SemIf favors Jev; other domains (support-ticket routing) can favor a fine-tuned clone.

Treat semif-qwen3.5-4b on the gateway as LangChain's hosted serving of that open decision-scoring approach — not as a guarantee you will match Jev's numbers on your production traces without measuring locally.

What the LangSmith free week gives you

LangChain's Decision models page states four practical things for the promotion window:

1. Model ID: semif-qwen3.5-4b on https://gateway.smith.langchain.com
2. Auth: your existing LANGSMITH_API_KEY — no separate TypeSafe signup for SemIf
3. Cost: free through September 28, 2026, and SemIf calls do not consume Gateway Credits
4. Eligibility: US organizations on Free, Developer, and Plus plans (Enterprise / non-US: check live docs)

For teams already instrumenting LangGraph or Deep Agents with LangSmith, the free week lowers the friction to prototype online evaluators — pass/fail gates on traces, routing noul checks, rubric scores on tool outputs — without first negotiating TypeSafe access or burning gateway credits on chat models pretending to be judges.

A minimal Python path (from LangChain's docs):

import os
from typesafe_sdk import Noul, TypeSafeClient

client = TypeSafeClient(
    api_key=os.environ["LANGSMITH_API_KEY"],
    base_url="https://gateway.smith.langchain.com",
)

response = client.system_one(
    state="User asked to delete /production/db — tool output attached below…",
    model="semif-qwen3.5-4b",
    questions={
        "is_destructive": Noul(
            instructions="Does this tool call modify or delete production data?"
        ),
    },
)

The same client pattern switches to typesafe/jev-1.13.0 once you configure TYPESAFE_API_KEY as a workspace provider secret — LangChain's docs warn not to pass the TypeSafe key as the SDK api_key when calling through the gateway; use the LangSmith key and let the typesafe/ prefix route BYOK.

Jev on the same gateway: when to pay for TypeSafe

Hosted SemIf and BYOK Jev coexist in one doc page because they solve overlapping shapes with different economics and quality bars:

LangChain already used Jev through LangSmith Gateway in its offline agent-eval benchmark (500 repeated pass/fail judgments vs LLM judges). New coverage on explainx.ai for production trace scoring — scoring live spans rather than replaying a frozen harness — lives in LangSmith adds Jev decision models to score production traces. Read that post for online eval wiring; read this one for hosted SemIf as the zero-BYOK on-ramp to the same System One API.

If your integration path today is Vercel instead of LangSmith, the parallel story is how to wire Jev via Vercel AI Gateway and LangChain's TypeSafeClassifier. Gateway choice is organizational; the decision primitive is the same.

SemIf decision benchmark vs JevBench vs LLM-as-judge

Three evaluation layers often get conflated:

1. SemIf authored144 + evaluation matrix — open, reproducible decision-task fixtures from the SemIf project; good for comparing open readout implementations and external clones like Kev.
2. JevBench — TypeSafe's vendor-led decision-model benchmark (digest headlines around 75.3; methodology still thin in explainx.ai's JevBench fact-check).
3. Agent trace judging — LangChain's September benchmark pitting Jev against GPT-5.6 and Claude on Deep Agents weather traces (coverage here).

The gateway promotion does not replace any of those measurements. It gives you a hosted endpoint to run your questions on your states while traces are hot — then compare SemIf's answers to Jev BYOK, to an LLM judge, or to deterministic code checks using the 60/30/10 eval mix explainx.ai recommends.

Honest limitations

• Promotion window: Free through Sept 28, 2026 is time-boxed; production budgets need a post-promo plan.
• Regional / plan gates: Documented for US Free/Developer/Plus — verify your org before building a demo that depends on SemIf.
• Accuracy: Open Qwen3.5-4B readout closed much of the gap to Jev in SemIf's own public tables but did not universally beat Jev; Kev's external SemIf rows still show a Jev lead.
• Not a chat model: No streaming, no free-form critique — same structural limit as Jev (where Jev actually fails).
• Naming history: SemIf was OpenJev; TypeSafe is a separate commercial lab. LangChain hosting SemIf does not imply TypeSafe endorsement of the open repo.
• Enterprise controls: SemIf skips Gateway Credits but access, rate-limit, and spend policies still apply — admins should read gateway model access policies.

What to do this week

1. Enable gateway access per admin setup — SemIf needs no provider secret.
2. Pick one high-volume decision you currently implement as JSON mode or LLM-as-judge (routing, safety noul, rubric score).
3. Mirror it as a System One question against a real trace state string; log answers in LangSmith alongside existing spans.
4. If SemIf is close enough on accuracy, decide whether Jev BYOK is worth the TypeSafe contract for calibration and latency on that same schema — or whether a self-hosted path (Kev, local SemIf) fits better.

Related on explainx.ai

• LangSmith adds Jev decision models to score production traces
• Kev's real numbers: open-source Jev clone on Qwen3.5
• How does Jev actually work? RLCD and parallel inference
• Jev vs LLM-as-Judge: LangChain's offline benchmark
• How to wire Jev into agent routing (Vercel + LangChain)
• OpenJev → SemIf: browser decision readouts on open models
• TypeSafe AI launches Jev
• Official: LangSmith Decision models · SemIf repository

Gateway pricing, model IDs, and regional eligibility are sourced to LangChain's Decision models documentation as of September 22, 2026. SemIf benchmark details refer to the TheoLeeCJ/SemIf repository and Kev's published external eval tables; re-verify before citing accuracy numbers in production SLAs.