Dev & Engineering mcp-servertyped-decisionsprobability-scoringdecision-routingbatch-evaluationopenrouterstatic-binary

TypeSafe Evaluate

Give AI clients typed, probabilistic judgments that application code can branch on.

FollowAgents review · FARS-2.1
Use with care
70/ 100 5-point scale 3.5 / 5
1 2 3 4 5 6
Per-dimension scores and reasoning
1Trust16 / 29 · 2.8/5

The README clearly shows that state and questions are sent to either the TypeSafe API or OpenRouter, and it discloses writes made by installation, client registration, the pi extension, and self-update. The evaluation tool is described as read-only, supporting but not fully establishing least privilege and bounded effects. Setup is explicitly initiated by the user, but there is no per-request confirmation for remote evaluation. Keys come from environment variables and precedence is documented, while setup carries every TYPESAFE_* variable; the supplied material does not address configuration-file permissions, log redaction, rotation, or server-side retention. Go dependencies are versioned, Actions are commit-pinned, and releases use SHA-256 checksums, but no vulnerability scanning, SBOM, or dependency-update policy is shown. No uninstall, configuration restoration, or update rollback procedure is documented. The repository, TypeSafe service, and license are attributed, although publisher identity is unverified and responsibility between the repository maintainer and service operator is not fully defined.

2Reliability9 / 14 · 3.2/5

The README, module manifest, and release workflow are broadly consistent about a Go static binary, release assets, and checksums, but the supplied evidence omits implementation and tests, preventing a thorough self-consistency score. Direct and indirect dependencies are pinned and supported release targets are stated; operation nevertheless depends on external TypeSafe or OpenRouter availability, with the OpenRouter Decisions endpoint explicitly described as alpha. The documentation covers exponential retry for 429/529, a 60-second timeout, a 16 MiB response limit, field-path validation, and readable API errors. It does not provide a complete error taxonomy, retry ceilings, or recovery guidance.

3Adaptability15 / 18 · 4.2/5

The intended audience, supported Claude Code, Claude Desktop, Codex, and pi clients, and urgency, routing, and scoring scenarios are concrete. Capability boundaries are unusually clear: one evaluate tool, three question types, typed judgments rather than text generation, and separate MCP and pi integration paths. Trigger and question-writing guidance is mentioned, but important client guidance is delegated to a CLAUDE.md file not included in the evidence. Environment instructions cover macOS/Linux, amd64/arm64, PATH setup, Go installation, and several clients, while Windows, proxy configuration, and offline behavior are not covered.

4Convention13 / 18 · 3.6/5

The README has a usable progression through motivation, quickstart, features, reference, and contribution, though detailed specifications are delegated to unavailable files. Installation, an alternative Go installation, registration, updating, and pi reload steps are strong. Naming is mostly stable, but evaluate names both the executable and tool, jev-latest is a moving alias, and the OpenRouter path may change. The worked example clearly shows the input shape, but there is no dedicated FAQ or substantial edge-case coverage. Several limitations are disclosed, including read-only behavior, size and time limits, platform scope, and the alpha endpoint, but privacy, quotas, network failures, and model accuracy limitations are not consolidated. The complete MIT license matches the metadata. Release Please and the release badge show a versioning process, but no changelog content is supplied. Contributions and a copyright holder are identified, while the maintenance team, support path, response expectations, and deprecation policy remain unclear.

5Effectiveness12 / 13 · 4.6/5

Responses are described as structured JSON keyed by caller-provided identifiers, with typed answers and probabilities suitable for programmatic branching; batching further improves usability. The repository makes a concrete case for marginal value over generating and parsing free-form model output by adding stable shapes and confidence values. A static binary, parallel batching, and retry handling reduce operational burden, but external-service pricing, latency, quotas, judgment quality, and data-transfer costs are not quantified, so cost-benefit treatment is incomplete.

6Verifiability5 / 8 · 3.1/5

Several claims are traceable across the supplied files: the MIT declaration matches the license, the Go binary and dependency claims align with go.mod, and checksum generation plus pinned Actions appear in the release workflow. README claims concerning runtime validation, retries, timeouts, response limits, client registration, and data handling cannot be corroborated because implementation and test files were not supplied. Cross-source support therefore exists but is limited, with no independent corroboration. The documentation distinguishes the problem, proposed solution, and known alpha risk, but multiple effectiveness and safety statements remain product assertions not demonstrated by the provided source.

Evidence confidence: Low Reviewed Sep 20, 2026 Reviewed revision d4c110c7edd8
Safety controls not found in source: rollback or recovery path
Before you use it
  • Evaluation sends caller-provided state and questions to TypeSafe or OpenRouter. Do not submit secrets, personal data, or regulated information without verified retention, logging, and privacy terms.
  • Setup modifies client configuration and carries every TYPESAFE_* environment variable. Review the variable scope, target configurations, and generated-file permissions before running it.
  • No uninstall, configuration backup, or rollback procedure is supplied. Preserve existing configurations and binaries before registration or self-update.
  • OpenRouter Decisions uses an alpha path that may move, while external-service availability, pricing, quotas, and output quality are not verified by these static files.
  • Several runtime and security claims in the README cannot be cross-checked against supplied implementation or tests; this assessment is not an execution test or independent security audit.
Review evidence [1][2][3][4]
See the full review method →

What does this agent do, and when should you use it?

TypeSafe Evaluate is a Go static binary and MCP server that exposes TypeSafe's Jev model as one read-only `evaluate` tool for Claude Code, Claude Desktop, and Codex; pi connects through a bundled extension. It accepts text or JSON state together with questions typed as `noul`, `choice`, or `score`. The server sends requests through TypeSafe's `/v1/systemone` API or OpenRouter's Decisions endpoint, then returns structured JSON answers with probabilities under the submitted question IDs. Independent questions can be batched and processed in parallel, while HTTP 429 and 529 responses receive exponential-backoff retries. Its deployment boundary is a locally running connector backed by remote Jev inference, so operation requires network access and either TypeSafe or OpenRouter credentials.

