Source: https://ailoot.ai/docs/de-at/api/systemone/
Canonical: https://ailoot.ai/docs/de-at/api/systemone/
Language: de-at

[API](https://ailoot.ai/docs/de-at/) 

# Jev — Entscheidungsmodell

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

Das Entscheidungsmodell Jev von TypeSafe beantwortet typisierte Fragen zu Text oder JSON: Auswahl einer Option, Bewertung auf einer Skala oder „Ja/Nein“ mit Wahrscheinlichkeiten. Es dient weder als Chat noch zur Textgenerierung.

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

Jev — Entscheidungsmodell

```bash
curl https://api.ailoot.ai/v1/systemone \
  -H "Authorization: Bearer $AILOOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Hilfe! Meine Auszahlungen schlagen seit 3 Tagen fehl.",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "Drückt dies Dringlichkeit aus?"
      }
    }
  }' 
```

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

body = {
    "model": "jev-latest",
    "state": "Hilfe! Meine Auszahlungen schlagen seit 3 Tagen fehl.",
    "questions": {
        "is_urgent": {"type": "noul", "instructions": "Drückt dies Dringlichkeit aus?"},
    },
}
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: "Hilfe! Meine Auszahlungen schlagen seit 3 Tagen fehl.",
    questions: {
      is_urgent: { type: "noul", instructions: "Drückt dies Dringlichkeit aus?" },
    },
  }),
});
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 ist ein Entscheidungsmodell der Klasse System One von TypeSafe. Es schreibt keine Texte und führt keine Dialoge: Sie übergeben einen **Zustand** (`state`) — Text oder JSON — und eine Reihe von **Fragen**, als Antwort erhalten Sie typisierte Werte mit Wahrscheinlichkeiten. Damit kann Ihr Code sofort verzweigen, sortieren und weiterleiten, ohne freien Text auswerten zu müssen.

Alle Fragen eines Requests werden parallel und unabhängig voneinander für denselben `state` ausgewertet. Laut TypeSafe verändert das Hinzufügen von Fragen die Antwortzeit kaum; die Fragen beeinflussen einander nicht.

| Was | Kurz erklärt |
| --- | --- |
| Modell | `jev-latest` — Alias der aktuellen stabilen Jev-Version; [Modellkarte im Katalog](https://ailoot.ai/models/de-at/#m=jev-latest) |
| Methode | `POST /v1/systemone`. Dies ist kein Chat: Die Formate OpenAI, Anthropic und Gemini eignen sich nicht für Jev. Die Antwort wird vollständig als ein JSON-Objekt übermittelt |
| Akzeptierte Eingabe | Nur Text: ein String, ein JSON-Objekt oder ein Array aus Texten. Wandeln Sie Bilder, Audio und Video zuerst in Text um |
| Kontext | 64K Tokens pro Request — state und alle Fragen zusammen; state mit der längsten Frage — bis zu 32K |
| Sprache | Laut TypeSafe arbeitet das Modell auf Englisch am genauesten; andere Sprachen werden akzeptiert, liefern aber eine geringere Genauigkeit — prüfen Sie dies mit Ihren eigenen Daten |
| Preis | Eingabe $0.084 je 1 Mio. Tokens, Ausgabe kostenlos |

## [](https://ailoot.ai/docs/de-at/api/systemone/#request)Request

### Authentifizierung

| Parameter | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `Authorization` | header | erforderlich | Ailoot-Schlüssel in der Form `Bearer sk-…`. |

### Request-Body

| Parameter | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `model` | string | erforderlich | `jev-latest`. |
| `state` | string \| object \| array | erforderlich | Was bewertet werden soll: ein Textstring oder JSON — eine Kundenanfrage, ein Datenbankeintrag, ein Gesprächsverlauf oder der aktuelle Zustand Ihrer Anwendung. Ein Objekt mit verständlichen Feldnamen ist meist praktischer als ein einzelner String. |
| `questions` | object | erforderlich | Fragen. Die Schlüssel wählen Sie selbst; die Antworten erscheinen unter denselben Schlüsseln. Der Schlüssel beeinflusst die Antwort nicht — die eigentliche Frage steht in `instructions`. |
| `questions.*.type` | string | erforderlich | `noul`, `choice` oder `score` — siehe unten. |
| `questions.*.instructions` | string \| object \| array | erforderlich | Die eigentliche Frage. Eine lange Frage samt Daten können Sie als Objekt übergeben: die Frage in einem Feld, die Daten in anderen. Verweisen Sie auf die Felder über deren Namen in Backticks. |
| `questions.*.criteria` | object \| array |  | Antwortmöglichkeiten je Typ: Beschreibungen für „Ja“ und „Nein“ bei noul (optional), ein Dictionary mit Optionen bei choice, eine geordnete Liste von Stufen bei score. |

## [](https://ailoot.ai/docs/de-at/api/systemone/#question-types)Fragetypen

| Typ | Fragestellung | Rückgabe |
| --- | --- | --- |
| `noul` | Trifft die Aussage zu: ja oder nein | `noul` — Wahrscheinlichkeit für „Ja“ von 0 bis 1 |
| `choice` | Welche der vorgegebenen Optionen passt | `choice`, `probabilities`, `confidence` |
| `score` | Wo state auf Ihrer Skala liegt | `score`, `legend`, `probabilities`, `confidence` |

Die Typen lassen sich innerhalb eines Requests kombinieren.

### noul — ja oder nein

Das Feld `criteria` ist optional: Hier können Sie beschreiben, was „Ja“ (`true`) und „Nein“ (`false`) bedeuten. Die Antwort `noul` — eine Zahl von 0 (nein) bis 1 (ja).

```json
"is_urgent": {
  "type": "noul",
  "instructions": "Drückt dies Dringlichkeit aus?",
  "criteria": {
    "true": "Ausdrücklich zeitkritisch",
    "false": "Keine Dringlichkeit ausgedrückt"
  }
}
```

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

### choice — Auswahl einer Option

`criteria` — ein Dictionary „Option → Beschreibung“; ist keine Beschreibung nötig, geben Sie `null` an. Bis zu 255 Optionen. In der Antwort: `choice` — die wahrscheinlichste Option, `probabilities` — die Wahrscheinlichkeit jeder Option (in Summe 1), `confidence` — die Konfidenz von 0 bis 1.

```json
"department": {
  "type": "choice",
  "instructions": "Welches Team sollte sich darum kümmern?",
  "criteria": {
    "billing": "Zahlungen, Rechnungsstellung, Rückerstattungen",
    "technical": "Fehler, Ausfälle, Integrationen",
    "sales": "Preise, Upgrades, Neukunden"
  }
}
```

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

### score — Bewertung auf einer Skala

`criteria` — Stufen von der niedrigsten zur höchsten, höchstens 10 (TypeSafe empfiehlt mindestens zwei). In der Antwort: `score` — der nach den Wahrscheinlichkeiten der Stufen gewichtete Wert (kann zwischen den Stufen liegen), `legend` — die Nummer der Stufe und ihre Beschreibung, `probabilities` und `confidence`. Laut TypeSafe eignet sich `score` für den Vergleich mit einem Schwellenwert, nicht aber als exakte Zahl zwischen den Stufen.

```json
"frustration": {
  "type": "score",
  "instructions": "Wie frustriert ist der Kunde?",
  "criteria": ["Ruhig", "Frustriert", "Sehr wütend"]
}
```

```json
"frustration": {
  "type": "score",
  "score": 1.05,
  "legend": { "0": "Ruhig", "1": "Frustriert", "2": "Sehr wütend" },
  "probabilities": { "0": 0.0, "1": 0.95, "2": 0.05 },
  "confidence": 0.92
}
```

## [](https://ailoot.ai/docs/de-at/api/systemone/#response)Antwort

| Parameter | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `model` | string |  | Die Modellversion, die geantwortet hat. Der Alias jev-latest verweist mit der Zeit auf neuere Versionen: Wenn Sie die Schwellenwerte für `confidence` auf eine bestimmte Version abgestimmt haben, behalten Sie dieses Feld im Blick. |
| `answers` | object |  | Eine Antwort je Frage unter denselben Schlüsseln. Jede Antwort enthält `type`, bei choice und score zusätzlich `confidence`. |
| `usage` | object |  | `input_tokens` und `output_tokens`. Verrechnet werden nur Eingabetokens. |

`confidence` lässt sich gut als Schwellenwert verwenden: Bei einer sicheren Antwort handeln Sie automatisch, bei einer unsicheren lassen Sie einen Menschen oder ein großes Modell prüfen. Die Antwort sagt, was gewählt werden soll, und `confidence` — ob Sie handeln sollten.

## [](https://ailoot.ai/docs/de-at/api/systemone/#many-questions)Mehrere Fragen in einem Request

Stellen Sie alle Fragen zu einem state in einem Request: Sie werden parallel ausgewertet, und state wird nur einmal übertragen. Laut TypeSafe war in deren Beispiel mit 13 Fragen ein gemeinsamer Request bei denselben Antworten 12,2-mal günstiger und 10-mal schneller als 13 einzelne, nacheinander gesendete Requests.

Teilen Sie komplexe Beurteilungen besser in einfache Fragen auf und führen Sie die Antworten im Code zusammen: Statt „Bewerte den Antrag“ etwa getrennte Bewertungen von Markt, Umsetzbarkeit und Unterschieden zur Konkurrenz. Die Gewichtung ändern Sie dann im Code statt im Fragetext.

```json
{
  "model": "jev-latest",
  "state": "Hilfe! Meine Auszahlungen schlagen seit 3 Tagen fehl.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Welches Team sollte sich darum kümmern?",
      "criteria": {
        "billing": "Zahlungen, Rechnungsstellung, Rückerstattungen",
        "technical": "Fehler, Ausfälle, Integrationen",
        "sales": "Preise, Upgrades, Neukunden"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "Wie frustriert ist der Kunde?",
      "criteria": ["Ruhig", "Frustriert", "Sehr wütend"]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "Drückt dies Dringlichkeit aus?"
    }
  }
}
```

## [](https://ailoot.ai/docs/de-at/api/systemone/#use-cases)Geeignete Anwendungsfälle

- **Routing.** Eine Anfrage an die passende Abteilung weiterleiten und einen Request an die passende Verarbeitung: einfachen Code, ein großes Modell oder einen Menschen.
- **Sortierung und Priorisierung.** Dringlichkeit, Tonalität, Risiko — auf einer Skala, mit Schwellenwerten im Code.
- **Moderation und Prüfungen.** Verstößt eine Nachricht gegen Regeln, belegt eine Quelle ein Zitat, beantwortet ein Dokument eine Frage — bevor der Text weiterverarbeitet wird.
- **Scoring und Ranking.** Dokumente, Bewerber oder gefundene Textstellen nach Ihrem eigenen Bewertungsraster beurteilen und im Code entscheiden, was weiterverarbeitet wird.
- **Anstelle des fehleranfälligen „Gib JSON zurück“.** Ein Aufruf, der konstruktionsbedingt typisierte Werte zurückgibt, statt Text, den Sie erst auswerten müssen.

## [](https://ailoot.ai/docs/de-at/api/systemone/#not-for)Ungeeignete Anwendungsfälle

- **Chat, Antworten an Nutzer, Text- oder Codegenerierung.** Jev schreibt keine Texte — dafür gibt es [Textmodelle](https://ailoot.ai/models/de-at/?kind=text).
- **Als Modell für Claude Code, Cursor und andere Agenten.** jev-latest kann das Modell eines Agenten nicht ersetzen: Ein Agent benötigt ein Modell, das Text schreibt und Werkzeuge aufruft. Jev lässt sich aus Code aufrufen, den der Agent für Sie schreibt.
- **Arithmetik, Zählen, Datumsvergleiche.** Laut TypeSafe erledigen Sie dies zuverlässiger im Code und fragen das Modell nur nach der Bedeutung — etwa indem Sie Datumsbestandteile über choice extrahieren.
- **Bilder, Audio und Video.** Das Modell akzeptiert nur Text — wandeln Sie solche Daten vorher in Text um.

Das Modell funktioniert am besten, wenn jede Frage genau eine konkrete, eng umrissene Beurteilung verlangt. Formulieren Sie die Bedingung direkt: Laut TypeSafe versteht das Modell Fragen wörtlich; ein großer state mit überflüssigen Daten senkt die Genauigkeit — filtern Sie ihn im Code.

## [](https://ailoot.ai/docs/de-at/api/systemone/#price)Preis

Verrechnet werden nur Eingabetokens — Feld `usage.input_tokens` in der Antwort: **$0.084 je 1 Million**. Ausgabetokens sind kostenlos.

Der Beispielrequest auf dieser Seite (296 Eingabetokens) kostet weniger als $0.0001.

Vor dem Request reserviert Ailoot den Betrag auf Ihrem Guthaben und bucht nach der Antwort einmal nach dem tatsächlichen Verbrauch ab — [so funktioniert es](https://ailoot.ai/docs/de-at/billing/reserve/).

## [](https://ailoot.ai/docs/de-at/api/systemone/#limits)Limits

| Was | Limit |
| --- | --- |
| Gesamter Request: state und alle Fragen | 64K Tokens |
| state mit der längsten Frage | 32K Tokens |
| Optionen in einem choice | bis zu 255 |
| Stufen in einem score | von 2 bis 10 |
| Eingabe | nur Text: ein String, ein JSON-Objekt oder ein Array aus Texten |

Die Modelllimits stammen von TypeSafe. Einschränkungen Ihres Schlüssels und Guthabens gelten wie bei jedem Ailoot-Modell: [Fehler und Limits](https://ailoot.ai/docs/de-at/errors/).

## [](https://ailoot.ai/docs/de-at/api/systemone/#errors)Fehler

Fehler werden im einheitlichen Format der Ailoot API zurückgegeben: Code, verständlicher Text und Request ID. Bei dieser Methode treten am häufigsten folgende Fehler auf:

| Code | Wann | Was tun |
| --- | --- | --- |
| **400** `invalid_request` | Der Request-Body hat die Prüfung nicht bestanden: state, model oder questions fehlen, type ist unbekannt, choice enthält mehr als 255 Optionen oder score mehr als 10 Stufen | Korrigieren Sie den Request anhand des Fehlertexts: Ohne Änderung wird er erneut abgelehnt |
| **400** `context_length_exceeded` | state und Fragen überschreiten gemeinsam das Modelllimit | Filtern Sie state im Code und behalten Sie nur die für die Fragen erforderlichen Daten |
| **401** `invalid_api_key` | Der Schlüssel fehlt oder ist ungültig | Übermitteln Sie den Schlüssel im Header Authorization |
| **402** `insufficient_balance` | Das frei verfügbare Guthaben reicht für die Reservierung nicht aus | Laden Sie Ihr Guthaben auf |
| **404** `model_not_found`, `unsupported_endpoint` | Die ID ist fehlerhaft oder das Modell wurde über die falsche Methode aufgerufen, etwa über /v1/chat/completions | Rufen Sie jev-latest ausschließlich über POST /v1/systemone auf |
| **429** `rate_limit_exceeded` | Zu viele Requests | Warten Sie die im Header Retry-After angegebene Anzahl an Sekunden und versuchen Sie es erneut |
| **503** `model_overloaded`, `model_unavailable` | Das Modell ist vorübergehend überlastet oder nicht verfügbar | Bei X-Should-Retry: true wiederholen Sie den Request nach Retry-After Sekunden; bei false prüfen Sie zuerst die Request ID im Verlauf |
| **504** `model_timeout` | Das Modell hat nicht rechtzeitig geantwortet | Senden Sie den Request erst erneut, nachdem Sie die Request ID im Verlauf geprüft haben |

Die vollständige Liste der Codes finden Sie auf der Seite [Fehler und Limits](https://ailoot.ai/docs/de-at/errors/).

Noch Fragen? Senden Sie uns die Request ID und eine Beschreibung — wir helfen Ihnen weiter.[Support kontaktieren](mailto:support@ailoot.ai)

## Ailoot · Das Unternehmen und sein Projektportfolio





Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle.





Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.





Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.
