Skip to main content
TypeSafe’s Jev model answers typed questions instead of writing prose. You give it a state — a record, a message, a document — and a set of questions, and it returns one structured answer per question with the probabilities behind it. There is nothing to parse and no output format to coax out of a prompt, so a workflow can branch on the result directly. Every question is evaluated in parallel against the same state in a single call, so asking ten of them costs about as much time as asking one.

Authentication

TypeSafe runs on Cargo credits by default, so you can use it without an account of your own. To bill TypeSafe directly instead, turn off Credits managed by Cargo on the connector and paste an API key created at console.typesafe.ai under Settings → Keys.

Connection details

Credits

TypeSafe charges for the tokens it reads, not the ones it writes, so the cost follows the size of your state and questions — the answers are free. Each call rounds up to the next 1,000 tokens, so a short record costs 0.01 credits however many questions you ask it. Batching questions into one node is therefore cheaper as well as faster: the state is charged once instead of once per node. The exact token count is in the action’s usage.input_tokens output.

TypeSafe actions

Evaluate

Ask one or more typed questions about a state. Configuration State takes plain text or structured data. Passing a record gives Jev the field names as context, so {"employees": 420, "industry": "robotics"} reads better than the same values flattened into a sentence. Each question has a Key — where its answer lands in the output, such as isIcp. The key is not sent to the model, so name it for your workflow rather than for the question.

The three question types

Yes/no

Returns noul, the probability that the answer is yes. There is no separate confidence field, because the probability already carries it — 0.5 is the model telling you it cannot decide.

Choice

Returns the winning option in choice, every option’s probability in probabilities, and a confidence derived from that distribution. Leave an option’s description empty when the name says enough.

Score

Returns a probability-weighted score that can land between levels — a 1.6 across ["Calm", "Frustrated", "Very angry"] sits between frustrated and very angry — plus the legend mapping each level index back to its description.

Output

The node declares its output from the questions you wrote, so downstream nodes pick answers.isUrgent.noul or answers.department.choice from the field list instead of reaching into an untyped blob.

Use cases

One Choice question sends each inbound message to the team that should own it, and its confidence decides whether to route automatically or send it to a human.
Score an account on fit, intent and timing as three separate questions, then weight them in your own formula rather than in a prompt.
Ask whether a reply is interested, an objection, or an out-of-office, and branch the sequence on the answer.
Screen generated copy before it sends, scoring how far off-brand or risky it is.

Best practices

  1. Ask one thing per question — a judgement that weighs several independent factors should be several questions combined in your own logic, not one question that has to reason
  2. Ask everything in one node — questions are evaluated in parallel and in isolation, so batching them is cheaper and faster than one node per question, and adding a question does not degrade the others. Splitting them across nodes pays for the state again each time
  3. Put the rules in criteria, not the instructions — the option and level descriptions are where your domain’s boundary cases belong
  4. Branch on confidence, not just the answer — a low-confidence choice is the model telling you the case is genuinely ambiguous and worth a human
  5. Give the state real structure — a JSON object with named fields beats a flattened string