Jevbridge: Bridging Jev Into Other Runtimes

Most of the projects that wire Jev into agents settle on one integration surface, usually MCP. Jevbridge takes a broader view: it exposes the same typed-decision interface over MCP, over the Agent Client Protocol (ACP), and as a CLI, so editors that never adopted MCP can still reach it. It also does something none of the other integrations in this series attempt — it can stand in Jev's place with a different LLM when no TypeSafe key is configured at all.

That flexibility is the whole pitch, and also the thing to be most careful about. This article covers what Jevbridge's README actually documents, at 40 stars as of September 2026, and where the "any LLM as System One" mode changes the calculus you'd apply to Jev proper. For background on the primitives involved, see what Jev is and typed decisions vs free text.

Key Takeaways

• Three protocols, one interface. MCP for Claude Desktop, Cursor, Codex and OpenCode; ACP over stdio for Zed and JetBrains; a CLI for direct use.
• Confidence gating returns an action, not just a score. A judgment maps to execute, confirm, escalate, or abort.
• Three backends, one being explicitly unreliable. Native Jev, an LLM adapter (Codex, Claude, Grok, OpenCode, or any OpenAI-compatible endpoint), and a local heuristic scorer the README calls "not a safety signal."
• It adds a computer-use mode, scoring GUI observations against a closed set of actions rather than free-form clicking.
• The repo has already moved. Its README notes the project was transferred into the tacticocc organization; treat the gamesonrblx URL as the origin, not necessarily the current home.

What Jevbridge actually exposes

Functionally, Jevbridge sits as a decision sidecar next to whatever agent or model is doing the generation. You send it a state and a set of typed questions — the same noul/choice/score shape used throughout this series — and it returns confidence-gated answers your code can branch on. Over MCP, it registers tools including jev_decide, jev_gate, and jev_computer_use, aimed at Claude Desktop, Cursor, Codex and OpenCode. Over ACP, it runs as a stdio agent server with session persistence, which is how it reaches Zed (which supports custom agent servers) and JetBrains. The CLI covers direct command-line use of the same recipes without an editor in the loop at all.

The jev_computer_use tool is the more unusual addition: it scores GUI observations against a closed set of possible actions, which is a narrower and more auditable version of the "browser agent" pattern covered in browser and desktop agents. Confidence gating is the throughline across all three protocols: rather than returning a bare probability, Jevbridge maps a judgment to one of four actions — execute when confidence is high, confirm when it's middling, escalate when it's low, and abort for destructive actions it won't run unsupervised. That's a sensible default pattern, and one worth comparing against the guardrail designs in Jev guardrails and safer routing.

The part to read carefully: backend swapping

Jevbridge's most distinctive feature is that Jev is optional. With a TypeSafe API key configured, it calls Jev natively. Without one, it can route the same typed-question interface to another LLM instead — Codex, Claude, Grok, OpenCode, or a generic OpenAI-compatible endpoint — asked to produce structured output in Jev's place. There's also a third, offline option: a local heuristic scorer intended for testing when no API access is available at all.

The README is unusually candid about that heuristic backend's limits, stating that it includes the question text itself in its scoring, which causes false positives from simple word overlap. Its own guidance: "treat heuristic numbers as a smoke test, not a safety signal." That's worth taking at face value — it means the offline mode is for exercising your integration code, not for making real gating decisions.

The LLM-adapter mode deserves the same caution for a different reason. Jev's pitch throughout this series rests on it being a small, fast, purpose-trained classifier — calibrated for typed judgments, not a general-purpose model coerced into one. A general LLM forced into the same noul/choice/score interface can mimic the shape of the output, but it inherits none of Jev's calibration claims, and its latency and cost profile will look nothing like the 150–500ms figures reported for purpose-built Jev wrappers. If you fall back to this mode because no TypeSafe key is available, treat it as a different tool wearing the same interface, not a drop-in equivalent. Jevbridge itself does not claim otherwise — the README frames it as a fallback, not a recommendation.

What to do next

1. Pick the backend deliberately. Native Jev if you have a key and want the calibration properties the rest of this series describes. The LLM adapter only as an explicit, understood fallback — not a silent substitute.
2. Use ACP if your editor lacks MCP. Zed and JetBrains users who've been locked out of MCP-only wrappers like typesafe-mcp or jev-mcp get a route in through Jevbridge.
3. Never trust the heuristic backend for real gating. Reserve it for exercising integration code in CI, not for production decisions.
4. Confirm the current repo location before installing. The README documents a move to the tacticocc organization; check that the org's fork is the maintained one.
5. Compare with the narrower alternatives. If you only need MCP and don't need the fallback modes, typesafe-mcp or jev-mcp are simpler surfaces. Jevbridge earns its complexity when you need multi-protocol or multi-backend support. See the full field at the Awesome Jev projects radar. On aiskill.market: /skills/jevbridge-gamesonrblx.