Jev Is Live on Taliiq: Give Your Agent a Classification Tool

Meet Jev: a model that answers instead of writing

Most AI models are built to write, which is exactly what you want for a reply and exactly what you do not want when an agent needs a judgment it can act on. Is this caller upset? Is this a billing question or a technical one? Did they just ask us to stop calling? Asking a chat model for a judgment means coaxing free text into a shape and then parsing it back out.

Jev, from TypeSafe, takes a different route. TypeSafe describes it as the first "System One" model: you send some text (the state) and a set of typed questions, and it returns typed answers directly, with probabilities and, for choice and score questions, a confidence value. It never writes a sentence.

Jev is now live on Taliiq. It lives in its own Classifier catalog, separate from chat models, so it can never be picked as an agent's brain by mistake. You reach it through a new built-in tool called Classification.

What the Classification tool does

You define your questions once, attach the tool to an agent and tell the agent when to use it. When that moment comes, the agent calls the tool, Taliiq sends the recent conversation to the classifier and the agent gets one compact line back:

is_angry=yes (0.99); anger_level=2.6 of 3 (confidence 0.59); insulting=yes (0.98). Uncertain: none.

The classifier never talks to the caller. Your agent's own model still decides what to say, now with a calibrated read on the conversation instead of a guess. The tool works in chat, in voice (cascaded and realtime pipelines) and in Squad process runs.

Three question types

Type	You get	Example
Yes/No	The probability that a statement is true	"The caller asks to stop being contacted"
Pick one	The best option, a probability for every option and a confidence	billing, technical, sales, other
Rate	A score across ordered levels, with a confidence	calm, irritated, angry, furious

All the questions in one tool are evaluated together against the same conversation, so adding a question barely changes the response time. Keep each question about one thing. If you need a combined judgment, ask separate questions and let your agent combine the answers.

Set it up in four steps

1. Connect a classifier provider

Create an API key in your TypeSafe account, then open Manage → Integrations → Classifier Providers in Taliiq and connect TypeSafe. In the tool's model picker every option is labeled, so you can see at a glance whether a run uses Taliiq-funded usage or Your Key, exactly like the brain model picker.

2. Create the tool

Go to Build → Tools, choose Classification under Built-in and pick Jev as the classifier model. Only classifier models are listed here, and each model card shows which question types it supports, so unsupported types are disabled with a reason.

3. Write the questions and the trigger

Start from a template (urgency, lead qualification, opt-out, escalation, callback) or build your own with the question builder. A JSON view is there when you prefer it. Then fill in When should the agent use this? This text is what the agent reads to decide when to call the tool, so write it as a clear instruction. You can also set the confidence floor, the number of recent turns sent and the maximum checks per session.

4. Test, attach and instruct

Open the Test panel, paste a conversation or load a recent session and press Run. You see probability bars, the confidence of each answer, an uncertain badge, tokens used and response time. Nothing is saved by testing, and your unsaved draft runs through the same service the agent uses, so what you see is what the agent gets. When you are happy, attach the tool on the agent's Actions tab and add one line to the agent's instructions, for example: "When the caller sounds upset, run the classification check before deciding what to say."

A worked example: an upset caller, in Arabic

Here is the setup we used to test it ourselves. The agent speaks Arabic, and we wanted it to notice when a customer is angry and change its tone. The tool has three questions:

[
  { "id": "is_angry", "type": "yes_no",
    "instructions": "The customer is angry or upset with the service or the agent." },
  { "id": "anger_level", "type": "score",
    "instructions": "How angry the customer sounds.",
    "levels": ["Calm", "Irritated", "Angry", "Furious"] },
  { "id": "insulting", "type": "yes_no",
    "instructions": "The customer insults the agent or the company." }
]

The trigger text told the agent to run the check when the customer sounds upset and, if they are angry, to apologize sincerely, acknowledge the frustration, slow down and offer to bring in a person. Then we tested it with messages like this one, the way an unhappy customer would write:

