TypeSafe Evaluate

Give agents typed judgments and probabilities they can branch on instead of prose they must parse.

Stars
★ 358
Last updated
2d ago
License
MIT
Primary language
Go

At a glance

How it runs
CLIMCP serverAgent plugin / skill
Works with
Platform-specificCodex · Claude Code · Claude.ai
Cost
Free software; you pay for model usage
Setup effort
Low · running in minutes
You'll need
TypeSafe API key or OpenRouter API keymacOS or Linux on amd64 or arm64Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
A support-platform developer needs to judge whether a ticket is urgent and route it among billing, technical, and sales teams from the ticket text.
Not a fit if
  • Users wanting general text generation or a full workflow engine; it only returns structured judgments
  • Windows users; documented installation covers only macOS and Linux on amd64/arm64

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

TypeSafe Evaluate is an MCP server distributed as a static Go binary and exposing one read-only tool named evaluate. It accepts text or JSON state plus noul, choice, or score questions, then uses TypeSafe's Jev model to produce structured answers with probabilities. Requests can go directly to the TypeSafe API or through OpenRouter's Decisions endpoint, but both routes depend on Jev rather than providing a general model adapter. evaluate setup mcp registers the server with Claude Code, Claude Desktop, and Codex when detected, while pi connects through a separately installed native extension. It fits programmable routing and classification workflows that need machine-readable confidence, but it is not a general text generator and cannot perform evaluations without network access and suitable API credentials.

The evaluate MCP tool reads a state value containing plain text or a JSON object or array with named fields, followed by a questions map keyed by caller-defined question IDs. Each question uses the noul, choice, or score type and may include instructions and the applicable criteria. The server sends this material to the TypeSafe API at POST /v1/systemone, or to POST /decisions when configured for OpenRouter, and returns the raw structured JSON with answers under the original IDs. Multiple independent questions about the same state can be submitted in one call and run in parallel. HTTP 429 and 529 responses are retried with exponential backoff, while other API failures become tool errors the agent can inspect. Malformed criteria are rejected locally with the submitted field path; requests have a 60-second timeout, and responses larger than 16 MiB are rejected rather than truncated.

  1. A support-platform developer needs to judge whether a ticket is urgent and route it among billing, technical, and sales teams from the ticket text.
  2. An agent-workflow author needs a probabilistic yes/no judgment so application code can choose a branch based on confidence.
  3. A backend engineer wants to evaluate several independent questions against the same event state and receive all answers in one structured call.
  4. A Claude Code, Claude Desktop, or Codex user wants to avoid maintaining rigid prose prompts and fragile output parsers for recurring decisions.
  5. A pi user wants to add typed judgments to an automation through the supplied native extension and its evaluate mcp backend.

How do you install or deploy this agent?

On macOS or Linux running amd64 or arm64, use the installer; it places the binary in ~/.local/bin:

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

If that directory is not on PATH, add it:

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

Go users can install it directly instead:

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

After obtaining a TypeSafe API key, register the MCP server with detected Claude Code, Claude Desktop, and Codex installations:

TYPESAFE_API_KEY=your-key evaluate setup mcp

To access Jev through OpenRouter, use:

OPENROUTER_API_KEY=your-key evaluate setup mcp

TYPESAFE_API_KEY takes precedence when both variables are set. Because pi has no MCP client, install the supplied extension separately:

evaluate setup pi

This writes ~/.pi/agent/extensions/evaluate.ts; run /reload in pi afterward. Upgrade an installed binary in place with:

evaluate update

How do you use this agent?

Complete client registration and make a valid TYPESAFE_API_KEY or OPENROUTER_API_KEY available to the shell that launches the agent. Ask the agent to use evaluate for a specific judgment, such as deciding whether a ticket is urgent and which team should own it. The corresponding tool input can be:

