Jev Images and Box Questions: What the Preview Can Do

Quick answer

• Images are opt-in and preview-grade. Send TypeSafe-Danger-Zone-Images: true; TypeSafe calls the feature dreamer-ready, not production-ready.
• Jev 1.13 and 1.14 accept images. Box questions need Jev 1.14 and are available through jev-preview or the versioned jev-1.14.0.
• An image can sit in the state, in a question’s instructions, or in its criteria. Every image reference must be used somewhere in the request.
• A Box answer gives fractional top, bottom, left, and right edges plus confidence. It has no “not found” answer, so pair it with a Noul.
• For a production image workload, benchmark a production multimodal option such as Clef, or OpenAI’s beta Decisions API, and keep a text-only fallback.

What is actually available

TypeSafe’s models page describes Jev as a text model, but the documentation also has an images page and a Box question type. Both are real and both are explicitly marked as preview features. The docs call them “dreamer-ready”: useful for prototypes and internal tools, not yet up to the vendor’s standard for production. The request format, answer fields, limits, and accuracy can change between releases.

The practical reading is that Jev is a text decision model with an experimental vision path. Jev 1.13 and 1.14 both accept images. Box questions, which return the location of an object in an image, require Jev 1.14. The jev-latest alias still points at 1.13, so a request that uses the alias will not get Box support; send jev-preview or jev-1.14.0 explicitly.

Turn images on for the request

Images and Box questions are off by default. Every request that contains an image or a Box question needs the TypeSafe-Danger-Zone-Images: true header. Without it, the request is rejected or the image is not processed as an image. The header is per request, not an account setting, so put it in the same place you set the authorization header.

The Python and JavaScript SDKs create an image reference for you and upload the file. With the raw API, send a multipart/form-data request with the JSON body as the first part named request, then each image as its own file part. Base64 inside JSON also works, but it makes the request about a third larger and counts toward the body limit. Prefer multipart unless your client cannot send it.

from pathlib import Path
from typesafe_sdk import Choice, Image, Noul, TypeSafeClient

with TypeSafeClient() as client:
    result = client.system_one(
        model="jev-1.14.0",
        state={"door": Image(Path("door-camera.jpg"))},
        questions={
            "person_present": Noul(
                instructions="Is there a person in `door`?",
            ),
            "carrying": Choice(
                instructions="What is the person in `door` carrying?",
                criteria={
                    "package": "A box, parcel, or delivery bag.",
                    "bag": "A handbag, backpack, or shopping bag.",
                    "nothing": "Empty hands.",
                },
            ),
        },
        extra_headers={"TypeSafe-Danger-Zone-Images": "true"},
    )

print(result.answers["person_present"].noul)
print(result.answers["carrying"].choice)

Put the image in the state, instructions, or criteria

An image in the state is part of the shared evidence, and every question in the request can see it. That is the efficient placement when several questions are about the same photo. Refer to it by name or path in backticks, such as photo or frames[2].frame, the same way you refer to a text field. A state can mix images with text and can hold several labeled images.

An image in a question’s instructions is sent only with that question. Use this when one question compares the state to a reference image, such as a badge photo or a product catalog shot. An image in the criteria defines an option or level by example. Choice options can be an image on its own, a description with example images, or text only. This is useful for visual categories that are hard to describe in words.

References are matched as plain text anywhere in the request, so use values that cannot occur by accident. A short reference such as cat can match inside category. A UUID per image is the safest choice. Every asset must be referenced; an unused asset returns a 400. Each use adds another copy of the image to what the model reads, so referring to the same image from five questions costs more than putting it in the state once.

Use a Box question to locate an object

A Box question asks where something is in an image. It takes only type and instructions; it does not take criteria. The answer is a bounding box with top, bottom, left, and right as fractions from zero to one, measured from the top-left corner. Multiply each edge by the image’s width or height to crop or draw the box. A Box answer also includes a confidence value.

The most important limitation is that a Box always returns a box. There is no “not found” result, so a question about an object that is absent still produces four edges. Pair the Box with a Noul that asks whether the object is visible, and ignore the box when the Noul probability is low. If the image may contain several instances of the same object, describe the one you want precisely, or split the image into regions and ask again.

Box questions need Jev 1.14. The request’s model field must be jev-preview or jev-1.14.0, and the danger-zone header must be present. Box coordinates are fractional, so they survive resizing; they are not pixel coordinates. If you crop to the box and the target is cut off, ask one Noul per edge whether the target continues past that edge, then pad and retry.

{
  "model": "jev-preview",
  "state": {"photo": "6e1d0b7c-kitchen"},
  "assets": {
    "6e1d0b7c-kitchen": {
      "type": "image",
      "format": "jpg",
      "part": "kitchen-photo"
    }
  },
  "questions": {
    "mug_visible": {
      "type": "noul",
      "instructions": "Is there a coffee mug in `photo`?"
    },
    "mug": {
      "type": "box",
      "instructions": "the coffee mug in `photo`"
    }
  }
}

Respect the image and size limits

Images add tokens as well as bytes. A full-resolution photo can consume a meaningful share of the 64k request context, and the same image referenced in several places is counted each time. Resize and crop before sending, and put a shared image in the state once rather than in every question. A smaller, sharper crop is usually better for a small target than a large scene.