أنت لا تفهمني، أنت غبي، ولا أحب خدمتكم
(You don't understand me, you're dumb, and I don't like your service.)

The agent called the tool, and in one of our test runs on a conversation like this the classifier answered is_angry=yes (0.99), anger_level=2.6 of 3 with a confidence of 0.59, and insulting=yes (0.98). Following its instructions, the agent then changed course: it apologized, acknowledged the frustration and offered to connect the customer with a person, instead of carrying on with its script. Notice the middle answer: the score is high but the confidence is only moderate, which is the classifier honestly saying the level is less clear than the yes/no answers. That is a useful signal, and it is why the tool reports confidence at all.

One conversation is not a benchmark. Jev is tested in English today, and while we saw sensible Arabic answers in our own checks, we have not measured accuracy on Arabic dialects. Run the Test panel on your own conversations before you rely on a question in production.

Six use cases with ready question sets

1. Frustration and escalation

Questions: is_urgent (yes/no), frustration (rate: calm, frustrated but civil, very angry) and wants_human (yes/no). Tell the agent to offer a transfer to a person when the caller is very angry or asks for one, and to slow down and acknowledge the problem otherwise.

2. Opt-out and do-not-contact

Question: asked_to_stop (yes/no), "the person asks to stop being called or contacted, or to be removed from the list." Run it before ending an outbound call or scheduling a follow-up, so a request to stop is never missed. It pairs naturally with automatic follow-up calls.

3. Lead qualification

Questions: buying_intent (yes/no) and timeline (pick one: now, soon, later, unknown). Use it when someone asks about pricing or plans, to decide whether to offer a demo, a callback or just information.

4. Support routing

Question: department (pick one: billing, technical, sales, other), plus is_urgent. The agent uses the winning option and its confidence to hand off to the right team, and when confidence is low it simply asks the caller which team they need instead of guessing. In a Squad this pairs with handoffs.

5. Callback intent

Question: wants_callback (yes/no), "the person asks to be contacted again later." Keep the actual time and date in your own systems, since classifiers judge meaning and not calendars, and use this answer only to decide that a callback should be offered.

6. Resolution check

Questions: issue_resolved (yes/no, "the customer says their problem is solved") and needs_follow_up (yes/no). Run it near the end of a conversation to decide whether to close politely, offer more help or flag the session for a person to review.

See every check in your session logs

• Inside the conversation. Each check appears as a Classification card in the Agent Console and in the session's conversation, showing the answers, the confidence, which credentials were used and exactly what the agent received.
• A Classification tab. In Observe → Logs, any session where the agent made checks gets a Classification tab that lists every check in order and counts the uncertain ones. It works for single agents and for Squads, in voice and in chat.
• In the cost breakdown. A Classifier line appears only when the tool actually ran in that session. It shows the input and output tokens reported by the provider. When the run uses Your Key, the tokens show at $0.00 in Taliiq, because your provider bills you directly. For Taliiq-funded usage, the cost is the provider's tokens at the catalog rate plus your plan markup, added to the session cost in the same single charge as everything else.

Sessions that never use the tool look exactly as before.

Best practices

• Write the exact condition. "The caller asks to be removed from the call list" works better than "opt-out." Classifiers read literally, so put boundary cases in the option or level descriptions.
• One question, one idea. Ask "is the caller angry?" and "did they insult us?" as two questions, then combine the answers in the agent's instructions.
• Use confidence. Answers below your confidence floor are reported as uncertain, and the tool tells the agent to ask the caller instead of guessing. Raise the floor for high-stakes actions.
• Keep numbers in code. Arithmetic, counting and date comparison belong in your own systems, not in a classifier.
• Send only what the question needs. The agent sends the last 12 turns by default. Fewer turns are faster and cheaper, and more turns are useful only when the answer depends on earlier context.
• Treat answers as advice. A caller can try to steer any model, so keep confirmations on sensitive actions such as transfers or messages.
• Do not check on every turn. A check takes about a second end to end. In a live call the agent waits for it, so use it where a judgment changes what happens next.

Limits, privacy and cost

• Maximum checks per session. Defaults to 20 and can be set from 1 to 100. It stops a looping model without blocking normal use. At the limit the agent is told the check is unavailable and carries on with the conversation.
• Soft failure. If the classifier is slow or unavailable, the agent is told the check could not run and continues. A classifier problem never ends a call.
• Your data goes to the provider. The recent conversation text is sent to the classifier provider to answer your questions. For that reason the tool is not available on workspaces with Zero Data Retention or HIPAA enabled, or on sovereign hosts.
• Test panel limits. Runs on Your Key are never limited by Taliiq. Runs on Taliiq-funded usage are rate limited per workspace, and testing is never charged because it is not part of a session.
• Text only. Jev reads text. It does not take audio or images, and it cannot generate replies.

Jev reference, in short

This is a plain-language summary of the parts of TypeSafe's documentation that matter most when you use Jev through Taliiq. The TypeSafe docs are the source of truth, and each point below links to the page that covers it.

• System One. A System One model is built to make fast, structured decisions software can use directly, rather than text for people to read. See the introduction.
• Three primitives. Yes/no questions (called Noul by TypeSafe, returning a value from 0 to 1), Choice (pick from a list) and Score (rate on a rubric). Taliiq gives them friendlier names and a provider-neutral shape so future classifier models fit the same tool. See the API reference.
• State and questions. The state is the text you want judged. Jev reads it once and evaluates every question against it in parallel and in isolation, which is why more questions barely add latency and do not interfere with each other. See State.
• Confidence. Confidence is computed from the probability distribution, so a flatter distribution means lower confidence. TypeSafe suggests three ranges: act automatically when confidence is high, proceed with care or confirm when it is medium, and do not act when it is low, with thresholds that scale with the risk of the action. See Confidence and confidence routing.
• Pinned model version. Taliiq pins Jev to a specific version (jev-1.13.0) instead of a moving alias, so answers do not change underneath you when a new release ships. See Models.
• Context size. The state plus the longest question must fit within 32k tokens, and the model card in Taliiq shows the limit the tool enforces.
• Known rough edges. TypeSafe is open about where this version struggles: very literal reading, arithmetic and dates, long chains of indirection, large states full of irrelevant detail, adversarial content and text generation. Each has a simple workaround. See Jev 1.13 jaggedness.
• Ideas and patterns. TypeSafe publishes a use case map, an intent routing pattern and an LLM guardrails cookbook that are good sources of question ideas.

For the LangChain view of the same idea, read Building a Harness with Jev.

Keep reading

• Classification tool guide in the Taliiq docs, with every setting explained.
• Integrations guide for connecting Your Key providers.
• Squads and process runs, where the tool can support routing and decisions.
• Session logs, where the Classification tab and cost breakdown live.
• Realtime voice pipelines, since Classification works in both cascaded and realtime voice.
• Egyptian Arabic and MENA dialect support, if your callers speak Arabic.

Give your agent a calibrated read on every conversation

Connect Jev, add the Classification tool and let your agent know when a caller is upset, ready to buy or asking to stop, before it decides what to say next. Free to start, no card required.

Start Free with Taliiq