Jev on AWS Bedrock

If you're searching for Jev in the Amazon Bedrock model catalog, the short answer is: it isn't there as a native foundation model. Jev is TypeSafe AI's System One decision model — it doesn't generate a chat completion, it returns a typed answer (one of your options, a probability, a confidence) in a single parallel pass. That doesn't fit Bedrock's InvokeModel contract. But Jev composes cleanly with a Bedrock agent, and that's usually what people actually want.

The reason Jev isn't a Bedrock foundation model is structural, not a roadmap gap. Bedrock's InvokeModel and Converse APIs expect a generative model: you send messages, you stream back tokens. Jev's endpoint takes state plus a set of typed questions and returns typed values with calibrated confidence in roughly 70–500ms — a different request/response shape entirely. So instead of proxying Jev through Bedrock, you call it as an external decision step from inside your agent.

Is Jev available in Amazon Bedrock?

Not as a native foundation model — it won't appear in the Bedrock model catalog, and there's no InvokeModel / Converse path for it.
It doesn't fit the chat-completion contract Bedrock model access is built around; Jev emits typed structured values, not tokens.
What does work: reach Jev's hosted endpoint from a Lambda that your Bedrock agent invokes as an action group / tool.

The integration pattern that works

Your Bedrock agent (AgentCore) calls a Lambda action group; the Lambda POSTs state to Jev and hands the typed decision back to the agent.

Give your Bedrock agent an action group backed by a Lambda. When the agent needs a decision — which tool to call, whether an input is in policy, how to triage an alert — the Lambda sends the current state to Jev, gets back one typed option plus a confidence value, and returns it to the agent. The agent stays in Bedrock; Jev is just the fast, calibrated brain for the branch.

Keep your generative model on Bedrock for text; put decisions on Jev.
Jev returns one of your defined options — never a made-up label — so the agent branches on a value you can trust.
Threshold on the confidence score to fall back to a safe default when Jev isn't sure.
Each decision is sub-cent and ~70–500ms, so it's cheap to put one in front of every expensive model call.

Call Jev from a Bedrock Lambda

# Lambda backing a Bedrock agent action group.
# The agent asks: "which queue should this ticket go to?"
import json, os, urllib.request

JEV_URL = "https://jevtypesafeai.com/api/v1/decide"

def lambda_handler(event, context):
    ticket = event["inputText"]  # state passed in by the Bedrock agent
    body = json.dumps({
        "state": {"ticket": ticket},
        "questions": {
            "queue": {
                "type": "choice",
                "options": ["billing", "technical", "abuse", "sales"],
            }
        },
    }).encode()
    req = urllib.request.Request(
        JEV_URL, data=body,
        headers={
            "Content-Type": "application/json",
            "Authorization": f"Bearer {os.environ['JEV_KEY']}",  # jv_live_...
        },
    )
    jev = json.loads(urllib.request.urlopen(req).read())
    queue = jev["queue"]["value"]          # always one of the four options
    conf = jev["queue"]["confidence"]      # threshold this if you want a fallback
    return {"response": {"queue": queue, "confidence": conf}}

queue is locked to the options you sent, so the agent never has to parse free text or handle a hallucinated label. Pin a Jev model version so your confidence thresholds stay stable as models update.

Already routing through LiteLLM?

If your Bedrock stack sits behind a LiteLLM proxy, TypeSafe is available as a pass-through provider: point requests at LITELLM_PROXY_BASE_URL/typesafe instead of api.typesafe.ai and route Jev alongside your Bedrock models through the same gateway. See the LiteLLM docs in Sources below.

When to reach for this

	Bedrock LLM call	Jev decision step
Job	Generate text / reason	Pick one option, classify, judge
Output	Tokens	One typed value + confidence
Latency	The model's	~70–500ms
Reliability	May drift / hallucinate	0% structured-output error
Cost per step	Frontier-model tokens	Under a cent per decision

Sources

LiteLLM — TypeSafe (Jev) pass-through — Route Jev through a LiteLLM proxy alongside your Bedrock models.
TypeSafe AI — introducing System One models & Jev — What Jev is and why its request shape differs from a chat model.

FAQ

Is Jev a foundation model in Amazon Bedrock?

No. Jev isn't in the Bedrock model catalog and there's no InvokeModel or Converse path for it. It's a System One decision model with its own typed endpoint, so you call it directly — typically from a Lambda inside your Bedrock agent.

Can I use Jev with Bedrock AgentCore?

Yes, as an external tool. Give your agent an action group backed by a Lambda; the Lambda POSTs the current state to Jev and returns the typed decision to the agent. Your generative model stays on Bedrock.

Why isn't Jev just added to Bedrock as a model?

Bedrock's model APIs expect a generative chat/completion contract — send messages, stream tokens. Jev takes state plus typed questions and returns typed values with calibrated confidence in one pass, which is a different request and response shape.

Does calling Jev from Bedrock cost extra per decision?

Each Jev decision is well under a cent and runs in ~70–500ms. We bill per input token on a sliding scale (larger top-ups are cheaper); output is free. Exact numbers live on the pricing page.

Do I have to leave the AWS ecosystem?

No. The Lambda that calls Jev runs in your AWS account like any other action group; only the outbound HTTPS decision call leaves AWS. Everything else — the agent, your generative models, your data flow — stays on Bedrock.

Put Jev on the decision inside your Bedrock agent

Grab a jv_live_ key and return a typed, calibrated decision to your agent in one sub-cent call.

▶ Try Jev free Get an API key →