Decisions API - each::labs

The Decisions API answers a set of typed questions over the same context. Instead of free-form text, it returns a probability, one of a named set of options, or a score on an ordered scale, so a caller can branch on the result without parsing prose. Use the same each::labs API key and base URL as the rest of each::api:

https://api.eachlabs.ai/v1

The Decisions API is in alpha. Its request and response contract may change without notice while it is stabilized, so avoid depending on it in production yet. Contact us if you want to build against it.

Model and routing

Send one of the supported model IDs below as the model. each::labs routes the request through the LLM Router to OpenRouter. You call a single each::labs endpoint; provider selection and credentials stay on our side, and usage is billed to your each::labs account. Unlike chat completions, this is not an OpenAI-compatible operation and has no corresponding OpenAI SDK method. Call it directly over HTTP.

Supported models

The list of decision models changes as models are added or retired, so read it from the API instead of hard-coding it:

curl https://api.eachlabs.ai/v1/decisions/models \
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "models": [
    { "id": "cloudflare/clef" },
    { "id": "liquid/d1" },
    { "id": "typesafe/jev-1.13" }
  ]
}

Every id in the response is accepted as model. Use it exactly as returned. The examples below use typesafe/jev-1.13; replace it with another listed ID to select that model.

Endpoint

POST https://api.eachlabs.ai/v1/decisions

A request is answered synchronously: one call evaluates every question and returns the answers in the response body. There is no prediction to poll.

Authentication

Pass a standard API key as a Bearer token:

Authorization: Bearer YOUR_API_KEY

Request body

The body takes model, state, questions, and an optional images field. Any other field is rejected.

Field	Type	Description
`model`	string	The decision model ID. See Supported models.
`state`	string \| object \| array	The shared context every question is evaluated against.
`questions`	object	A map of question names to typed questions. At least one is required.
`images`	array of strings	Optional images to evaluate with `state`. See Images.

Each question is an object with a type, instructions, and — depending on the type — criteria:

`type`	Meaning	`criteria`
`noul`	A yes/no probability.	Optional object with exactly `true` and `false` keys describing each side.
`choice`	Choose one of a named set of options.	Required object mapping each option name to an optional description (a value may be `null`).
`score`	Rate on an ordered scale.	Required array of level descriptions, lowest first.

instructions and every criteria value accept a string, an object, or an array. The response preserves your question names as the keys of answers.

Streaming, asynchronous mode, provider overrides, webhooks, and client-supplied metadata or source are not supported on this endpoint. For asynchronous runs and webhooks, run Decisions as a model instead. Sending them — or an X-Provider or webhook header — returns 400. Organization, user, execution, and source identity are always taken from the authenticated key.

Images

Models that read images also evaluate images sent with the request. Pass them in images. Each entry can be an image URL, a base64 data URL, or plain base64:

{
  "model": "cloudflare/clef",
  "state": "Analyze the person in the image.",
  "images": ["https://example.com/photo.jpg"],
  "questions": {
    "hair_color": {
      "type": "choice",
      "instructions": "What is the person's hair color? Choose unknown if unclear.",
      "criteria": { "black": null, "blonde": null, "brown": null, "unknown": null }
    }
  }
}

each::labs downloads URLs and sends every image to the model as a base64 data URL. You can also put images inside a state array as image_url items; text items are plain strings:

"state": [
  "Analyze the person in the image.",
  { "type": "image_url", "image_url": { "url": "data:image/jpeg;base64,/9j/4AAQ..." } }
]

The url can be an image URL, a base64 data URL, or plain base64. each::labs also accepts these shapes and converts them before calling the model:

A Responses-style part: { "type": "input_image", "image_url": "https://..." }.
image_url given as a plain string instead of an object.
An image part nested inside an object, such as "state": { "photo": { "type": "image_url", ... } }. The image moves to its own state item, and [image 1] is left in its place so your text can still refer to it.
Send state as a JSON array, not as a string that contains JSON. A string is read as text, so the model never sees the image and the base64 is billed as input tokens. Such a request returns 400.
Images must be PNG, JPEG, or WebP. Send up to 16 images per request, each under 5 MB and 12 MB in total. A URL must be public http or https.
Only some decision models read images, for example cloudflare/clef, cloudflare/clef-flash, typesafe/jev-1.13, and liquid/d1. A text-only model reads the image as text. Model limits also apply: Clef works best with images under about 300 KB. Jev accepts PNG and JPEG with each side between 256 and 1568 px and 78,400 to 2,458,624 px in total; smaller images return 400.

Example

curl https://api.eachlabs.ai/v1/decisions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "typesafe/jev-1.13",
    "state": "Applicant is 34, income 120k, no dependents, existing card holder.",
    "questions": {
      "approve": {
        "type": "noul",
        "instructions": "Should this application be approved?"
      },
      "segment": {
        "type": "choice",
        "instructions": "Pick the customer segment.",
        "criteria": {
          "premium": "high spend, long tenure",
          "standard": "typical retail cardholder"
        }
      },
      "risk": {
        "type": "score",
        "instructions": "Rate the credit risk.",
        "criteria": ["low", "medium", "high"]
      }
    }
  }'

import requests

