Skip to main content
Glama

jev_evaluate

Read-only

Run multiple judgment questions — yes/no, choice, or score — against one shared state, returning calibrated probabilities, confidence, and an auto/review/escalate gate for branching decisions.

Instructions

Ask Jev — a fast, calibrated judgment model — many typed questions about one shared state; returns probabilities plus a gate computed in code. Use it for any judgment you want to branch on when no other jev_* tool fits. Writing questions (Jev reads literally):

  • State the exact condition in instructions; put boundary cases in criteria. If you would have to explain what you really meant, that explanation belongs in the instruction.

  • One judgment per question; split compound ones and combine in code.

  • Batch every question sharing a state into ONE call. They run in parallel and cost only their own tokens, so speculative questions are nearly free.

  • Send only the state the question needs; point at parts by path, e.g. ticket.messages[0].text.

  • Choice: list every option, plus an other/none escape hatch.

  • Never ask it to count, do arithmetic, or compare dates/numbers — compute those in code and pass the result in.

  • It selects from your options; it never generates text. Answers: noul is P(yes), ~0.5 means unsure; choice/score carry confidence; gate is auto/review/escalate. Budget: ~64k tokens state + all questions, ~32k state + longest question.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
modelNoOverride the configured model, e.g. `jev-1.13.0` to pin a version.
stateYesThe content to judge: a plain string, or structured data that questions reference by path.
questionsYesMap of question id -> question. Ids are yours; answers come back under the same ids.
thresholdsNoOverride the server's configured gating thresholds for this call only.

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
modelYesThe versioned model id that actually answered.
usageYesToken usage. Jev charges for input tokens only.
answersYesOne answer per question id, each augmented with a `gate` computed in code.
latency_msYesWall-clock time for the underlying API call(s), including retries.
thresholdsYesThe thresholds actually applied.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.4

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Adds substantial behavior beyond the readOnlyHint=true/openWorldHint=true annotations: questions run in parallel and are billed only their own tokens ('speculative questions are nearly free'), Jev reads literally, it never generates text (only selects from options), and it discloses the ~64k token budget. It also explains answer semantics (noul = P(yes), ~0.5 = unsure, gate = auto/review/escalate). No contradiction with annotations; readOnlyHint is consistent with a pure evaluation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but well-structured into scannable sections (Writing questions, Answers, Budget) with front-loaded purpose. Every bullet earns its place — the authoring rules are essential for correct use of this three-variant question-type tool. A little tightening is possible but the complexity justifies the length.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a highly complex tool (nested question variants, polymorphic state, thresholds, model override) with an output schema covering returns, the description is essentially complete. It addresses the failure-prone parts an agent would get wrong: instruction/criteria split, batching, literal reading, no-arithmetic rule, and the gate semantics. Nothing an agent needs to call it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3. The description earns a point above baseline by explaining how to structure the state and questions parameters: what belongs in instructions vs criteria, one judgment per question, path references like ticket.messages[0].text, and never asking it to count or compare. These usage patterns add meaning the schema alone doesn't convey.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Opens with a specific verb+resource+scope: 'Ask Jev — a fast, calibrated judgment model — many typed questions about one shared state; returns probabilities plus a gate computed in code.' It also names the sibling family it belongs to and explicitly carves its niche: 'Use it for any judgment you want to branch on when no other jev_* tool fits.' An agent can distinguish this from jev_rank/jev_verify without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives an explicit selection rule ('when no other jev_* tool fits') and backs it with a full authoring playbook: batch questions sharing a state into one call, send only the needed state, reference by path, always add an escape-hatch option, and compute arithmetic in code rather than asking the model. This is actionable when/why guidance, not a generic hint.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.