Integration guide · OpenClaw · published October 11, 2026

Jev in OpenClaw

OpenClaw now has a separate “decision model” next to the chat model. The official TypeSafe plugin fills it with hosted Jev or a local Jev-compatible model.

OpenClaw, the open-source agent with more than 390,000 GitHub stars, added a decisionModel role in September 2026 for the small judgments an agent makes all day: which tools matter, whether a message needs an answer, whether a command is safe. The official @openclaw/typesafe plugin connects that role to Jev or to a local System One server. This page covers setup, the plugin API, the limits, and what happened when we ran the published plugin code against 4 backends.

Install and configure Our plugin test Call it from a plugin

Written and tested by the Jev AI team from OpenClaw’s documentation and the published plugin package, read on October 11, 2026. Corrections: [email protected].

2026.10.1@openclaw/typesafe on npm, published 10 October 2026; host 2026.9.6 or later

2 / 4backends whose answers passed the plugin’s own validation in our test

737 msmedian for a three-question call to hosted Jev through the plugin, from Asia

2–255Choice options through TypeSafe; Score 2–10 levels; 4 concurrent requests per provider

What OpenClaw means by a decision model

A third model role, with its own picker.

Role	Typical work	Result
`Primary model`	Conversation and agent work	Messages and tool calls
`utilityModel`	Short language tasks such as titles and summaries	Generated text
`decisionModel`	Classification, rubric scoring and predicate checks	Typed answers with probability estimates

A decision model reads evidence and a rubric and returns a choice, a score position or a probability that a condition holds. OpenClaw gives it a separate Decision picker in the Control UI, so choosing Jev never replaces your chat model. Selecting one does not start background work by itself; plugins and the decision_evaluate tool use it when they need a judgment. There is no automatic fallback to the chat model when the decision provider is unavailable.

OpenClaw maintainer Josh Lehman’s first attempt was a plugin that gave the agent a Jev tool. It worked, but left a slow language model deciding when to call a fast one. The decision role lets plugin code call Jev directly, which is where the speed pays off. The same idea runs through our Jev agent guide.

1 · Install the plugin

Packaged separately from core, published to npm and ClawHub.

openclaw plugins install @openclaw/typesafe

The plugin is disabled by default, and installing it selects no model and schedules nothing. It needs an OpenClaw host and plugin API of at least 2026.9.6; the installer refuses older hosts before loading it. On a source checkout, build with pnpm install --frozen-lockfile and pnpm build instead.

2 · Configure hosted Jev or a local model

One plugin, two modes. The endpoint is a plugin setting, not a per-model choice.

Hosted Jev

{
  plugins: {
    allow: ["typesafe"],
    entries: {
      typesafe: {
        enabled: true,
        config: {
          apiKey: { source: "store", provider: "default", id: "TYPESAFE_API_KEY" },
        },
      },
    },
  },
  agents: {
    ownership: "explicit",
    defaults: { decisionModel: "typesafe/jev-latest" },
    entries: {
      research: { decisionModel: "typesafe/jev-1.13.0" },
      quiet: { decisionModel: "" },          // decisions off for this agent
    },
  },
}

Store the TypeSafe key under Settings → Secrets and reference it; the plugin reads only that prepared secret, never environment variables. typesafe/jev-latest follows TypeSafe’s newest model; typesafe/jev-1.13.0 pins the current one. An empty per-agent value turns decisions off for that agent.

Local System One server

{
  plugins: {
    allow: ["typesafe"],
    entries: {
      typesafe: {
        enabled: true,
        config: { baseUrl: "http://127.0.0.1:8009" },   // your local Kev server
      },
    },
  },
  agents: {
    defaults: { decisionModel: "typesafe/kev-latest" },
  },
}

baseUrl accepts only loopback origins: localhost, 127.0.0.1 or [::1], without a path. LAN and remote hosts are refused. OpenClaw starts no server and downloads no weights; run Kev yourself. Ollama and Jeeves speak the same API but failed the plugin’s validation in our test. Once baseUrl is set, every request goes local, even ones labelled Jev.

Jev AI keys: the official plugin’s hosted mode always calls TypeSafe’s fixed endpoint, and its local mode only accepts loopback addresses, so a Jev AI key cannot be used in this plugin. Use a TypeSafe key here. Jev AI keys work in tools that take a base URL, such as the n8n nodes, TypeSafe’s SDKs and your own code.

3 · Call decisions from a plugin

Any plugin can ask the configured decision model without its own provider code or key.

const outcome = await api.runtime.decisions.evaluate(
  {
    state: { message: "Checkout is failing for all customers." },
    questions: {
      route: {
        type: "choice",
        instructions: "Which team should handle this?",
        criteria: { support: "Technical problems", billing: "Charges and refunds", sales: "Buying questions" },
      },
      escalate: {
        type: "boolean",
        instructions: "Does this need incident response?",
        criteria: { true: "Widespread outage", false: "A single user or routine request" },
      },
    },
  },
  { agentId, purpose: "triage", rubricVersion: "2026-10-11", signal },
)

if (outcome.status === "ok") {
  const { route, escalate } = outcome.result.answers
  if (escalate?.type === "boolean" && escalate.probabilityTrue >= 0.9) await page(route)
}

The host picks the provider and model from the owning agent’s configuration. In OpenClaw’s vocabulary a yes/no question is boolean and its answer is probabilityTrue; the TypeSafe adapter translates it to Jev’s Noul. Scores come back as zero-based positions on your rubric. purpose and rubricVersion go into the result’s provenance, so you can tell which rubric produced which answer later.

Agents get the same capability as the core decision_evaluate tool when they have an effective decisionModel. Normal tool policy and explicit denies still apply.

Our test: the plugin against 4 backends

We installed the published package and called its own evaluate() with one three-question batch, 5 times per backend.

Backend	Plugin setting	Accepted	Median	route	urgency (0–3)	escalate
Jev, hosted (jev-1.13.0)	`apiKey (TypeSafe)`	5 / 5	737 ms	incident (1)	2.97	0.97
Kev-4B, local MLX server	`baseUrl http://127.0.0.1:8010`	5 / 5	370 ms	incident (0.94)	2.38	0.9
Ollama 0.40.2, nimble as kev-latest	`baseUrl http://127.0.0.1:11434`	0 / 5	—	—	—	—
Jeeves FP8, local server (thinking off)	`baseUrl http://127.0.0.1:8009`	0 / 5	—	—	—	—

What we did

Installed @openclaw/[email protected] and [email protected] from npm and imported the plugin’s compiled evaluate(), the function the host calls. No gateway or chat model was involved.
Sent the same state, a support message about a checkout outage, with three questions: a Choice of team, a four-level urgency Score and an escalate Noul.
Hosted Jev went through the plugin’s TypeSafe path with our TypeSafe key. Local servers went through baseUrl on 127.0.0.1, on an Apple M5 Pro laptop.

What we found

Hosted Jev passed every round through the plugin’s TypeSafe path: incident with probability 1, urgency about 2.97 of 3, escalate 0.97, at a 737 ms median from Asia.
Kev-4B, the local server OpenClaw documents, passed every round too, at a 370 ms median once warm; its first call took about 10 seconds while the model loaded. If you want OpenClaw decisions on your own machine today, this is the path that works without changes.
Ollama did not pass. Its /v1/systemone answer carries an extra top-level field, prompt_eval_cached_count, and the plugin rejects any field it does not know. When we removed that one field in a diagnostic copy of the plugin, Ollama passed every round, so the answers themselves are compatible. Ollama model names also need an alias without a colon, for example ollama cp nimble kev-latest, because the plugin sends kev-latest as the model.
Jeeves did not pass either. With its default thinking, our three-question batch ran past OpenClaw’s fixed 30-second deadline on a 48 GB Mac. Started with --max-think 0 it answered in about 1.1 seconds, but its usage block includes reasoning_tokens, which the plugin also rejects as an unknown field.
Strictness is deliberate in the plugin: it validates the full answer batch before returning anything. Until Ollama or Jeeves drop the extra fields, or the plugin tolerates them, a small loopback proxy that removes them is the workaround; we did not ship one.

What to use it for in OpenClaw

The judgments OpenClaw’s maintainers and plugin authors point to first.

Which tools matter for this request

Give the decision model the request and the tool list; expose only the relevant tools to the language model, so its context stays small.

Which messages survive compaction

Score each old message for whether later turns depend on it before the session is summarised.

Is anyone talking to the agent

In a group chat, a yes/no question decides whether the agent should reply or stay quiet, without a language-model call per message.

Is this tool call safe

Before a shell command or a send, ask whether it is destructive or leaves the trust boundary, and route to approval above a threshold.

The same patterns outside OpenClaw: MCP tool router · prompt injection check · agent completion check · open-source examples.

Jev and OpenClaw FAQ

Does OpenClaw support Jev?

Yes. OpenClaw added a decisionModel role after release 2026.9.5, and the official @openclaw/typesafe plugin connects that role to TypeSafe’s hosted Jev (typesafe/jev-latest or the pinned typesafe/jev-1.13.0) or to a local System One server. The plugin was published to npm as version 2026.10.1 on 10 October 2026 and needs an OpenClaw host of 2026.9.6 or later.

How do I install the TypeSafe plugin in OpenClaw?

Run openclaw plugins install @openclaw/typesafe, allow and enable the typesafe plugin in your configuration, store your TypeSafe key as a protected secret, then select typesafe/jev-latest as decisionModel for the agents that should use it. The plugin is disabled by default and installing it selects nothing.

Can I use a Jev AI key in OpenClaw?

Not through the official plugin. Its hosted mode always calls TypeSafe’s fixed HTTPS endpoint, and its baseUrl setting only accepts loopback addresses such as 127.0.0.1. Use a TypeSafe key for hosted Jev inside OpenClaw, or a local model. Jev AI keys work everywhere you can set a base URL, such as n8n nodes, the SDKs and your own code.

Can OpenClaw use Ollama or Kev instead of hosted Jev?

Kev, yes: set baseUrl to the local Kev server and select typesafe/kev-latest; it passed every round in our test. Ollama and Jeeves speak the same API but, as of 11 October 2026, their answers include extra fields (prompt_eval_cached_count and usage.reasoning_tokens) that the plugin rejects, and Jeeves with thinking on also overran OpenClaw’s 30-second deadline on a Mac. Details are in our test section.

What is decision_evaluate?

A core OpenClaw tool that an agent receives when it has an effective decisionModel. The agent passes explicit state and typed questions; the host routes them to the configured provider. Answers are evidence, not permission: they do not authorise sending, publishing or changing state.

What limits apply?

For TypeSafe, Choice takes 2 to 255 options and Score 2 to 10 levels. The host caps requests at one MiB, 20,000 JSON nodes, depth 32 and 256 questions, admits at most four concurrent requests per provider, and gives each request at most 30 seconds. Oversized input is rejected, never silently truncated.

Is there a local option without any server?

OpenClaw’s ONNX plugin runs small zero-shot classifiers such as GLiClass and DeBERTa on the CPU in a subprocess. They are much smaller than Jev-class models; compare answers on your own cases before relying on them.

About this page

Who. Jev AI runs a hosted endpoint for TypeSafe’s Jev and publishes guides and measurements around it. We are not affiliated with OpenClaw or TypeSafe.

How. Setup and limits are from OpenClaw’s decision-model and TypeSafe plugin documentation and the plugin source on GitHub; the version and publication date are from npm. The backend test used the published package on 2026-10-11; the script and raw results are in our repository.

When. Published October 11, 2026. OpenClaw ships weekly; we will update the page when the plugin or the role changes.

Sources

OpenClaw is an open-source project of its maintainers; TypeSafe and Jev are TypeSafe AI’s. Neither is affiliated with Jev AI.