Jev Agent Toolkit

项目摘要

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.

来源原文

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?

原记录的限制

• 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.