For developers building workflows clients can trust

Code checks every answer.

Your clients trust code, not LLMs. Give them both: Jev answers in a fifth of a second, a rules engine confirms every answer, and anything it can't confirm comes back to you. One API call.

The check is code, not another AI.

Start free Read the docs

Refund emails · act modeJev reads each email; rules confirm its answer
Example
"The $40 lamp came last week and I've changed my mind…"Jev: approve · confirmed by rule small-within-window · 0.2 s
approve
"My order of $320 never arrived and I'll dispute it with my bank…"Jev: ask · confirmed by rule needs-person-review · 0.2 s
ask
"Can I get my money back for the thing from a while ago?"No rule applies · sent back to your workflow, which asks your own AI
not confirmed
Every decision records what Jev read, which rule confirmed it, and why when none did

How it works

You make one call. DataSnack does the rest.

  1. It learns

    While a gate learns, a careful AI decides each request by your policy. DataSnack writes the questions Jev will answer about each request, and rules over Jev's answers, and tests every rule against your history.

  2. Jev answers, code checks

    Switch the gate on: Jev reads each request in a fraction of a second, and the rules must reach the same answer, firmly, before it goes out. No AI checks the AI.

  3. The rest come back to you

    What code cannot confirm comes back unanswered, with the reason, for your own AI or a person. Their answer, sent back, is repeated for that request and the gate learns from it.

One call · a refund email200
POST /v1/gates/refund-emails/decide

{"input": {"customer_tier": "plus",
  "email": "The $40 lamp came last
  week and I've changed my mind…"}}
{ "output": {"decision": "approve"},
  "decided_by": {"tier": "checked",
    "rule": "small-within-window",
    "answered_by": "jev-1.14.0"},
  "ms": 190 }

Why a fast model needs a code check

Built on Jev

Jev is fast and cheap. Code makes it safe to act on.

Jev, TypeSafe's fast model, answers typed questions about text in about a fifth of a second, for a tiny fraction of a large model's price. On its own it is right most of the time and wrong without warning. Checked by rules learned from a careful AI, it is right when it answers, and says so when it cannot.

On 150 refund emails it had not seenAnsweredAgreed with the careful AI
Jev alone, every email100%85%
Jev alone, only when it is 90% sure of itself53%99%
Jev, confirmed by DataSnack's rules73–79%99–100%

Our own test, on synthetic refund emails: rules learned from 250 emails the careful AI decided, then scored on 150 more against its decisions; the range is two runs. Your numbers depend on your decision; the dashboard shows them from your first day.

It keeps checking

Every rule stays on trial.

Re-checked in the background

A share of the answers code confirms is decided again, after the response, by the careful AI the rules were learned from. A rule whose answers drift is switched off on its own, and you are told.

Pinned to one Jev version

When Jev releases a new version, your recent requests are read with both and compared. If answers would change more than reading again changes them, nothing moves until you decide.

One click back

Every rule and every config is versioned. Roll a rule back to shadow, or the whole gate back to learning, in one click.

Three ways to use it

Text or typed fields. Our Jev key or yours.

Jev and rules

For decisions made from text: emails, tickets, notes. Jev reads, rules confirm. Jev is included in every plan.

Rules alone

For decisions made from typed fields: rules answer in microseconds, the same answer every time. Deterministic, end to end.

Your own Jev key

Already a TypeSafe customer? Read with your own key from Settings; your gates use it and TypeSafe bills you directly.

Using it

One endpoint for your code, one MCP server for your agents.

Each gate is an API endpoint from the moment you create it, and a tool on your workspace's MCP server. You integrate once, while the model is still deciding. As rules take over, the request and the response stay the same; the response says what answered.

From your code · REST200
POST /v1/gates/ad-approval/decide
Authorization: Bearer dsk_…

{"input": {
  "price_monthly_usd": 249,
  "term_months": 36,
  "market": "US-CA",
  "channel": "meta",
  "flight_end_day": 20261220,
  "legal_line_present": true }}
{ "output": {"decision": "reject",
             "problem": "price"},
  "reason": "The approved price is $299 a month.",
  "decided_by": {"tier": "rule",
                 "rule": "price-mismatch",
                 "version": 2},
  "ms": 0 }
From your agents · MCPstreamable HTTP
"mcpServers": {
  "datasnack": {
    "url": "https://datasnack.ai/mcp",
    "headers": {
      "Authorization": "Bearer dsk_…"
    }
  }
}
tool    decide_ad_approval
input   the gate's input schema
result  output, reason, decided_by

The same call, before and after

Rules replace model answers behind the same endpoint. Nothing in your workflow changes when a rule goes live, or when one is rolled back.

Code in the answer

Every answer names the rule and version that gave or confirmed it, and on a text gate what Jev read. A rule is code evaluated from memory, in a Go rule engine.

It never hangs on us

Rule answers need neither our database nor a model provider. If Jev cannot be reached, a text request comes back unanswered within two seconds, with the reason, for your workflow to handle.

Where it fits

The gates your clients still have a person check.

Give your client a gate they can trust.

Write the policy, send real requests, and switch it on when its rules pass their tests. One API call. Free while in early access.

Start free Read the docs