TypeSafe Jev：让AI返回结构化决策而非段落文本

Take a support ticket: I was charged twice. Please fix this ASAP.

With a chat model you usually beg for JSON, then parse prose that was meant for a human. Sometimes the braces close. Sometimes the team field is Billing? with a question mark. Sometimes you get a paragraph and no probability you can threshold.

TypeSafe's Jev is built for that ticket as data, not as a conversation. You send the ticket text as state, plus named questions. You get typed answers and probabilities back. No paragraph. Their name for this shape is System One: models that make fast structured decisions your code can branch on.

Three questions, one call

On that same ticket you might ask three things in one request.

Is it about billing? That is a Noul (yes/no). You get a probability between 0 and 1.

Which team should own it, billing or technical? That is a Choice. You get the picked label, a probability per option, and a confidence.

How urgent is it on a short ordered scale (can wait / this week / today)? That is a Score. The position can land between levels.

TypeSafe evaluates those questions in parallel against the same state. Adding a question does not stack another chat round trip. Their docs are blunt about scope: ask one narrow judgment per question, then combine answers in your own code when you need weights. That is the useful split. The model judges. Your code still owns policy.

I run Hellenic Development. We ship Go infrastructure, including Plexon AI. TypeSafe's official SDKs are JavaScript and Python. Six days after Jev shipped, we released an unofficial Go client and put it on our own product path. I will get to that. First, what other people already built, because the model is easier to understand from uses than from a slide.

What people are building

On 21 September 2026, @Pluvio9yte posted a Chinese list of projects that showed up after the launch. Rough English of the opener: Jev is everywhere right now; if you just got an API key and do not know what to try, copy from this list.

I am not reprinting all twenty. Here are twelve I would open, in groups.

Agents that have to act

browser-use/jev-ultrafast keeps Jev on the decision each step (what to do, which element to click) and only calls a text model when it must type. They clock a Google Flights search around seven seconds.

lahfir/agent-desktop does a similar job on the real desktop: read the OS accessibility tree, then judge which control to hit, instead of squinting at screenshots.

Coding loops that drown in their own tools

tamaratran/fast-jev-compaction asks Jev which tool results still matter for Claude Code, drops the rest, and leaves kept text alone instead of rewriting a summary.

0xNatoshi/jev-codex-router scores how hard the current coding turn looks, then picks model tier, reasoning depth, and speed mode.

ellipsis-dev/blink walks a tree and asks which files are worth opening next.

qkal/Canny looks at tool output, diffs, and tests before it believes an agent that says it is done.

vercel-labs/json-render is Vercel Labs' generative UI work. In the Jev experiments the model picks components, props, and layout instead of streaming JSON one token at a time.

If you want the API inside Claude Code, Claude Desktop, Codex, or Pi with almost no glue, start with itsmostafa/typesafe-mcp or jkudish/jev-mcp. Choice, Score, and Noul show up as tools.

Pipelines and weird ones

sharziki/semdecide puts typed decisions on the shell for crawlers, CI, and filters.

jarrodwatts/jev-trader makes market-style buy/sell judgments on a Monad testnet and quotes model latency around 81 ms per tick.

fhshaik/typesafe-mario plays Super Mario from structured emulator RAM, not pixels.

Star counts will move. The pattern will not: keep policy in code, ask Jev for the small semantic call an if statement cannot make.

github.com/kataras/jev

That is where Go was thin. We needed a client that looks like a Go module: context, options, sentinel errors, shared rate limits, one dependency.

So we shipped github.com/kataras/jev (MIT, v0.1.0).

Product: hellenic.dev/jev

Docs: pkg.go.dev/github.com/kataras/jev

API: docs.typesafe.ai/api

go get github.com/kataras/jev

Set TYPESAFE_API_KEY. The ticket example above is the README example:

client, err := jev.New()
resp, err := client.SystemOne(ctx, jev.Request{
    State: "I was charged twice. Please fix this ASAP.",
    Questions: jev.Questions{
        "billing": jev.Noul{Instructions: "Is this ticket about billing?"},
        "team": jev.Choice{
            Instructions: "Which team should handle this?",
            Criteria: map[string]any{
                "billing":   "Payments, invoices, refunds",
                "technical": nil,
            },
        },
        "urgency": jev.Score{
            Instructions: "How urgent is this ticket?",
            Criteria:     []string{"can wait", "this week", "today"},
        },
    },
})

billing, _ := resp.Noul("billing")
team, _ := resp.Choice("team")
urgency, _ := resp.Score("urgency")

Answers come back under the names you chose. One-question shortcuts exist (Noul, Classify, Rate). SystemOneAs decodes into your own struct; that generic method is why we require Go 1.27. Cost of that choice: older toolchains stay out until they move.

The boring production parts are why I bother publishing a client instead of a gist:

Default pacing sits under TypeSafe's published account caps (1,200 requests/min, 250,000 input tokens/s).

Retries match the JavaScript SDK on 408, 429, and 5xx.

Retry-After pauses every caller that shares the limiter, because the budget is per account, not per process.

Thirteen sentinel errors for errors.Is.

And an Agent Skill so Claude Code, Cursor, Codex, and Plexon read our real signatures:

npx skills add kataras/jev --skill jev -g -y

Unofficial. Not affiliated with TypeSafe. We follow their contract where a Go client should. Where we differ, the README says so. Pin jev-1.13.0 (or whatever version you tested) when a later run must hit the same model. jev-latest moves.

Plexon is our desktop assistant. Chat still uses ordinary language models. The closed decisions next to chat use System One through this client: how hard is this turn, which UI step is next, is this tool result worth keeping while we condense context, how risky is this click or this diff.

The desktop leases a short-lived TypeSafe key from our server, builds a jev.Client in memory, and does not write that key to disk. Those calls usually land in tens to a few hundred milliseconds on our side. That is the point. You do not burn a full chat completion to ask whether a ticket is about billing.

TypeSafe released Jev on 15 September 2026. We tagged kataras/jev v0.1.0 on 21 September 2026 and wired it through Plexon in the same week.

Short on purpose

When a decision model ships with a public HTTP contract and no official Go SDK, a Go shop should publish a careful client and run its own product on it before every tutorial assumes JavaScript.

github.com/kataras/jev

TypeSafe introduction

If you write Go and you have a key, start with the client. If you want the wider map of what people are doing with the model, start from Pluvio9yte's list and TypeSafe's docs. Those are better guides than another company blog from me.