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

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):
    # Bedrock passes the caller's text as a requestBody property:
    props = event["requestBody"]["content"]["application/json"]["properties"]
    ticket = next(p["value"] for p in props if p["name"] == "state")

    body = json.dumps({
        "state": ticket,
        "questions": {
            "queue": {
                "type": "choice",
                "instructions": "Which queue should this ticket go to?",
                "criteria": {
                    "billing": "payments, refunds, invoices",
                    "technical": "bugs, errors, how-to",
                    "abuse": "spam, fraud, policy violations",
                    "sales": "pricing, upgrades, new purchases",
                },
            }
        },
    }).encode()
    req = urllib.request.Request(
        JEV_URL, data=body,
        headers={
            "Content-Type": "application/json",
            "Authorization": f"Bearer {os.environ['JEV_API_KEY']}",  # jv_live_...
        },
    )
    answers = json.loads(urllib.request.urlopen(req).read())["answers"]
    queue = answers["queue"]["choice"]        # one of your four criteria keys
    conf = answers["queue"]["confidence"]     # threshold this for a fallback

    # Return the Bedrock action-group response envelope:
    return {
        "messageVersion": "1.0",
        "response": {
            "actionGroup": event["actionGroup"],
            "apiPath": event["apiPath"],
            "httpMethod": event["httpMethod"],
            "httpStatusCode": 200,
            "responseBody": {"application/json": {"body": json.dumps({"queue": queue, "confidence": conf})}},
        },
    }

The response is a map under answers, and answers.queue.choice is locked to the criteria keys you sent — so the agent never parses free text or handles a hallucinated label. It's wrapped in Bedrock's action-group response envelope so the agent can read it directly. Pin a Jev model version so your confidence thresholds stay stable as models update.

Deploy it in one command

You don't have to hand-wire the Lambda, its permissions, and the schema. The jev-bedrock starter is a SAM template that stands the whole action group up with one deploy — clone it, pass your jv_live_ key, and you get a Lambda ARN to attach to your agent.

git clone https://github.com/codaaiteam/jev-bedrock
cd jev-bedrock
sam build
sam deploy --guided --parameter-overrides JevApiKey=jv_live_your_key
# → prints a FunctionArn output — that's the Lambda for your action group

A Bedrock action group also needs an OpenAPI schema so the agent knows how to call your Lambda. That's the piece people miss — here it is; upload it when you add the action group (it's openapi.yaml in the starter):

openapi: 3.0.0
info: { title: Jev Decision, version: 1.0.0 }
paths:
  /decide:
    post:
      operationId: decide
      summary: Make a fast, typed decision about the current situation.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [state]
              properties:
                state:
                  type: string
                  description: The situation to decide on, as plain text.
      responses:
        "200":
          description: One entry per question, each with a typed value and confidence.
          content:
            application/json:
              schema:
                type: object
                additionalProperties:
                  type: object
                  properties:
                    value: { description: chosen option, score, or 0-1 probability }
                    confidence: { type: number }

The answer space is yours: it lives in the Lambda (src/handler.py), not in the agent, so the model can't invent an option. Edit the questions there — or set the QUESTIONS_JSON env var — to route, classify, score, or gate whatever your agent decides. Everything defaults to the hosted gateway with your jv_live_ key, so each decision is billed to your Jev account.

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

Sources

• jev-bedrock — SAM starter — One-command deploy of the Lambda action group, OpenAPI schema included.
• 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

See also: jev-bedrock starter (GitHub) · Bedrock integration guide · Jev over MCP · How to use the Jev API · Pricing