COMMUNITY OBSERVEDMetric claims: AUTHOR REPORTEDSOURCE AUDITED⚡ Jev Skills🤖 Jev Agent

Jev Agent Toolkit

A portable coding-agent Skill with an optional Jev MCP bridge.

Overview & result

The author built a portable Agent Skill plus an optional MCP server exposing jev_evaluate. Coding agents can use Jev for bounded routing, ranking and code-review judgments while retaining their main LLM for generation and deterministic code for exact checks. The public repository contains both the Skill and MCP implementation.

From the original post

I’ve been experimenting with a question that kept coming up while working with coding agents:

Does every uncertain decision really need another large LLM call?

For tasks like generating code, debugging, planning or explaining something, a general-purpose LLM obviously makes sense.

But coding agents also make a lot of much narrower decisions:

- Which subsystem does this bug belong to?

- Which of these files is most likely relevant?

- Does this diff appear to widen permissions?

- Is this test failure more likely a regression, a flaky test, or an environment issue?

- How risky does this change look?

- Does this retrieved piece of context actually help answer the question?

These aren't really generation problems. They’re bounded judgment problems.

So I built Jev Agent Toolkit, an open-source Agent Skill + optional MCP bridge that lets Claude Code, Codex, Cursor and other agents use TypeSafe’s Jev/System One model specifically for those decisions.

GitHub:

https://github.com/reiswaffel78/jev-agent-toolkit

The basic architecture is intentionally simple:

Coding Agent

|

+----------------+----------------+

| | |

deterministic generative bounded

work reasoning judgment

| | |

code/tests main LLM Jev

Choice

Score

Noul

Jev does not generate code or prose.

The main coding agent still owns reasoning, implementation and orchestration.

Deterministic code still owns things like parsing, arithmetic, builds, tests, thresholds and control flow.

Jev is only used when the answer space is bounded and a probability distribution is useful.

For example, an agent could send one batched request asking:

subsystem:

auth | billing | frontend | other

change_risk:

low | moderate | high | critical

logs_secrets:

probability true/false

adds_network_call:

probability true/false

widens_permissions:

probability true/false

The agent can then apply deterministic thresholds in code:

low confidence -> investigate further

high risk -> require additional review

otherwise -> continue workflow

One design principle I tried to keep strict is:

Don't use an AI model where deterministic code can answer the question exactly.

So Jev isn't used for compilation, parsing, counting, date comparisons, applying diffs, dependency resolution, test assertions, etc.

The toolkit currently includes:

- Portable Agent Skill

- Claude Code / Codex / Cursor support

- Optional MCP server exposing `jev_evaluate`

- Direct TypeSafe API / SDK usage

- Choice / Score / Noul patterns

- batched evaluations

- confidence-gated routing

- candidate ranking

- retrieval relevance

- code-review property checks

- multi-agent orchestration guidance

- Blender / Unreal / external-tool orchestration guidance

It's MIT licensed.

One important caveat:

I do not currently have evidence that this makes coding agents objectively better, cheaper or faster overall.

The architecture works and the integrations have been tested, but the interesting next step is benchmarking whether separating bounded judgment from general-purpose reasoning actually improves real coding-agent workflows.

That is also why I'm posting this here.

I'm particularly interested in criticism of the architecture:

Where would you actually use a bounded judgment model inside a coding-agent workflow?

And equally important:

Where do you think adding another probabilistic model just creates unnecessary complexity?

— Thin-Illustrator-912

How Jev fits in the loop

  1. A coding agent frames a narrow decision as Choice, Score or Noul instead of asking for free-form generation.
  2. The Skill can call the TypeSafe API directly or use the optional jev_evaluate MCP tool.
  3. The agent applies its own deterministic confidence and risk thresholds to the result.

How to reproduce

  1. Read the Agent Skill in skills/jev-agent-toolkit/SKILL.md.
  2. For the optional tool bridge, follow mcp/jev/README.md and configure a TypeSafe API key.
  3. Try a bounded code-review or routing question and inspect the returned typed probabilities.

Why this build matters

A concrete Skill and MCP integration showing where a small judgment model fits inside a coding-agent workflow, with an explicit statement that overall gains remain unmeasured.

Limitations

  • The author explicitly reports no benchmark showing that full coding-agent runs are better, cheaper or faster overall.
  • Parsing, compilation, tests, thresholds and other exact operations remain deterministic code paths.

Patterns