response = requests.post(
    "https://api.eachlabs.ai/v1/decisions",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "typesafe/jev-1.13",
        "state": "Applicant is 34, income 120k, no dependents, existing card holder.",
        "questions": {
            "approve": {
                "type": "noul",
                "instructions": "Should this application be approved?",
            },
            "segment": {
                "type": "choice",
                "instructions": "Pick the customer segment.",
                "criteria": {
                    "premium": "high spend, long tenure",
                    "standard": "typical retail cardholder",
                },
            },
            "risk": {
                "type": "score",
                "instructions": "Rate the credit risk.",
                "criteria": ["low", "medium", "high"],
            },
        },
    },
    timeout=300,
)
response.raise_for_status()

print(response.json()["answers"])

Response

{
  "answers": {
    "approve": { "type": "noul", "noul": 0.82 },
    "segment": {
      "type": "choice",
      "choice": "standard",
      "confidence": 0.71,
      "probabilities": { "premium": 0.29, "standard": 0.71 }
    },
    "risk": {
      "type": "score",
      "score": 1.4,
      "legend": { "0": "low", "1": "medium", "2": "high" },
      "probabilities": { "0": 0.12, "1": 0.68, "2": 0.2 }
    }
  },
  "model": "typesafe/jev-1.13",
  "usage": { "input_tokens": 118, "output_tokens": 24, "cost": 0.0031 }
}

Answer fields

Every answer carries the question’s type. The remaining fields depend on it:

`type`	Fields
`noul`	`noul` — the probability that the answer is “yes”, between `0` and `1`.
`choice`	`choice` — the selected option name. Optional `confidence` and `probabilities`, keyed by option name.
`score`	`score` — the chosen level’s index. Optional `confidence`, `probabilities`, and `legend`, which maps each level index to its description.

Usage

Field	Type	Description
`model`	string	The resolved model id.
`usage.input_tokens`	integer	Tokens consumed by `state` and `questions`.
`usage.output_tokens`	integer	Tokens generated for the answers.
`usage.cost`	number	The billable cost in USD for this call.

When the upstream returns a decision id, it is included in the response.

Run as a model

Decisions is also available as the eachlabs-decisions model, so you can run it like any other each::labs model: through POST /v1/prediction, in the playground, and as a step in a workflow. The input takes the same model, state, questions, and images fields as the request body above. In the playground, upload files in the Images field.

curl -X POST https://api.eachlabs.ai/v1/prediction \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "eachlabs-decisions",
    "input": {
      "model": "typesafe/jev-1.13",
      "state": "The sky is blue today.",
      "questions": {
        "relevant": {
          "type": "noul",
          "instructions": "Does this mention the sky?"
        }
      }
    }
  }'

import requests

response = requests.post(
    "https://api.eachlabs.ai/v1/prediction",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "eachlabs-decisions",
        "input": {
            "model": "typesafe/jev-1.13",
            "state": "The sky is blue today.",
            "questions": {
                "relevant": {
                    "type": "noul",
                    "instructions": "Does this mention the sky?",
                },
            },
        },
    },
    timeout=30,
)
response.raise_for_status()

print(response.json()["predictionID"])

The call returns a prediction ID. Poll GET /v1/prediction/{id}, or pass a webhook_url, until status is success. The output has the same answers, model, and usage fields as a direct response:

{
  "status": "success",
  "output": {
    "answers": { "relevant": { "type": "noul", "noul": 1 } },
    "model": "typesafe/jev-1.13",
    "usage": { "input_tokens": 278, "output_tokens": 22, "cost": 0.0000123 }
  }
}

An unsupported input.model returns 400 with a message naming the ID.

In a workflow

Add an eachlabs-decisions model step, then branch on or pass along its answers with a $. reference to $.<step_id>.primary.answers.<question>:

{
  "id": "decide",
  "type": "model",
  "model": "eachlabs-decisions",
  "params": {
    "model": "typesafe/jev-1.13",
    "state": "$.inputs.ticket",
    "questions": {
      "color": {
        "type": "choice",
        "instructions": "Which color does the ticket ask for?",
        "criteria": { "red": null, "blue": null }
      }
    }
  }
}

A later step reads the selected option with $.decide.primary.answers.color.choice.

Error responses

Errors use the same shape as the rest of each::api:

{
  "error": {
    "message": "Invalid API key",
    "type": "authentication_error",
    "code": "invalid_api_key"
  }
}

Status	`type`	Description
`400`	`invalid_request_error`	The body is not a JSON object, contains an unsupported field, has no valid questions, or names a model that is not in the supported list.
`401`	`authentication_error`	The API key is missing or invalid.
`402`	`insufficient_quota`	The organization’s balance is below the minimum for an execution.
`404`	`not_found_error`	The Decisions API is not enabled for your account or environment.
`5xx`	`server_error`	The model service failed or timed out. Retry, and simplify the input if it persists.

​Model and routing

​Supported models

​Endpoint

​Authentication

​Request body

​Images

​Example

​Response

​Answer fields

​Usage

​Run as a model

​In a workflow

​Error responses

Model and routing

Supported models

Endpoint

Authentication

Request body

Images

Example

Response

Answer fields

Usage

Run as a model

In a workflow

Error responses