How to Use Jev with Claude Code and Codex for Triage

Jev is a model from TypeSafe AI that reads unstructured text, like a support ticket or an alert, and returns typed, structured decisions instead of prose: a category, a severity score, or the probability that a statement is true. It answers in well under a second, at a fraction of the cost of a full LLM call, which makes it practical to run on every single event instead of a sampled few.

That's the useful property. Jev is named after William Stanley Jevons, the economist who noticed that when coal got cheaper to use, England burned more of it, not less. The same thing happens to decisions. When classifying a ticket costs a fraction of a cent and a fraction of a second, you stop rationing it. You classify everything, the moment it arrives.

That changes how a support, payment ops, or on-call team should use AI agents. Today most teams either send every ticket to an expensive agent or let a human skim the queue first. Neither scales. The better shape is two layers: a fast model that decides what matters, and a capable agent that investigates what it decides.

This is a guide to building that with Jev as the pre-trigger and a Claude Code or Codex agent running in a Runtime sandbox as the investigator. It covers triage, ranking, investigations, and incident response, with a payment operations example throughout, though the same pattern applies to support and compliance queues.

The short answer. Send every ticket and alert to Jev with a few typed questions: what category, how severe, does it need a human now. Jev returns probabilities in one fast request. Your code applies thresholds and decides whether to start a Runtime agent, queue it, or hand it straight to a person. The agent investigates with read-only access and drafts the answer. A human approves anything that moves money or reaches a customer.

What it does. Every event gets scored the moment it lands, so a missing payroll payout doesn't wait behind forty "how do I change my logo" tickets. Agents only start on work that deserves one, in priority order.

What it is not. Jev doesn't investigate, explain, or reply. It can't read your logs. It is a routing layer, and a bad route should cost you a few minutes, never a wrong refund. Every material improvement comes from a human questioning a premise. Plan for that.

What Jev is

Jev is the first model from TypeSafe AI, released in early access on September 15, 2026. TypeSafe calls it a System One model, after the fast, intuitive half of thinking. Instead of generating text one token at a time, it reads the state you give it and answers typed questions with probabilities, all in a single pass.

It answers three kinds of questions:

You can ask many questions in one request and they are evaluated in parallel, so ten questions take about as long as one.

Here is the difference in practice:

reply = llm.generate(
  "Is this ticket urgent? " + ticket
)

Yes, this looks fairly urgent.
Payroll runs Friday, so I'd
prioritize it.

result = client.system_one(ticket, {
  "urgent": Noul(instructions=
    "Money or a deadline is at risk"),
})

{
  "urgent": {"noul": 0.91}
}

TypeSafe's published numbers: 70 to 500 milliseconds end to end, 40x to 200x faster than frontier LLMs on comparable tasks, and $0.042 per million input tokens with output free. At that price, a 2,000-token ticket costs less than a hundredth of a cent to triage. These are the vendor's claims, so benchmark them on your own tickets.

Two things it can't do. It can't write, so it will never draft a reply or summarize an investigation. And it doesn't explain itself: you get probabilities, not reasons. That second point decides where it belongs in your workflow.

Jev vs. Claude Code and Codex

These aren't competitors, they're different layers. Jev decides, Claude Code and Codex investigate.

Run Jev on everything, and start an agent only on what Jev says deserves one.

How the pre-trigger works

Jev sees everything and decides fast. The agent only sees what Jev sent it, with full context and a priority. The human only sees finished work.

This is the pattern TypeSafe's founder describes for Jev: a decision layer that routes work for other models. In payment ops the split is natural, because most of the queue is sorting and a small part is real investigation.

The stack

Job	Tools
Fast decisions	Jev by TypeSafe
Investigating agent	Claude Code Codex
Tickets	Zendesk Intercom Pylon
Alerts and logs	Datadog Sentry PagerDuty
Payments data	Stripe Modern Treasury A read-only view of your ledger
Approvals and handoff	Slack Linear
Agent infrastructure	Runtime

Runtime is an operating system for coding agents. Each agent gets its own sandboxed computer, a credential vault, network rules, skills that persist between sessions, and a way to start on a schedule or from an event. That last part is what lets Jev hand work to an agent without a human in the middle.

Step 1: Write the questions (human)

This is the judgment step, and it is where the quality comes from. Jev answers exactly what you ask, literally. Vague questions get confident, useless answers.

TypeSafe's own guidance is to ask one specific thing per question and combine the answers in code. For a payment ops queue, a first set might look like this:

