Ask Jev, a fast non-generative judgment model, one or more plain-language questions about material you already have, and get calibrated probabilities back instead of a generated sub-agent response.
Ask yes/no questions and receive the probability of "yes".
Ask scale/rating questions; provide ordered options for a custom rubric or let a built-in rubric (severity, likelihood, sentiment, etc.) be chosen automatically.
Ask choice questions among named alternatives and get probabilities per option.
Batch multiple questions about the same state in one round trip.
Get per-answer probabilities, confidence, routing metadata, and optional token usage/model info.
Handle individual bad questions gracefully: one error does not fail the rest of the batch.
Works locally via stdio or hosted over HTTP, with support for several MCP clients (Claude Code, Claude Desktop, Cursor, Codex).
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@askjev Based on this customer email, should we offer a refund?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Unofficial MCP server for Jev, Typesafe AI's System One model. Not affiliated with Typesafe AI.
Give your agent a fast second opinion. It asks a plain question about material it already has, Jev works out whether that is a yes/no, a scale, or a choice, and answers with calibrated probabilities. No generative model in the loop, one round trip, a fraction of the cost and latency of a sub-agent.
An agent planning a workflow, asking Jev one question at a time. Every number is real.
Related MCP server: Jev MCP Server
You need a Typesafe API key. The server runs in one of two places; every client below supports at least one.
Hosted. https://jev.zacca.dev/mcp runs this repository on Cloudflare Workers. It keeps
nothing: every call builds a Typesafe client from the key you send and forwards the
question. Send the key in the x-api-key header, or as a bearer token if your client
only has that field. The same server is listed on Smithery as
pzacca/askjev.
Local. npx -y askjev runs it on your machine over stdio. Requires Node 22+ and the
key in TYPESAFE_API_KEY.
Client | Local (stdio) | Hosted (HTTP) |
yes | yes | |
yes | no, custom connectors cannot send an API key header | |
yes | yes | |
yes | yes, as a bearer token |
Claude Code and Codex were exercised end to end on both transports. Cursor follows its documented configuration format.
# hosted
claude mcp add --transport http askjev https://jev.zacca.dev/mcp --header "x-api-key: your-key"
# local
claude mcp add askjev -e TYPESAFE_API_KEY=your-key -- npx -y askjevOpen Settings, Developer, Edit Config. The file is
~/Library/Application Support/Claude/claude_desktop_config.json on macOS and
%APPDATA%\Claude\claude_desktop_config.json on Windows.
{
"mcpServers": {
"askjev": {
"command": "npx",
"args": ["-y", "askjev"],
"env": { "TYPESAFE_API_KEY": "your-key" }
}
}
}Restart Claude Desktop after saving. On Windows some hosts cannot launch npx directly;
use "command": "cmd" with "args": ["/c", "npx", "-y", "askjev"].
Add to ~/.cursor/mcp.json for every project, or .cursor/mcp.json for one project.
{
"mcpServers": {
"askjev": {
"url": "https://jev.zacca.dev/mcp",
"headers": { "x-api-key": "your-key" }
}
}
}For a local server use the same command, args and env block as Claude Desktop.
# hosted: Codex reads the key from an environment variable and sends it as a bearer token
export TYPESAFE_API_KEY=your-key
codex mcp add askjev --url https://jev.zacca.dev/mcp --bearer-token-env-var TYPESAFE_API_KEY
# local
codex mcp add askjev --env TYPESAFE_API_KEY=your-key -- npx -y askjevOne tool, ask. It takes the material and a list of free-text questions. Options are only
needed when the question has named alternatives.
{
"state": "...", // string | object | array: the material to judge
"questions": [
{ "question": "Is this a bug report?" },
{ "question": "How severe is it?" },
{ "question": "Which team owns it?", "options": ["billing", "platform", "mobile"] },
{ "question": "How urgent is it?", "options": ["can wait", "this week", "today"] }
]
}question is free text. Jev decides whether it is a yes/no question, a scale, or a
choice between the given options.
options is optional. Pass it when the question has named alternatives. Order matters
when the options form a scale.
There is no way to force the question type. The whole point is that the agent does not have to think about it.
One entry per question, in input order.
{
"answers": [
{
"kind": "noul",
"answer": 0.93, // probability of "yes"
"probabilities": { "yes": 0.93, "no": 0.07 },
"routing": { "kind": "noul", "confidence": 0.98 }
},
{
"kind": "score",
"answer": 3.4, // expected level, may be fractional
"legend": { "0": "trivial", "1": "minor", "2": "moderate", "3": "major", "4": "critical" },
"probabilities": { "0": 0.01, "1": 0.04, "2": 0.15, "3": 0.5, "4": 0.3 },
"confidence": 0.71,
"rubric": "severity",
"note": "No options were given, so the built-in 'severity' rubric was used. Pass options for a rubric tailored to your question.",
"routing": { "kind": "score", "confidence": 0.9, "rubric": { "name": "severity", "confidence": 0.84 } }
},
{
"kind": "choice",
"answer": "platform",
"probabilities": { "billing": 0.05, "platform": 0.88, "mobile": 0.07 },
"confidence": 0.88,
"routing": { "kind": "choice", "confidence": 0.97 }
},
{
"kind": "score",
"answer": 1.8,
"legend": { "0": "can wait", "1": "this week", "2": "today" },
"probabilities": { "0": 0.1, "1": 0.2, "2": 0.7 },
"confidence": 0.7,
"routing": { "kind": "score", "confidence": 0.79 }
}
]
}A question that cannot be answered does not fail the batch. Its entry has kind: "error"
and a message saying what to change, and every other question is still answered:
{
"kind": "error",
"message": "\"Which team owns it?\" asks to pick between alternatives, but no options were given. Pass options with the alternatives.",
"routing": { "kind": "choice", "confidence": 0.95 }
}Everything is raw. There is no threshold and no verdict. confidence comes straight from
Jev; yes/no answers have no separate confidence because the probability is the signal.
routing exposes how sure Jev was about the question type, and about the rubric when one
was picked, so a misroute is visible rather than silent.
What else comes back is the operator's choice, not the agent's. ASKJEV_INCLUDE is a
comma-separated list of the optional parts: routing (the default), usage (tokens summed
over every Jev call), and model. Set it to usage,routing to add token counts, or to an
empty string to get nothing but the answers. The tool description tells the agent what the
server was configured to emit.
flowchart TD
A[ask: state + questions] --> B[Call 1: route<br/>one Jev call, one choice question per input question]
B --> C{per question}
C -->|options given| D{choice or score?}
C -->|no options| E{noul, score, or<br/>choice-without-options?}
D -->|choice| F[choice with options as labels]
D -->|score| G[score with options as ordered rubric]
E -->|noul| H[noul]
E -->|score| I[Call 2: pick rubric<br/>one Jev call, one choice question per such input question]
E -->|choice| X[error: this question needs options]
I --> J[score with built-in rubric]
F --> K[Call 3: answer<br/>one Jev call with every typed question]
G --> K
H --> K
J --> K
K --> L[shape answers + routing metadata + summed usage]Two Jev calls in the common case, three when at least one question is a scale without
options. The number of input questions does not change the number of calls: each step
batches every question that needs it into a single systemone request.
| Router decides between | Becomes |
2+ items | choice, score |
|
absent | noul, score, choice |
|
1 item | rejected by schema validation | never reaches the router |
The router's state is the question text itself (an object keyed by question when
batching), and its instructions ask which kind of question that text is. The routing
criteria are described in plain language so Jev discriminates on intent, not on keywords.
Used only for scale questions that arrive without options. A second Jev call picks the closest one. All have five levels so Jev has room to discriminate without the levels blurring together.
Name | Levels, lowest to highest |
| not at all, slightly, moderately, very, extremely |
| poor, below average, acceptable, good, excellent |
| trivial, minor, moderate, major, critical |
| very unlikely, unlikely, uncertain, likely, very likely |
| very negative, negative, neutral, positive, very positive |
| never, rarely, sometimes, often, always |
| strongly disagree, disagree, neutral, agree, strongly agree |
The list is fixed in code. Configurable rubrics are a possible later addition.
Situation | Behaviour |
Input fails schema validation | Tool error with the Zod message. Jev is not called. |
Question routed to | That entry becomes |
Jev returns 401 | Tool error: API key missing or invalid, with the env var name. |
Jev returns 422, 429 after retries, 5xx | Tool error with status, Jev's message, and the request id when present. |
Network or timeout after retries | Tool error with the SDK's message. |
Errors that affect the whole call are returned as MCP tool results with isError: true,
not as protocol errors, so the agent sees the message and can recover. Errors that affect
one question are entries in answers, so one bad question never costs the agent the
others.
Local, only what the Typesafe SDK already reads from the environment:
Variable | Meaning |
| Required. |
| Optional, defaults to |
| Optional, for proxies and the smoke test stub. |
| Optional. SDK logs go to stderr. |
Plus one setting of the server's own:
Variable | Meaning |
| Optional parts of every result, comma-separated: |
stdout carries MCP protocol messages only; every diagnostic goes to stderr.
Hosted, the key travels per request in the x-api-key header (or Authorization: Bearer). TYPESAFE_BASE_URL, TYPESAFE_DEFAULT_MODEL and ASKJEV_INCLUDE can be set as
Worker vars and apply to every caller. The public instance at jev.zacca.dev runs the
defaults.
The router is the part that can be wrong in a way unit tests cannot catch. A versioned dataset of human-labelled questions runs against the live API weekly and on demand; the first run scored 42/42 on routing and 16/16 on rubric selection. See docs/EVAL.md. Design decisions and rejected alternatives are in docs/ARCHITECTURE.md.
npm ci
npm run lint
npm run typecheck
npm testThe hosted variant is src/worker.ts, bundled and deployed by wrangler from
wrangler.jsonc. npm run dev serves it on localhost. Every push to main that passes
CI is deployed to jev.zacca.dev by the deploy job in ci.yml; npm run deploy does
the same by hand (needs wrangler login).
Releases are tag-driven. Bump the version in package.json, commit, then:
git tag v0.2.0 && git push origin main v0.2.0release.yml checks that the tag matches package.json, runs the full test suite,
publishes to npm with provenance, and creates the GitHub release with generated notes.
The Smithery listing points at that domain and takes its configuration form from
smithery.schema.json. Smithery stores a snapshot of the tool taken at publish time, so
the same deploy job republishes the listing after every deploy to keep it current.
MIT
Ask Jev, a fast non-generative judgment model, one or more questions about some material you already have. Use it for a quick second opinion, a classification, a rating, or a yes/no check instead of reasoning it out yourself or spawning a sub-agent.
Write each question in plain language. Jev decides whether it is a yes/no question, a scale, or a choice:
Yes/no: "Does this ticket ask for a refund?" You get the probability of yes.
Choice: pass "options" with the named alternatives. "Which team owns this?" with options ["billing", "platform"].
Scale: pass "options" as ordered levels, lowest first. "How urgent is this?" with options ["can wait", "this week", "today"]. Without options, a built-in rubric is picked for you:
intensity: not at all < slightly < moderately < very < extremely
quality: poor < below average < acceptable < good < excellent
severity: trivial < minor < moderate < major < critical
likelihood: very unlikely < unlikely < uncertain < likely < very likely
sentiment: very negative < negative < neutral < positive < very positive
frequency: never < rarely < sometimes < often < always
agreement: strongly disagree < disagree < neutral < agree < strongly agree
Every answer carries probabilities and Jev's confidence, plus "routing" showing how the question was interpreted and how sure Jev was about that. Read the confidence: a low value means the material does not settle the question, so add context or decide another way.
Requires a Typesafe API key. Set TYPESAFE_API_KEY in the environment of the askjev process.
| Name | Required | Description | Default |
|---|---|---|---|
| state | Yes | The material to judge: text, a JSON object, or a JSON array. | |
| questions | Yes | Questions about the same state, answered in one round trip. |
| Name | Required | Description |
|---|---|---|
| model | No | The Jev model that answered. Present when configured. |
| usage | No | Token usage summed over every Jev call made. Present when configured. |
| answers | Yes | One entry per question, in input order. A question that could not be answered has kind "error"; the others are still answered. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes far beyond the readOnlyHint/openWorldHint annotations by disclosing that every answer carries probabilities and confidence, and that Jev's low confidence means the material does not settle the question. It also explains routing behavior (showing how the question was interpreted and how sure Jev was about that interpretation). No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is longer than necessary but front-loaded: the core purpose and use case appear in the first sentence. The rubric list is structured and easy to scan. The 'Requires a Typesafe API key' note is essential context and placed at the end. A bit verbose in the middle, but every section earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the full usage story: when to use it, how to phrase questions, how options change behavior, what the response will contain, what the confidence metric means, and the environment variable requirement. With an output schema and full schema coverage, nothing an agent needs to call this correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already documents both parameters with descriptions, so baseline is high. The description adds meaning by explaining how 'state' relates to 'questions' (questions are about the same state, answered in one round trip), how 'options' are used differently for choices vs scales vs yes/no, and providing the built-in rubrics. This goes well beyond what the schema gives.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('ask'), resource ('Jev, a fast non-generative judgment model'), and purpose ('second opinion, classification, rating, yes/no check'). It clearly differentiates from sub-agents and from reasoning it out yourself. The opening sentence is explicit about what the tool does and when it is not the right tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use it ('quick second opinion, classification, rating, yes/no check') and when not to ('instead of reasoning it out yourself or spawning a sub-agent'). It also provides built-in rubric names and the note to read confidence and decide another way when confidence is low. This is the most explicit usage guidance possible.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.2.0ask4 fields changedOutput schema / properties / answers / items / oneOfPrevious value: -[
- {
- "additionalProperties": false,
- "properties": {
- "answer": {
- "description": "Probability that the answer is yes, from 0 to 1.",
- "type": "number"
- },
- "kind": {
- "const": "noul",
- "type": "string"
- },
- "probabilities": {
- "additionalProperties": false,
- "properties": {
- "no": {
- "type": "number"
- },
- "yes": {
- "type": "number"
- }
- },
- "required": [
- "yes",
- "no"
- ],
- "type": "object"
- },
- "routing": {
- "additionalProperties": false,
- "properties": {
- "confidence": {
- "description": "Jev's confidence in that routing.",
- "type": "number"
- },
- "kind": {
- "description": "The question type Jev routed this question to.",
- "enum": [
- "noul",
- "score",
- "choice"
- ],
- "type": "string"
- },
- "rubric": {
- "additionalProperties": false,
- "description": "Present when a built-in rubric was picked for a scale question without options.",
- "properties": {
- "confidence": {
- "type": "number"
- },
- "name": {
- "type": "string"
- }
- },
- "required": [
- "name",
- "confidence"
- ],
- "type": "object"
- }
- },
- "required": [
- "kind",
- "confidence"
- ],
- "type": "object"
- }
- },
- "required": [
- "kind",
- "answer",
- "probabilities",
- "routing"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "answer": {
- "description": "Expected level on the rubric. May fall between integer levels.",
- "type": "number"
- },
- "confidence": {
- "type": "number"
- },
- "kind": {
- "const": "score",
- "type": "string"
- },
- "legend": {
- "additionalProperties": {
- "type": "string"
- },
- "description": "Level index to level description.",
- "propertyNames": {
- "type": "string"
- },
- "type": "object"
- },
- "note": {
- "description": "Advice when a built-in rubric was used instead of caller options.",
- "type": "string"
- },
- "probabilities": {
- "additionalProperties": {
- "type": "number"
- },
- "description": "Probability per level index.",
- "propertyNames": {
- "type": "string"
- },
- "type": "object"
- },
- "routing": {
- "additionalProperties": false,
- "properties": {
- "confidence": {
- "description": "Jev's confidence in that routing.",
- "type": "number"
- },
- "kind": {
- "description": "The question type Jev routed this question to.",
- "enum": [
- "noul",
- "score",
- "choice"
- ],
- "type": "string"
- },
- "rubric": {
- "additionalProperties": false,
- "description": "Present when a built-in rubric was picked for a scale question without options.",
- "properties": {
- "confidence": {
- "type": "number"
- },
- "name": {
- "type": "string"
- }
- },
- "required": [
- "name",
- "confidence"
- ],
- "type": "object"
- }
- },
- "required": [
- "kind",
- "confidence"
- ],
- "type": "object"
- },
- "rubric": {
- "description": "Name of the built-in rubric, when one was used.",
- "type": "string"
- }
- },
- "required": [
- "kind",
- "answer",
- "legend",
- "probabilities",
- "confidence",
- "routing"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "answer": {
- "description": "The selected option.",
- "type": "string"
- },
- "confidence": {
- "type": "number"
- },
- "kind": {
- "const": "choice",
- "type": "string"
- },
- "probabilities": {
- "additionalProperties": {
- "type": "number"
- },
- "description": "Probability per option.",
- "propertyNames": {
- "type": "string"
- },
- "type": "object"
- },
- "routing": {
- "additionalProperties": false,
- "properties": {
- "confidence": {
- "description": "Jev's confidence in that routing.",
- "type": "number"
- },
- "kind": {
- "description": "The question type Jev routed this question to.",
- "enum": [
- "noul",
- "score",
- "choice"
- ],
- "type": "string"
- },
- "rubric": {
- "additionalProperties": false,
- "description": "Present when a built-in rubric was picked for a scale question without options.",
- "properties": {
- "confidence": {
- "type": "number"
- },
- "name": {
- "type": "string"
- }
- },
- "required": [
- "name",
- "confidence"
- ],
- "type": "object"
- }
- },
- "required": [
- "kind",
- "confidence"
- ],
- "type": "object"
- }
- },
- "required": [
- "kind",
- "answer",
- "probabilities",
- "confidence",
- "routing"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "kind": {
- "const": "error",
- "type": "string"
- },
- "message": {
- "description": "Why this question could not be answered, and what to change.",
- "type": "string"
- },
- "routing": {
- "additionalProperties": false,
- "description": "Present when the question was routed before the error was detected.",
- "properties": {
- "confidence": {
- "description": "Jev's confidence in that routing.",
- "type": "number"
- },
- "kind": {
- "description": "The question type Jev routed this question to.",
- "enum": [
- "noul",
- "score",
- "choice"
- ],
- "type": "string"
- },
- "rubric": {
- "additionalProperties": false,
- "description": "Present when a built-in rubric was picked for a scale question without options.",
- "properties": {
- "confidence": {
- "type": "number"
- },
- "name": {
- "type": "string"
- }
- },
- "required": [
- "name",
- "confidence"
- ],
- "type": "object"
- }
- },
- "required": [
- "kind",
- "confidence"
- ],
- "type": "object"
- }
- },
- "required": [
- "kind",
- "message"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": false,
+ "properties": {
+ "answer": {
+ "description": "Probability that the answer is yes, from 0 to 1.",
+ "type": "number"
+ },
+ "kind": {
+ "const": "noul",
+ "type": "string"
+ },
+ "probabilities": {
+ "additionalProperties": false,
+ "properties": {
+ "no": {
+ "type": "number"
+ },
+ "yes": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "yes",
+ "no"
+ ],
+ "type": "object"
+ },
+ "routing": {
+ "additionalProperties": false,
+ "properties": {
+ "confidence": {
+ "description": "Jev's confidence in that routing.",
+ "type": "number"
+ },
+ "kind": {
+ "description": "The question type Jev routed this question to.",
+ "enum": [
+ "noul",
+ "score",
+ "choice"
+ ],
+ "type": "string"
+ },
+ "rubric": {
+ "additionalProperties": false,
+ "description": "Present when a built-in rubric was picked for a scale question without options.",
+ "properties": {
+ "confidence": {
+ "type": "number"
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name",
+ "confidence"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "kind",
+ "confidence"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "kind",
+ "answer",
+ "probabilities"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "answer": {
+ "description": "Expected level on the rubric. May fall between integer levels.",
+ "type": "number"
+ },
+ "confidence": {
+ "type": "number"
+ },
+ "kind": {
+ "const": "score",
+ "type": "string"
+ },
+ "legend": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "description": "Level index to level description.",
+ "propertyNames": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "note": {
+ "description": "Advice when a built-in rubric was used instead of caller options.",
+ "type": "string"
+ },
+ "probabilities": {
+ "additionalProperties": {
+ "type": "number"
+ },
+ "description": "Probability per level index.",
+ "propertyNames": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "routing": {
+ "additionalProperties": false,
+ "properties": {
+ "confidence": {
+ "description": "Jev's confidence in that routing.",
+ "type": "number"
+ },
+ "kind": {
+ "description": "The question type Jev routed this question to.",
+ "enum": [
+ "noul",
+ "score",
+ "choice"
+ ],
+ "type": "string"
+ },
+ "rubric": {
+ "additionalProperties": false,
+ "description": "Present when a built-in rubric was picked for a scale question without options.",
+ "properties": {
+ "confidence": {
+ "type": "number"
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name",
+ "confidence"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "kind",
+ "confidence"
+ ],
+ "type": "object"
+ },
+ "rubric": {
+ "description": "Name of the built-in rubric, when one was used.",
+ "type": "string"
+ }
+ },
+ "required": [
+ "kind",
+ "answer",
+ "legend",
+ "probabilities",
+ "confidence"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "answer": {
+ "description": "The selected option.",
+ "type": "string"
+ },
+ "confidence": {
+ "type": "number"
+ },
+ "kind": {
+ "const": "choice",
+ "type": "string"
+ },
+ "probabilities": {
+ "additionalProperties": {
+ "type": "number"
+ },
+ "description": "Probability per option.",
+ "propertyNames": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "routing": {
+ "additionalProperties": false,
+ "properties": {
+ "confidence": {
+ "description": "Jev's confidence in that routing.",
+ "type": "number"
+ },
+ "kind": {
+ "description": "The question type Jev routed this question to.",
+ "enum": [
+ "noul",
+ "score",
+ "choice"
+ ],
+ "type": "string"
+ },
+ "rubric": {
+ "additionalProperties": false,
+ "description": "Present when a built-in rubric was picked for a scale question without options.",
+ "properties": {
+ "confidence": {
+ "type": "number"
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name",
+ "confidence"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "kind",
+ "confidence"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "kind",
+ "answer",
+ "probabilities",
+ "confidence"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "kind": {
+ "const": "error",
+ "type": "string"
+ },
+ "message": {
+ "description": "Why this question could not be answered, and what to change.",
+ "type": "string"
+ },
+ "routing": {
+ "additionalProperties": false,
+ "description": "Present when routing is configured and the question was routed before the error was detected.",
+ "properties": {
+ "confidence": {
+ "description": "Jev's confidence in that routing.",
+ "type": "number"
+ },
+ "kind": {
+ "description": "The question type Jev routed this question to.",
+ "enum": [
+ "noul",
+ "score",
+ "choice"
+ ],
+ "type": "string"
+ },
+ "rubric": {
+ "additionalProperties": false,
+ "description": "Present when a built-in rubric was picked for a scale question without options.",
+ "properties": {
+ "confidence": {
+ "type": "number"
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name",
+ "confidence"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "kind",
+ "confidence"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "kind",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / properties / model / descriptionPrevious value: -"The Jev model that answered."New value: +"The Jev model that answered. Present when configured."Output schema / properties / usage / descriptionPrevious value: -"Token usage summed over every Jev call made."New value: +"Token usage summed over every Jev call made. Present when configured."Output schema / requiredPrevious value: -[
- "model",
- "usage",
- "answers"
-]New value: +[
+ "answers"
+]v0.1.0askScored across 1 tool
With only one tool, there is no possibility of confusion or misselection. The tool's purpose is clearly defined and unique.
A single tool name 'ask' is trivially consistent; there is no pattern to break or mix. The name accurately reflects its function.
A single tool is on the borderline of being thin, but it is purpose-built for a narrow domain (querying a judgment model). The count is acceptable but could feel minimal for broader expectations.
The tool fully covers the intended domain: asking yes/no, choice, or scale questions, with built-in rubrics and confidence reporting. No obvious gaps in its stated purpose.
Calibrated judgments for text: yes/no probabilities, picks from your options, or scores.
Jev-powered decisions, web search, PDF/web to Markdown, summarize. From $0.001, no API key.
Calibrated decisions for agents: choice, yes/no and score questions answered with probabilities.
Calibrated world model for AI agents. 40 tools: world state, markets, trading. Kalshi + Polymarket.
