Using Jev with Composio

Composio gives your agent hundreds of real tools (GitHub, Slack, Gmail, and more). Jev is TypeSafe AI's decision model — it doesn't call tools itself, but Composio ships an official TypeSafe provider that hands Jev the fetched toolset and a plain-language request, and gets back one typed answer: run this tool, run it once you supply these arguments, or don't run anything. Each answer carries a calibrated confidence score, and choosing a tool never generates free-form text.

Normally an LLM picks the tool: you describe the tools, it emits a tool-call, and you parse and validate that call before running it. Jev is a different primitive — a single non-autoregressive pass that returns a typed value from a finite set, not generated text. Composio's TypeSafe provider uses that to turn "which of these tools answers the request?" into a typed decision over the toolset you fetched, so the selection step is calibrated and can't hallucinate a tool that isn't in the set.

Decide, then execute — they're separate steps

The key idea is that choosing a tool and running it are two steps. provider.decide(tool_set, request) asks Jev which tool fits; it does not execute anything. You read the result's kind and act on it:

• call — Jev picked a tool and its arguments; inspect them, then execute
• partial — Jev picked a tool but needs more arguments; supply the ones listed in missing, then execute
• abstain — nothing fit confidently; stop and read the reason and candidates instead of guessing

Because selection and execution are decoupled, you get a natural safety gate: a destructive tool only runs when you execute it (the provider requires an explicit confirm=True / confirm: true for those), and arguments you pass yourself override Jev's.

Set it up (Python)

The TypeSafe provider is a Composio plugin. Install Composio, the provider, and the pinned TypeSafe SDK, then set two keys — one for Composio, one for TypeSafe:

# Composio's docs pin the TypeSafe SDK to 0.6.0:
pip install composio composio-typesafe typesafe-sdk==0.6.0

export COMPOSIO_API_KEY="your-composio-key"   # from your Composio project
export TYPESAFE_API_KEY="your-typesafe-key"   # from TypeSafe

from composio import Composio
from composio_typesafe import TypesafeProvider

provider = TypesafeProvider()            # reads TYPESAFE_API_KEY
composio = Composio(provider=provider)   # reads COMPOSIO_API_KEY

# Fetch the tools you want Jev to choose among:
tool_set = composio.tools.get(
    user_id="example-user",
    tools=["HACKERNEWS_GET_USER", "HACKERNEWS_GET_TOP_STORIES"],
)

# Jev picks one — this DECIDES, it does not execute:
decision = provider.decide(tool_set, "Look up the Hacker News user 'pg'")

if decision.kind == "call":
    # inspect decision's tool + args, then run the execute step
    ...
elif decision.kind == "partial":
    # supply the arguments in `missing`, then execute
    ...
elif decision.kind == "abstain":
    # nothing fit confidently — read decision.reason / decision.candidates
    ...

There's a TypeScript provider too (@composio/core, @composio/typesafe and the pinned @typesafe-ai/sdk, with zod, on Node.js 24.17+). The shape is the same: decide returns a typed call / partial / abstain, and a separate execute step runs the chosen tool.

Pin the model in production

The provider's default model is jev-latest, which moves over time — and because Jev's confidence is calibrated, a new version can shift what a given threshold means. For production, pin a versioned model id (TypesafeProvider(model="...")) so your tool-selection behaviour stays stable until you choose to upgrade. See the context and versioning notes on the JevBench and context-window pages.

Shortlisting a big toolset

If you have far more tools than you want to hand Jev at once, the provider also exposes a helper that ranks your raw tools against the request and keeps only the most relevant top-k, so the decide call sees a focused set. Check Composio's TypeSafe provider docs for the current helper name and limits.

Note on the project

The TypeSafe provider is maintained by Composio as part of its provider ecosystem — it's Composio's integration, not a TypeSafe AI product. What it needs from our side is a TypeSafe key (and the hosted Jev model behind it). Follow Composio's own docs for install, the exact method signatures, and supported versions; this page explains the decide-vs-execute model and how Jev fits.

• Composio docs — TypeSafe provider — Composio's official provider docs: install, the decide/execute methods, and key setup (maintained by Composio).

FAQ

See also: Jev over MCP · Jev for coding agents · Jev for computer use · Jev API · Playground