Source: https://ailoot.ai/docs/nl-be/api/systemone/
Canonical: https://ailoot.ai/docs/nl-be/api/systemone/
Language: nl-be

[API](https://ailoot.ai/docs/nl-be/) 

# Jev — beslissingsmodel

[Markdown](https://ailoot.ai/docs/nl-be/api/systemone/index.md)

Het beslissingsmodel Jev van TypeSafe beantwoordt getypeerde vragen over tekst of JSON: een optie kiezen, een score op een schaal of ‘ja/nee’ met waarschijnlijkheden. Het is geen chat en genereert geen tekst.

POST`https://api.ailoot.ai/v1/systemone`

Jev — beslissingsmodel

```bash
curl https://api.ailoot.ai/v1/systemone \
  -H "Authorization: Bearer $AILOOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Help! Mijn uitbetalingen mislukken al 3 dagen.",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "Drukt dit urgentie uit?"
      }
    }
  }' 
```

```python
import json, os, urllib.request

body = {
    "model": "jev-latest",
    "state": "Help! Mijn uitbetalingen mislukken al 3 dagen.",
    "questions": {
        "is_urgent": {"type": "noul", "instructions": "Drukt dit urgentie uit?"},
    },
}
req = urllib.request.Request(
    "https://api.ailoot.ai/v1/systemone",
    data=json.dumps(body).encode(),
    headers={"Authorization": "Bearer " + os.environ["AILOOT_API_KEY"],
             "Content-Type": "application/json"},
)
with urllib.request.urlopen(req, timeout=60) as resp:
    result = json.load(resp)
print(result["answers"]["is_urgent"]["noul"])  # 0.95
```

```js
const resp = await fetch("https://api.ailoot.ai/v1/systemone", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.AILOOT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "jev-latest",
    state: "Help! Mijn uitbetalingen mislukken al 3 dagen.",
    questions: {
      is_urgent: { type: "noul", instructions: "Drukt dit urgentie uit?" },
    },
  }),
});
const result = await resp.json();
if (!resp.ok) throw new Error(`${resp.status} ${JSON.stringify(result)}`);
console.log(result.answers.is_urgent.noul); // 0.95
```

200 OK

```json
{
  "model": "jev-1.13.0",
  "answers": {
    "is_urgent": {
      "type": "noul",
      "noul": 0.95
    }
  },
  "usage": { "input_tokens": 296, "output_tokens": 20 }
}
```

Jev is een beslissingsmodel van TypeSafe in de klasse System One. Het schrijft geen tekst en voert geen gesprekken: je geeft een **toestand** (`state`) door — tekst of JSON — en een reeks **vragen**, en krijgt getypeerde waarden met waarschijnlijkheden terug. Je code kan daarmee direct vertakken, sorteren en routeren, zonder vrije tekst te hoeven parsen.

Alle vragen in één verzoek worden parallel en onafhankelijk van elkaar beoordeeld aan de hand van dezelfde `state`. Volgens TypeSafe verandert het toevoegen van vragen de responstijd nauwelijks en beïnvloeden vragen elkaar niet.

| Wat | In het kort |
| --- | --- |
| Model | `jev-latest` — een alias voor de laatste stabiele versie van Jev; [kaart in de catalogus](https://ailoot.ai/models/nl-be/#m=jev-latest) |
| Methode | `POST /v1/systemone`. Dit is geen chat: de OpenAI-, Anthropic- en Gemini-formaten zijn niet geschikt voor Jev. Het antwoord komt volledig binnen als één JSON |
| Ondersteunde invoer | Alleen tekst: een string, JSON-object of array van teksten. Zet afbeeldingen, audio en video eerst om naar tekst |
| Context | 64K tokens per verzoek — state en alle vragen samen; state met de langste vraag — maximaal 32K |
| Taal | Volgens TypeSafe werkt het model het nauwkeurigst in het Engels; het accepteert andere talen, maar met een lagere nauwkeurigheid — controleer dit met je eigen gegevens |
| Prijs | Invoer $0.084 per 1 miljoen tokens, output gratis |

## [](https://ailoot.ai/docs/nl-be/api/systemone/#request)Verzoek

### Authenticatie

| Parameter | Type | Verplicht | Beschrijving |
| --- | --- | --- | --- |
| `Authorization` | header | verplicht | Ailoot-sleutel in de vorm `Bearer sk-…`. |

### Verzoekbody

| Parameter | Type | Verplicht | Beschrijving |
| --- | --- | --- | --- |
| `model` | string | verplicht | `jev-latest`. |
| `state` | string \| object \| array | verplicht | Wat je wilt beoordelen: tekst of JSON — een klantvraag, databaserecord, correspondentie of de huidige toestand van je applicatie. Een object met duidelijke veldnamen is meestal handiger dan één string. |
| `questions` | object | verplicht | Vragen. Je kiest zelf de sleutels; de antwoorden gebruiken dezelfde sleutels. De sleutel beïnvloedt het antwoord niet — de vraag zelf staat in `instructions`. |
| `questions.*.type` | string | verplicht | `noul`, `choice` of `score` — zie hieronder. |
| `questions.*.instructions` | string \| object \| array | verplicht | De vraag zelf. Een lange vraag met gegevens kun je als object doorgeven: de vraag in één veld, de gegevens in andere. Verwijs met backticks naar de veldnamen. |
| `questions.*.criteria` | object \| array |  | Antwoordopties verschillen per type: omschrijvingen van ‘ja’ en ‘nee’ bij noul (optioneel), een woordenboek met opties bij choice en een geordende lijst met niveaus bij score. |

## [](https://ailoot.ai/docs/nl-be/api/systemone/#question-types)Vraagtypen

| Type | Wat wordt gevraagd | Wat wordt teruggegeven |
| --- | --- | --- |
| `noul` | Is de bewering waar: ja of nee | `noul` — de kans op ‘ja’, van 0 tot 1 |
| `choice` | Welke van de opgegeven opties past | `choice`, `probabilities`, `confidence` |
| `score` | Waar state zich op jouw schaal van niveaus bevindt | `score`, `legend`, `probabilities`, `confidence` |

Je kunt de typen binnen één verzoek combineren.

### noul — ja of nee

Het veld `criteria` is optioneel: hierin kun je beschrijven wat ‘ja’ (`true`) en ‘nee’ (`false`) betekenen. Het antwoord `noul` — een getal van 0 (nee) tot 1 (ja).

```json
"is_urgent": {
  "type": "noul",
  "instructions": "Drukt dit urgentie uit?",
  "criteria": {
    "true": "Expliciet tijdsgevoelig",
    "false": "Geen urgentie aangegeven"
  }
}
```

```json
"is_urgent": {
  "type": "noul",
  "noul": 0.95
}
```

### choice — een optie kiezen

`criteria` — een woordenboek ‘optie → omschrijving’; geef `null` op als geen omschrijving nodig is. Maximaal 255 opties. In het antwoord is `choice` — de meest waarschijnlijke optie, `probabilities` — de waarschijnlijkheid van elke optie (samen 1), `confidence` — de mate van zekerheid, van 0 tot 1.

```json
"department": {
  "type": "choice",
  "instructions": "Welk team moet dit behandelen?",
  "criteria": {
    "billing": "Betalingen, facturatie, terugbetalingen",
    "technical": "Bugs, uitval, integraties",
    "sales": "Prijsstelling, upgrades, nieuwe klanten"
  }
}
```

```json
"department": {
  "type": "choice",
  "choice": "billing",
  "probabilities": { "billing": 0.88, "technical": 0.12, "sales": 0.0 },
  "confidence": 0.81
}
```

### score — een score op een schaal

`criteria` — niveaus van laag naar hoog, maximaal 10 (TypeSafe raadt minimaal twee aan). In het antwoord is `score` — een waarde gewogen naar de waarschijnlijkheden van de niveaus (kan tussen niveaus liggen), `legend` — het nummer en de omschrijving van het niveau, `probabilities` en `confidence`. Volgens TypeSafe is `score` geschikt voor een vergelijking met een drempel, maar niet voor een exact getal tussen de niveaus.

```json
"frustration": {
  "type": "score",
  "instructions": "Hoe gefrustreerd is de klant?",
  "criteria": ["Rustig", "Gefrustreerd", "Erg boos"]
}
```

```json
"frustration": {
  "type": "score",
  "score": 1.05,
  "legend": { "0": "Rustig", "1": "Gefrustreerd", "2": "Erg boos" },
  "probabilities": { "0": 0.0, "1": 0.95, "2": 0.05 },
  "confidence": 0.92
}
```

## [](https://ailoot.ai/docs/nl-be/api/systemone/#response)Antwoord

| Parameter | Type | Verplicht | Beschrijving |
| --- | --- | --- | --- |
| `model` | string |  | Welke modelversie heeft geantwoord. De alias jev-latest verwijst na verloop van tijd naar nieuwe versies: als je drempels voor `confidence` voor een specifieke versie hebt ingesteld, houd dit veld dan in de gaten. |
| `answers` | object |  | Eén antwoord per vraag, onder dezelfde sleutels. Elk antwoord heeft `type`, choice en score hebben ook `confidence`. |
| `usage` | object |  | `input_tokens` en `output_tokens`. Alleen invoertokens worden in rekening gebracht. |

`confidence` kun je goed als drempel gebruiken: handel automatisch bij een zeker antwoord en stuur een onzeker antwoord ter controle naar een mens of een groot model. Het antwoord zegt welke optie je moet kiezen, en `confidence` — geeft aan of het verstandig is om te handelen.

## [](https://ailoot.ai/docs/nl-be/api/systemone/#many-questions)Meerdere vragen in één verzoek

Stel alle vragen over één state in één verzoek: ze worden parallel beoordeeld en state wordt maar één keer doorgegeven. Volgens TypeSafe was in hun voorbeeld met 13 vragen één gezamenlijk verzoek 12,2 keer goedkoper en 10 keer sneller dan 13 afzonderlijke verzoeken die achter elkaar werden verstuurd, met dezelfde antwoorden.

Splits een complex oordeel liever op in eenvoudige vragen en combineer de antwoorden in code: bijvoorbeeld afzonderlijke beoordelingen van de markt, haalbaarheid en verschillen met concurrenten in plaats van ‘beoordeel de aanvraag’. De gewichten kun je dan in code wijzigen, in plaats van in de vraagtekst.

```json
{
  "model": "jev-latest",
  "state": "Help! Mijn uitbetalingen mislukken al 3 dagen.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Welk team moet dit behandelen?",
      "criteria": {
        "billing": "Betalingen, facturatie, terugbetalingen",
        "technical": "Bugs, uitval, integraties",
        "sales": "Prijsstelling, upgrades, nieuwe klanten"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "Hoe gefrustreerd is de klant?",
      "criteria": ["Rustig", "Gefrustreerd", "Erg boos"]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "Drukt dit urgentie uit?"
    }
  }
}
```

## [](https://ailoot.ai/docs/nl-be/api/systemone/#use-cases)Wanneer het geschikt is

- **Routering.** Stuur een klantvraag naar de juiste afdeling en een verzoek naar de juiste verwerker: eenvoudige code, een groot model of een mens.
- **Sorteren en prioriteren.** Urgentie, sentiment en risico: op een schaal, met drempels in code.
- **Moderatie en controles.** Overtreedt een bericht de regels, onderbouwt een bron het citaat of staat het antwoord op de vraag in een document — controleer dit voordat de tekst verdergaat.
- **Scoring en rangschikking.** Beoordeel documenten, kandidaten of gevonden fragmenten volgens je eigen beoordelingsrubriek en beslis in code wat verdergaat.
- **In plaats van een kwetsbare instructie ‘geef JSON terug’.** Een aanroep die door zijn opzet getypeerde waarden teruggeeft, in plaats van tekst die je nog moet parsen.

## [](https://ailoot.ai/docs/nl-be/api/systemone/#not-for)Wanneer het niet geschikt is

- **Chat, antwoorden aan gebruikers en tekst- of codegeneratie.** Jev schrijft geen tekst — daarvoor zijn er [tekstmodellen](https://ailoot.ai/models/nl-be/?kind=text).
- **Als model voor Claude Code, Cursor en andere agents.** Je kunt jev-latest niet als vervanger voor het agentmodel gebruiken: een agent heeft een model nodig dat tekst schrijft en tools aanroept. Je kunt Jev aanroepen vanuit de code die de agent voor je schrijft.
- **Rekenen, tellen en datums vergelijken.** Volgens TypeSafe is het betrouwbaarder om dit in code te doen en alleen het inhoudelijke deel aan het model te vragen — bijvoorbeeld de onderdelen van een datum ophalen via choice.
- **Afbeeldingen, audio en video.** Het model accepteert alleen tekst — zet zulke gegevens vooraf om naar tekst.

Het model werkt het best als elke vraag één concreet, afgebakend oordeel vraagt. Formuleer de voorwaarde expliciet: volgens TypeSafe neemt het model de vraag letterlijk, en een grote state met overbodige gegevens verlaagt de nauwkeurigheid — filter die in code.

## [](https://ailoot.ai/docs/nl-be/api/systemone/#price)Prijs

Alleen invoertokens worden in rekening gebracht — veld `usage.input_tokens` van het antwoord: **$0.084 per 1 miljoen**. Outputtokens zijn gratis.

Het voorbeeldverzoek op deze pagina (296 invoertokens) kost minder dan $0.0001.

Vóór het verzoek reserveert Ailoot een bedrag op het saldo en na het antwoord wordt één keer het daadwerkelijke verbruik afgeschreven — [zo werkt het](https://ailoot.ai/docs/nl-be/billing/reserve/).

## [](https://ailoot.ai/docs/nl-be/api/systemone/#limits)Limieten

| Wat | Limiet |
| --- | --- |
| Het volledige verzoek: state en alle vragen | 64K tokens |
| state met de langste vraag | 32K tokens |
| Opties in één choice | maximaal 255 |
| Niveaus in één score | van 2 tot 10 |
| Invoer | alleen tekst: een string, JSON-object of array van teksten |

De modellimieten zijn gebaseerd op gegevens van TypeSafe. De beperkingen van je sleutel en saldo gelden zoals voor elk Ailoot-model: [Fouten en limieten](https://ailoot.ai/docs/nl-be/errors/).

## [](https://ailoot.ai/docs/nl-be/api/systemone/#errors)Fouten

Fouten komen in het algemene Ailoot API-formaat: een code, duidelijke tekst en de Request ID. Bij deze methode komen vooral de volgende fouten voor:

| Code | Wanneer | Wat je moet doen |
| --- | --- | --- |
| **400** `invalid_request` | De body is niet door de validatie gekomen: state, model of questions ontbreekt, onbekend type, meer dan 255 opties bij choice of meer dan 10 niveaus bij score | Pas het verzoek aan op basis van de foutmelding: zonder wijziging zal het opnieuw mislukken |
| **400** `context_length_exceeded` | state en vragen zijn samen langer dan de modellimiet | Filter state in code en behoud wat de vragen nodig hebben |
| **401** `invalid_api_key` | De sleutel ontbreekt of is ongeldig | Geef de sleutel mee in de Authorization-header |
| **402** `insufficient_balance` | Onvoldoende vrij saldo voor de reservering | Waardeer je saldo op |
| **404** `model_not_found`, `unsupported_endpoint` | Een fout in de ID of het model is via de verkeerde methode aangeroepen, bijvoorbeeld /v1/chat/completions | Roep jev-latest alleen aan via POST /v1/systemone |
| **429** `rate_limit_exceeded` | Te veel verzoeken | Wacht het aantal seconden in de Retry-After-header en probeer opnieuw |
| **503** `model_overloaded`, `model_unavailable` | Het model is tijdelijk overbelast of niet beschikbaar | Als X-Should-Retry: true — probeer opnieuw na het aantal seconden in Retry-After; bij false — controleer eerst de Request ID in de geschiedenis |
| **504** `model_timeout` | Het model heeft niet op tijd geantwoord | Verstuur het verzoek niet opnieuw voordat je de Request ID in de geschiedenis hebt gecontroleerd |

De volledige lijst met codes staat op de pagina [Fouten en limieten](https://ailoot.ai/docs/nl-be/errors/).

Nog vragen? Stuur de Request ID en een beschrijving — we helpen je verder.[Contact opnemen met support](mailto:support@ailoot.ai)

## Ailoot · Het bedrijf en zijn projectenportefeuille





Ailoot bouwt op opgebouwde operationele ervaring, een groot klantenbestand, een stabiele dienst en doorlopende KPI-controle.





Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden.





Ailoot gebruikt die operationele ervaring voor API-toegang tot AI-functies in klantproducten, agents, applicaties en automatiseringen.
