A small API for big decisions.

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: "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 jeff-latest, which follows our current release, or a pinned release such as jeff-1.0.0. Omitting it means jeff-latest.

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 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 are smaller: eight questions and ten options per question, 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.

Every question needs type and instructions. Describe what each answer means for better results. Choice confidence is normalized against a uniform guess: (n × highest probability − 1) / (n − 1), where n is the number of options. 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": "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 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.
• 60 requests per minute across all keys and signed-in playground activity.
• 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, and ten options per 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 in arrival order, with keyed requests 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.

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