EU hosted models by BevelVisit Bevel
CLEAR FROM THE FIRST CALL.

A small API for big decisions.

Send context and one or more questions. Receive structured answers with probabilities, ready for your application.

New here? Create an account to get an API key and €5 in starting credits.

Your first decision.

Send a POST request to /v1/systemone on this website’s origin. Add your API key and describe the options in natural language. Examples below use the address you’re visiting.

const response = await fetch("https://eu-jev.com/v1/systemone", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "eu-jeff-latest",
    state: "I was charged twice. Can I get a refund?",
    questions: {
      team: {
        type: "choice",
        instructions: "Which team should handle this?",
        criteria: {
          billing: "Payments, invoices, and refunds",
          support: "Technical issues and bugs"
        }
      }
    }
  })
});

if (!response.ok) throw new Error(await response.text());
const { answers } = await response.json();
console.log(answers.team.choice); // "billing"

The state may be a string, JSON object, or array. The questions object maps your chosen names to questions. You can include up to eight questions per request. The optional model field takes eu-jeff-latest, which follows our current release, or a pinned release such as eu-jeff-1.0.0. Omitting it means eu-jeff-latest. The earlier names jeff-latest and jeff-1.0.0 are still accepted and answer with the current release.

Jev-style requests and compatibility.

We follow TypeSafe’s System One HTTP request format: POST /v1/systemone, Bearer authentication, and JSON containing state and named questions. Point your HTTP client at this site, use your eu/jev key, and change model to eu-jeff-latest. eu/jev runs its own model, so a Jev model ID returns HTTP 400 instead of being answered by a different model.

eu/jev accepts strings, objects, arrays, or null for instructions and criterion descriptions. Structured entries become JSON text before token counting and inference; null Choice descriptions use the option label. These are eu/jev’s validation rules; do not assume every accepted value works identically at TypeSafe.

Compatibility covers the HTTP payload structure. Jev model IDs are not supported. Our limits differ: eight questions per request, 64 options per choice question (Jev allows 255), a 256 KiB body, 1,000 characters per instruction, and 500 per criterion after serialization. SDK interoperability and identical model results are not guaranteed. Check the error and rate-limit handling below when migrating.

Our €37 per billion input tokens matches Jev’s published input-token rate, checked 30 September 2026. Outputs are free. This is the same unit rate; the cost per request can differ because tokenization and input formatting differ between services. We count shared state once, plus each question’s input.

A key for every application.

Pass your key with Authorization: Bearer YOUR_API_KEY. Keys are created in your dashboard. A default key is generated at signup and shown once; only a hash is stored.

Keep API keys on your server, outside browser code and source control. You can have up to five active keys. Revoking a key stops new requests immediately; a request already running may finish. All keys share your account’s credit balance.

Choose the right question.

PRIMITIVECRITERIAANSWER
choiceAn object mapping 2–64 option names to descriptions.choice, probabilities, and confidence.
noulOptional object with true and false descriptions.noul: a probability between 0 and 1.
scoreAn ordered array of 2–10 descriptions, from low to high.score: expected position on a scale of 0 to N−1, with probabilities, confidence, and a legend.

Every question needs type and instructions. Describe what each answer means for better results. Choice and score confidence is the normalized inverse entropy of the probabilities: 1 − H(p) / ln(n), where n is the number of options. It is 1 when all probability sits on one option and 0 when the options are equally likely, and it is separate from the selected option’s probability.

Evaluate probability estimates on representative data before choosing automation thresholds.

Answers you can work with.

This illustrative response excerpt shows the fields used by the playground. The API also returns service metadata. Actual probabilities, token counts, and timing vary with your input.

{
  "model": "eu-jeff-1.0.0",
  "answers": {
    "team": {
      "type": "choice",
      "choice": "billing",
      "probabilities": {
        "billing": 0.95,
        "support": 0.05
      },
      "confidence": 0.9
    }
  },
  "usage": {
    "input_tokens": 64,
    "output_tokens": 0
  },
  "meta": {
    "request_id": "example-request-id",
    "latency_ms": 180
  }
}

model names the release that answered, also when you sent eu-jeff-latest or no model. The answers keys match your question names. The extra meta object includes a request ID, which matches the X-Request-ID response header, and latency_ms: server-side time for token quoting, credit reservation, and inference. It excludes earlier admission checks, final usage settlement, and your network round trip, so it is not a model-only or end-to-end measurement. No prompt or answer content is saved to the usage database.

Room to build.

  • €5 in starting credits per account, with no monthly reset or automatic charges.
  • €37 per billion input tokens. Output tokens are free.
  • Input tokens include context, instructions, answer options, and special tokens used to prepare the request. Shared state is counted once, plus each question’s input. Repeated or cached input is charged at the same rate.
  • 240 requests and about 80,000 input tokens per minute per account, across all keys and signed-in playground activity. The token budget is roughly what the service can process in a minute; it is estimated from the input size before a request is admitted, and it grows with the number of model workers.
  • Team workspace keys share one limit per workspace: 480 requests and the same input-token budget per minute, across all of the workspace’s keys. Workspace keys pause while the workspace’s seats are unpaid and return 402 with the code seats_unpaid.
  • The public playground permits 12 requests per minute and 100 per day per visitor, and its requests queue behind keyed ones.
  • Maximum 256 KiB (262,144 bytes) JSON body, 100,000 characters for string state, eight questions, 64 options per choice question, and ten levels per score question. The prepared input must fit a 32,768-position context allocation; question branches and formatting also consume that allocation. The playground’s text field has a separate 12,000-character limit.
  • Requests are served one at a time per model worker. Waiting accounts take turns, so a burst from one account does not hold up another, and keyed requests go ahead of the public playground. Under load a request waits its turn, up to 20 seconds, instead of failing; only a full queue returns 503 with a Retry-After header.

The playground uses the same service as the API. Anonymous playground calls are free; signed-in runs use your credits. Failed requests do not consume credits. If the service is unavailable, the request returns an error.

Your balance stays in your control.

We check the exact input cost before inference and charge only for a successful result. Failed requests cost nothing. Signed-in playground requests use the same balance as your API keys.

If a request costs more than your available credit, it stops before inference and returns HTTP 402 with code: "insufficient_credits" and a contact_url. Contact us for extra usage through our request form.

Successful responses include meta.cost_eur, the exact charge in euros. The dashboard shows your remaining credit and each request’s cost. For example, one million input tokens costs €0.037.

When a request needs attention.

STATUSWHAT TO DO
400 / 413 / 415Check your input, model ID, body size, and Content-Type: application/json header. An unknown model, including a Jev model ID, returns 400.
401Check that your Bearer key is valid and has not been revoked.
402Your balance cannot cover this request. Contact us for extra usage.
422The model cannot process this input, including requests that exceed its prepared context allocation. Shorten or revise the request before retrying.
429Wait for the Retry-After interval if provided.
500 / 502 / 503The service is busy, starting up, unavailable, or returned an invalid response. Retry with exponential backoff and respect Retry-After when provided. Contact support with the request ID if failures persist.

Errors return JSON with an error string. Check the HTTP status before reading an answer.