Write the level descriptions carefully. "Money has left one account and not arrived in another, or won't arrive before a stated deadline" beats "Critical."

Step 2: Put the thresholds in code

Jev gives you probabilities. What you do with them is your decision, written as plain rules your team can read and change.

Keep the sensitive threshold low. Missing a legal ticket costs far more than a human reading a few false alarms.

Set the numbers from your own history, not from intuition. Take a few hundred tickets your team already triaged, run them through Jev, and see where its answers and your team's disagree. That also tells you whether Jev is good enough for your queue before anything depends on it.

Step 3: Build the triage with Claude Code or Codex

You don't need to write this yourself. Put your TypeSafe API key in an environment variable and ask your agent to build it. TypeSafe has Python and TypeScript SDKs and publishes an agent skill, and community projects like jev-code register Jev as a tool inside Claude Code and Codex.

"Build a small triage service. For each new Zendesk ticket or Datadog alert, send the text and account tier to Jev using the TypeSafe SDK, with the questions in triage-questions.md. Apply the rules in routing.md. Log every Jev response with the ticket ID and the rule that fired. Write tests using the 300 labeled tickets in /fixtures and report where Jev and the labels disagree."

Two habits make these prompts work harder:

• Say why, not just what. "Log every response, because Jev doesn't explain itself and we'll need to audit routing later" gets you better logs than "log every response."
• Name the failure you're preventing. "A ticket that mentions a chargeback must never start an agent, even if severity is low" exists because that is the ticket that hurts.

Step 4: Create the Runtime template

The template is what the investigating agent boots into every time Jev hands it a case: the repos, runbooks, tools, and credentials it can use, and the hosts it can reach.

"Create a Runtime template for payment investigations. Connect Zendesk, Datadog, Stripe, and Slack. Add a read-only connection to the ledger replica. Allow network access only to those hosts. Load every credential from secrets."

Add credentials through the template's secrets in the dashboard, never by pasting them into chat. Then test the limits: ask the agent to write to the replica or issue a refund and confirm it can't.

Attach your runbooks as skills, one per Jev category. When Jev says "payout missing," the agent loads the payout runbook first instead of rediscovering it.

Step 5: Let Jev start the agent

Now connect the two. When a rule says "start an agent," the triage service starts a Runtime session with a case packet: the ticket, Jev's answers, the rule that fired, and the priority.

"When the routing rule is 'investigate now,' start a session from the payment investigations template with the ticket, the Jev scores, and the matched category. Load the skill for that category. Investigate with read-only access, cite every record you used, and post a draft reply and a recommended action to #payment-ops. Never reply to the customer or move money."

For batched work, schedule one agent to pull everything queued since the last run, highest Jev severity first.

Where it fits: support, payment ops, incident response

Incident response is where the speed matters most. When a payouts API starts failing, tickets arrive by the dozen. Asking Jev "is this the same problem as the open incident" on each one takes milliseconds, so one agent works the incident while the rest of the queue stays clean.

For onboarding, KYB and KYC, sanctions and adverse media screening, and AML alerts, the rules are stricter. See how to use Jev for KYC, KYB, and AML.

What stays human

Where it breaks

Jev is new, and TypeSafe is direct about its weak spots. Plan for these from day one.

Numbers and dates. TypeSafe's documentation says Jev struggles with them. Don't ask it whether an amount is over $10,000 or a payout is older than three days. Compute that in code and pass the result as state.

Ticket text is untrusted. Customers write the input, and TypeSafe notes Jev can be misled by adversarial content. Treat its answers as routing hints only. No Jev score should ever grant an agent more access or skip an approval.

No reasons. Jev returns probabilities without explanation. Log every response next to the ticket so you can audit why something was routed where it was.

Literal reading. It answers the question you wrote, not the one you meant. When routing looks wrong, fix the question before blaming the model.

Measuring it

• Time to first touch on high-severity tickets. The number a pre-trigger exists to move.
• Routing agreement. How often your team would have made the same call as Jev plus your rules. Check a sample every week.
• Missed sensitive tickets. Any legal or chargeback ticket that reached an agent. The target is zero.
• Agent runs per resolved ticket. If agents keep starting on tickets that didn't need them, tighten the thresholds.

Measure your current triage first, or you won't be able to show what changed.

A realistic timeline

The point

Cheap decisions change the shape of the work. When triage costs almost nothing, you can score every ticket and alert the moment it arrives, and save the expensive, careful investigation for the cases that deserve it.

Jev decides what matters, the agent investigates in a sandbox, and your team makes the calls that need a name on them.

Back to the queue.