The raw API accepts PNG, JPEG, and JPG images. The request body limit is 32 MiB, and a base64-encoded image is about a third larger than the file, so multipart is the safer transport for large photos. Each reference can be at most 1,024 bytes of UTF-8, and all references together at most 65,536 bytes. These are provider limits and can change; check the current images page before building a pipeline around them.

Send only the images the decision needs. A doorbell photo may contain faces, plates, and neighbors’ property. Redact or crop where possible, and check the data-retention terms for your plan. An image is personal data in many jurisdictions even when the text beside it is not.

Test the image path before trusting it

Build a labeled set of at least 100 images that resemble production: different lighting, angles, resolutions, backgrounds, and the edge cases your operators see. Measure the answer accuracy for each question, the calibration of the confidence value, and the share of low-confidence answers. A model that is accurate on clean catalog photos can fail on phone photos with clutter and glare.

For Box questions, measure intersection-over-union against hand-drawn boxes, not just whether the box looks plausible. Track the miss rate for small objects and the share of boxes that are returned for absent objects; the Noul companion is what protects you from the latter. For classification questions, include images where the correct answer is “none of the above” and verify that the model uses the escape option rather than forcing a label.

Run the same set when the model version, image preprocessing, or question wording changes. The preview label means the model can change without a major-version signal, so a pinned version plus a repeatable evaluation is the only way to know what you are shipping. Keep the raw image hash with the result so a bad decision can be reproduced.

When to use a production multimodal model instead

If image input is core to the product, Jev’s preview is not the safe default yet. Cloudflare’s Clef and Clef-flash accept images on Workers AI, and OpenAI’s Decisions API accepts images and returns predicate, choice, and score answers. Clef’s 27B model costs $0.24 per million input tokens; Clef-flash is the 9B model at $0.038 with a smaller 24k context. OpenAI’s Decisions API is in public beta at $0.10 per million input tokens on GPT-6 Luna.

The trade is not only price. Clef has generally available image support, and OpenAI treats images as a first-class input even while its Decisions endpoint is in beta. Both document image tokenization and return typed answers. Jev’s advantage is the same as in text: a small typed contract and a low per-token price. A reasonable architecture is to keep Jev for text decisions and route image-bearing requests to a production multimodal model, rather than making the preview path carry a customer-facing workflow.

Where this bites vibecoders

A coding assistant that sees an images page and a Box primitive will happily wire a camera feed straight into a refund or access-control decision. The page’s own warning is the important part: this is dreamer-ready. Build the prototype, measure it on real images, and keep the action behind a human or a production multimodal fallback until the evaluation says otherwise.

Where AI coding assistants get this wrong

• Forgetting the TypeSafe-Danger-Zone-Images: true header and assuming the image was read.
• Using jev-latest for Box questions; the alias points at 1.13, which does not support Box.
• Treating a Box answer as proof that the object exists, even when the target is absent.
• Sending a full-resolution photo when a cropped, resized image would be cheaper and sharper.
• Referencing the same image in every question instead of once in the state.
• Shipping a preview image path into a customer-facing decision without a fallback.

Checklist

• Confirm the feature is still labeled preview in the current docs.
• Send the danger-zone header on every image request.
• Use jev-preview or jev-1.14.0 for Box questions.
• Put shared images in the state and refer to them by path.
• Pair every Box with a Noul that checks visibility.
• Resize, crop, and redact images before sending.
• Measure accuracy, calibration, and Box overlap on your own images.
• Keep a production multimodal fallback for customer-facing paths.

FAQ

Are Jev images production-ready?

No. TypeSafe labels images and Box questions dreamer-ready rather than production-ready. The request format, answers, limits, and accuracy can change between releases. Use them for prototypes and internal tools, measure on your own images, and keep a production fallback for customer-facing decisions.

Which model do I need for images and Box?

Jev 1.13 and 1.14 accept images. Box questions need Jev 1.14, so send jev-preview or jev-1.14.0. The jev-latest alias points at 1.13 and will not give you Box support.

Can Jev read an image from a URL?

The documented image input is an uploaded file or base64 data, not a remote URL. Fetch the image yourself, check its type and size, and send it as a file part or base64 asset. That also lets you resize and redact before the request.

What does a Box answer look like?

It contains top, bottom, left, and right as fractions from 0 to 1, plus a confidence value. Multiply the horizontal edges by the image width and the vertical edges by the height to get pixels. There is no not-found result, so use a companion Noul for presence.

Can I find several objects with one Box question?

No. One Box question returns one box. Ask one Box question per object, or split the image into regions and run the question on each. If several instances of the same object are present, describe the one you want precisely, such as the mug nearest the sink.

Is Jev image input cheaper than Clef?

Jev’s listed text price is $0.042 per million input tokens, while Clef is $0.24 and Clef-flash is $0.038. Images are converted to tokens, and the number depends on the image size and the provider’s tokenization. Measure the real cost on your images rather than comparing headline text rates.

Related topics

• Jev AI: The Complete Guide to TypeSafe’s Decision Model
• Jev vs Laya vs Clef: Which Decision Model Should You Use?
• How to Write Decision Questions for Jev and Laya
• How to Evaluate a Decision Model Before You Ship It
• Jev Use Cases: 15 Decisions Worth Replacing an LLM Call For
• Jev Pricing: What a Decision Actually Costs

Sources

• TypeSafe Documentation
• TypeSafe Documentation
• TypeSafe Documentation
• Cloudflare Workers AI Documentation
• OpenAI API Documentation