{
  "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 result is raw JSON, with each answer stored under the question ID supplied in the request. An optional model field is supported; it defaults to jev-latest on the TypeSafe route and ~typesafe/jev-latest on OpenRouter.

What are this agent's strengths and limitations?

Pros
  • Typed answers and probabilities can drive application branches directly, eliminating prose extraction for supported decision shapes.
  • One request can batch multiple independent questions over the same state and execute noul, choice, or score evaluations in parallel.
  • evaluate setup mcp configures detected Claude Code, Claude Desktop, and Codex clients, and a dedicated extension covers pi.
  • The server includes exponential-backoff retries for 429 and 529 responses, local criteria validation, a 60-second timeout, and a 16 MiB response limit.
  • It runs as a single static binary without a Node.js or Python runtime and supports checksum-verified in-place updates.
Limitations
  • Core judgments depend on TypeSafe's Jev model; the OpenRouter route does not make the backend interchangeable with arbitrary models.
  • Evaluations require network access and either a TypeSafe or OpenRouter API key; OpenRouter usage is billed to the user's OpenRouter account.
  • OpenRouter's Decisions endpoint remains under an /api/alpha/ path that the documentation says may move.
  • The tool is limited to structured judgments and does not provide general-purpose text generation or a complete workflow engine.
  • Documented binary installation covers only macOS and Linux on amd64 or arm64, with no stated Windows installation path.

How does this agent compare with similar options?

Compared with asking a general LLM for prose and parsing the result, evaluate returns typed JSON with probabilities, removing prompt-format maintenance and fragile text extraction. TypeSafe API and OpenRouter Decisions are alternative request routes, but both use Jev; when both credentials are configured, TYPESAFE_API_KEY wins.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
TypeSafe Evaluate This agent 70 · Some gaps CLIFree + model costs ★ 358 2d ago Go Codex · Claude Code · Claude.ai
Jevbridge Decision Sidecar 62 · Some gaps CLIFree + model costs ★ 48 1mo ago TypeScript Codex · OpenAI API · Claude API
Distill Terminal Coding Agent 47 · Major gaps CLIFree + model costs ★ 774 today Rust ChatGPT · OpenAI API
Jev Review 81 · Good Agent plugin / skillFree + model costs ★ 247 1mo ago TypeScript Codex · Claude Code

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
70/ 100 5-point scale 3.5 / 5
This review covers the source as of Sep 20, 2026. The project has shipped 12 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 16/29
Reliability 9/14
Adaptability 15/18
Convention 13/18
Effectiveness 12/13
Verifiability 5/8
Why each dimension lost points
Trust16 / 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.

Reliability9 / 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.

Adaptability15 / 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.

Convention13 / 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.

Effectiveness12 / 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.

Verifiability5 / 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.

Risks and how to mitigate them
  • Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
  • 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.
Evidence confidence: Low Reviewed Sep 20, 2026 Reviewed revision d4c110c7edd8 New commits since this review; the score may not cover them
See the full review method →

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.4.14
    Release notes excerpt
    [0.4.14](https://github.com/itsmostafa/system-one-connector/compare/v0.4.13...v0.4.14) (2026-10-25) Bug Fixes * eval: make the taxcat eval neutral and score it only on its own dataset ([12212ee](https://github.com/itsmostafa/system-one-connector/commit/12212eefc24a002f5adf34f461b14b8ba2877263)) * eval: show recall per taxcat group when limits differ ([2b0f555](https://github.com/itsmostafa/system-one-connector/commit/2b0f555ececbed1bed2b2ada41586867010b78c2))
    View on GitHub ↗
  2. v0.4.13
    Release notes excerpt
    [0.4.13](https://github.com/itsmostafa/system-one-connector/compare/v0.4.12...v0.4.13) (2026-10-23) Bug Fixes * client: keep /v1/decisions base URLs as given ([39dcd64](https://github.com/itsmostafa/system-one-connector/commit/39dcd64a8b8a7e31a4ba53a7351fb5ef8821b368)) * client: keep /v1/decisions base URLs as given ([702423f](https://github.com/itsmostafa/system-one-connector/commit/702423f1c6111301c05c65c4d2ade05dbd5d95de)) …
    View on GitHub ↗
  3. v0.4.12
    Release notes excerpt
    [0.4.12](https://github.com/itsmostafa/system-one-connector/compare/v0.4.11...v0.4.12) (2026-10-08) Features * client: send extra request headers from TYPESAFE_HEADERS ([e2fcc02](https://github.com/itsmostafa/system-one-connector/commit/e2fcc02c39015daf7ef9cd6854daa5fd10edb481)) * client: send extra request headers from TYPESAFE_HEADERS ([adca31b](https://github.com/itsmostafa/system-one-connector/commit/adca31b71e48d90ac0d08b05df0ae4c752560591)), closes [#53](https://github.com/itsmostafa/system-one-connector/issues/53)
    View on GitHub ↗

FAQ

Which credentials are required?
Provide either TYPESAFE_API_KEY or OPENROUTER_API_KEY. If both are present, the TypeSafe key takes precedence.
Can evaluations run offline?
No. The MCP server is a local static binary, but its core evaluation request must reach either the TypeSafe API or OpenRouter's Decisions endpoint.
What happens during rate limits or API failures?
HTTP 429 and 529 responses are retried with exponential backoff. Other API failures are returned as tool errors. Requests time out after 60 seconds, and responses above 16 MiB are rejected.
Does it modify files or perform write operations?
The evaluate tool is described as read-only. Installation and setup do write local files, including the binary under ~/.local/bin, client configuration, and ~/.pi/agent/extensions/evaluate.ts for pi.
Is the OpenRouter integration on a stable endpoint?
Not yet. The Decisions endpoint is still under /api/alpha/ and may move; calls are billed through the user's OpenRouter account.
View on GitHub ↗ Install ↓

Compare agents like this one

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

Related agents