evaluate mcp runs an MCP server over stdio and publishes a single tool named evaluate. The tool reads plain text, a JSON object, or an array from state, plus a questions map whose entries contain type, instructions, and type-dependent criteria. It rejects malformed criteria locally with the submitted field path; valid input is sent to TypeSafe's POST /v1/systemone endpoint or, when OPENROUTER_API_KEY is used, OpenRouter's POST /decisions endpoint. Independent questions run in parallel within one call, and the raw JSON result is keyed by the original IDs so client code can branch on probabilities, selected choices, or ordered scores. Requests have a 60-second timeout, responses larger than 16 MiB are rejected, 429 and 529 responses are retried, and other API failures are surfaced as readable tool errors.

  1. A customer-support automation developer wants to assess ticket urgency and select billing, technical, or sales ownership from the same ticket text.
  2. A workflow engineer needs a probabilistic yes/no condition without maintaining parsers for free-form model prose.
  3. A Claude Code, Claude Desktop, or Codex user wants typed routing or severity judgments inside an existing MCP workflow.
  4. A pi user wants the same decision service through a native extension because pi does not provide an MCP client.
  5. An application developer wants to batch several independent questions over one shared state and receive structured answers in a single call.

What are this agent's strengths and limitations?

Pros
  • Returns typed JSON with probabilities, allowing application code to branch without parsing free-form prose.
  • Supports noul, choice, and score questions and can process multiple independent questions in parallel over one state.
  • A single evaluate setup mcp command configures detected Claude Code, Claude Desktop, and Codex installations, with a separate extension for pi.
  • Ships as one static binary with no Node.js or Python runtime requirement and supports checksum-verified in-place updates.
  • Includes exponential-backoff handling for 429 and 529 responses, a 60-second timeout, a 16 MiB response limit, and local criteria validation.
Limitations
  • Core judgments depend on TypeSafe's Jev model; the supplied material does not document substituting another model, even through OpenRouter.
  • Inference requires a remote service, network access, and a TypeSafe or OpenRouter API key; offline or fully self-hosted inference is not documented.
  • Prebuilt installation is documented only for macOS and Linux on amd64 and arm64, with no stated Windows support.
  • OpenRouter's Decisions endpoint remains under an /api/alpha/ path that may move.
  • Calls are constrained by a 60-second timeout and a 16 MiB response ceiling; oversized responses are rejected rather than truncated.

How do you install or deploy this agent?

Prebuilt installation is documented for macOS and Linux on amd64 and arm64:

curl -fsSL https://raw.githubusercontent.com/itsmostafa/typesafe-mcp/main/install.sh | sh

The binary is installed in ~/.local/bin. If necessary, add it to PATH:

export PATH="$HOME/.local/bin:$PATH"

With Go installed, the alternative is:

go install github.com/itsmostafa/typesafe-mcp/cmd/evaluate@latest

Obtain a key from https://console.typesafe.ai/, then register detected MCP clients with:

TYPESAFE_API_KEY=your-key evaluate setup mcp

To use ~typesafe/jev-latest through OpenRouter instead:

OPENROUTER_API_KEY=your-key evaluate setup mcp

TYPESAFE_API_KEY takes precedence when both variables exist. The setup command registers detected installations of Claude Code, Claude Desktop, and Codex. Run evaluate update for an in-place upgrade.

How do you use this agent?

After registration, ask the client to invoke evaluate. For example, this input assesses urgency and team ownership:

{
"state": "Help! My payouts have been failing for 3 days.",
"questions": {
"is_urgent": {
"type": "noul",
"instructions": "Does this convey urgency?"
},
"department": {
"type": "choice",
"instructions": "Which team should handle this?",
"criteria": {
"billing": "Payments, refunds",
"technical": "Bugs, outages",
"sales": "Pricing"
}
}
}
}

The optional model field defaults to jev-latest through TypeSafe or ~typesafe/jev-latest through OpenRouter. For pi, run evaluate setup pi; it writes ~/.pi/agent/extensions/evaluate.ts. Run /reload in pi afterward. The extension reads its key from the shell environment in which pi is running.

How does this agent compare with similar options?

Compared with asking a general-purpose language model for prose and then parsing its answer, Evaluate returns typed judgments with probabilities and removes much of the prompt-format and parsing work, at the cost of depending on Jev. It offers two access routes: the TypeSafe API, which takes precedence when both credentials are set, and OpenRouter Decisions, which bills the user's OpenRouter account but still uses an alpha endpoint path.

FAQ

Is a TypeSafe API key mandatory?
No. You can use TYPESAFE_API_KEY for direct TypeSafe access or OPENROUTER_API_KEY for Jev through OpenRouter Decisions. The TypeSafe key wins if both are set.
Does it run the Jev model locally?
No. The local component is a static connector and MCP server; judgment requests go to TypeSafe or OpenRouter and therefore require network access.
Can the tool modify evaluated data or external systems?
The evaluate tool is documented as read-only: it consumes state and questions, calls the decision service, and returns JSON. Installation and setup commands do write the binary, client configuration, or pi extension locally.
What happens during rate limits or service errors?
HTTP 429 and 529 responses are retried with exponential backoff. Other API failures are returned as tool errors that the calling client can inspect and handle.
What caveat applies to the OpenRouter route?
Its Decisions endpoint is still under an /api/alpha/ path and may move. Usage is billed to the user's own OpenRouter account.

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents