← Use cases

OpenAI Dots, and the decision underneath them

OpenAI's Dots are always-on agents that pursue your goals in the background and — per rules you set — either act on their own or pause to ask you. That act-or-ask call is a decision made thousands of times a day. Here's what Dots are, and how to give the agents you build the same gate as one fast typed call with Jev.

At DevDay on September 29, 2026, OpenAI launched Dots: always-on agents that run in the background, connect to thousands of apps, and can message you in ChatGPT, Slack or Teams. The detail that matters for anyone building agents isn't the avatar — it's that a Dot follows custom rules about when it may act independently versus when it must get your approval first.

always-on agent proposes an action Jev gate act alone? typed act autonomously check with you first runs 24/7
Every always-on agent lives on one repeated call: act on its own, or check with you first. That's a decision — and a decision is exactly what Jev returns.

What OpenAI Dots are

Dots are OpenAI's own closed product — you configure them, you don't extend them, and Jev has no affiliation with OpenAI. What's worth copying is the pattern Dots put in front of everyone: an agent that runs unattended has to decide, over and over, whether this next action is safe to take on its own.

The decision every unattended agent runs on

"Act on my own, or check with the human first?" is the load-bearing call in any always-on agent. Get it wrong toward action and the agent sends the wrong email or deletes the wrong file; get it wrong toward caution and it pings you for everything and stops being useful. Today teams answer it two clumsy ways: a brittle static allow-list, or a second LLM prompt that asks the model to reason about itself — slow, expensive per step, and poorly calibrated.

Jev is built for exactly this call. It's a System One model that returns a typed, calibrated decision in a single non-autoregressive pass — about 70–500ms, far cheaper than a frontier-LLM self-check — so you can vet every action instead of sampling. Ask it a noul (a calibrated yes/no) and branch your loop on the number.

Give your own agent the same gate

You can't paste this into a Dot, but if you're building or wrapping an always-on agent, drop Jev between 'propose action' and 'run action':

// Always-on agent loop: decide act-alone vs ask-the-human, every step
async function step(proposedAction, context) {
  const res = await fetch("https://jevtypesafeai.com/api/v1/decide", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.JEV_KEY}`, // jv_live_...
    },
    body: JSON.stringify({
      state: { action: proposedAction, context },
      questions: {
        actAlone: { type: "noul", instructions: "Safe and reversible for the agent to do on its own, without asking the human first?" },
        kind: { type: "choice", instructions: "Classify the action.",
                criteria: { read: "reads data", write: "writes data", send: "sends/posts", destructive: "deletes/irreversible" } },
      },
    }),
  });
  const { answers } = await res.json();

  if (answers.actAlone.noul > 0.85 && answers.kind.choice !== "destructive") {
    await run(proposedAction);          // confident + non-destructive → act
  } else {
    await askHuman(proposedAction);     // otherwise → check with the human
  }
}

answers.actAlone.noul is a calibrated probability that RLCD training makes trustworthy; answers.kind.choice is locked to the criteria you listed, so there's no invalid class to handle. Tune 0.85 against your own logs — raise it on send/destructive surfaces, lower it where a mistake is cheap.

Prefer no code? Give the agent a decide tool once and drop in a rule that makes it check risky actions before running them:

npx github:codaaiteam/jev-mcp   # gives the agent a `decide` tool (set JEV_API_KEY=jv_live_...)

Which primitive to use

This is the same gate the /jev-computer-use pattern puts in front of a clicking agent — the surface changes, the typed decision doesn't.

FAQ

Can I add Jev to OpenAI Dots?

No — Dots is a closed OpenAI product you configure, not a framework you extend, and Jev is unaffiliated with OpenAI. But if you build or wrap your own always-on agent, Jev gives it the same act-or-ask discipline Dots run on, as one fast typed call.

Is Jev a competitor to OpenAI Dots?

No. A Dot is an agent that does the work; Jev is a decision primitive an agent calls to decide whether to act. They sit at different layers — one acts, one judges — so they're complementary, not alternatives.

Why not just ask GPT 'should I act?' each step?

You can, but a second LLM prompt is slow and expensive to run on every action and its confidence isn't calibrated. Jev returns a typed answer with a trustworthy probability in about 70–500ms, so you can afford to check every step.

What are OpenAI Dots, briefly?

Always-on agents OpenAI announced at DevDay on Sept 29, 2026: powered by GPT-6 Astra, each with its own cloud computer and browser, reachable in ChatGPT, Slack or Teams, that follow your rules on when to act alone versus ask first.

See also: Jev for computer use · What a decision API is · OpenAI Decisions API vs Jev · Jev MCP server

Give your agent an act-or-ask gate

Grab a jv_live_ key and add one fast, calibrated check before every autonomous action.

▶ Try Jev freeGet an API key →
OpenAI Dots — and the act-or-ask decision every always-on agent needs · Jev by TypeSafe AI