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

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

# Jev — Entscheidungsmodell

[Markdown](https://ailoot.ai/docs/de/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 ist weder Chat noch 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 keinen Text und führt keinen Dialog: Sie übergeben einen **Zustand** (`state`) als Text oder JSON sowie einen Satz von **Fragen**, und erhalten typisierte Werte mit Wahrscheinlichkeiten. Darauf kann der Code direkt Verzweigungen, Sortierung und Routing aufbauen, ohne freien Text zu parsen.

Alle Fragen einer Anfrage werden parallel und unabhängig voneinander anhand desselben `state` bewertet. Laut TypeSafe verändert das Hinzufügen weiterer Fragen die Antwortzeit kaum, und die Fragen beeinflussen einander nicht.

| Merkmal | Kurz erklärt |
| --- | --- |
| Modell | `jev-latest` — Alias der neuesten stabilen Jev-Version; [Modellkarte im Katalog](https://ailoot.ai/models/de/#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 geliefert. |
| Unterstützte Eingaben | Nur Text: eine Zeichenfolge, ein JSON-Objekt oder ein Array von Texten. Wandeln Sie Bilder, Audio und Video zunächst in Text um. |
| Kontext | 64K Tokens pro Anfrage für 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, allerdings mit geringerer Genauigkeit. Prüfen Sie dies an Ihren eigenen Daten. |
| Preis | Eingabe $0.084 pro 1 Million Tokens, Ausgabe kostenlos |

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

### Authentifizierung

| Parameter | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `Authorization` | header | erforderlich | Ailoot-Schlüssel im Format `Bearer sk-…`. |

### Anfrageinhalt

| Parameter | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `model` | string | erforderlich | `jev-latest`. |
| `state` | string \| object \| array | erforderlich | Was bewertet werden soll: eine Zeichenfolge mit Text oder JSON, etwa eine Kundenanfrage, ein Datenbankeintrag, ein Gesprächsverlauf oder der aktuelle Zustand Ihrer Anwendung. Ein Objekt mit verständlichen Feldnamen ist meist praktischer als eine einzelne Zeichenfolge. |
| `questions` | object | erforderlich | Fragen. Die Schlüssel legen Sie fest; die Antworten erscheinen unter denselben Schlüsseln. Der Schlüssel beeinflusst die Antwort nicht; der eigentliche Fragentext 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 mit Daten kann als Objekt übergeben werden: die Frage in einem Feld, die Daten in anderen. Verweisen Sie mit Backticks auf die Feldnamen. |
| `questions.*.criteria` | object \| array |  | Antwortoptionen je nach Typ: Beschreibungen für „Ja“ und „Nein“ bei noul (optional), ein Wörterbuch der Optionen bei choice und eine geordnete Liste der Stufen bei score. |

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

| Typ | Was gefragt wird | Was zurückgegeben wird |
| --- | --- | --- |
| `noul` | Ist die Aussage wahr: 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 Stufenskala liegt | `score`, `legend`, `probabilities`, `confidence` |

Die Typen können in einer Anfrage kombiniert werden.

### noul — Ja oder Nein

Das Feld `criteria` ist optional: Darin 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": "Explizit zeitkritisch",
    "false": "Keine Dringlichkeit ausgedrückt"
  }
}
```

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

### choice — Auswahl einer Option

`criteria` — Wörterbuch „Option → Beschreibung“; wenn keine Beschreibung benötigt wird, geben Sie `null` an. Bis zu 255 Optionen. In der Antwort ist `choice` — die wahrscheinlichste Option, `probabilities` — die Wahrscheinlichkeit jeder Option (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": "Preisgestaltung, Upgrades, neue Kunden"
  }
}
```

```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 ist `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` zum Vergleich mit einem Schwellenwert, nicht 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/api/systemone/#response)Antwort

| Parameter | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `model` | string |  | Welche Modellversion geantwortet hat. Der Alias jev-latest verweist mit der Zeit auf neue Versionen. Wenn Sie Schwellenwerte für `confidence` auf eine bestimmte Version abgestimmt haben, beobachten Sie dieses Feld. |
| `answers` | object |  | Eine Antwort pro Frage unter denselben Schlüsseln. Jede Antwort enthält `type`, bei choice und score außerdem `confidence`. |
| `usage` | object |  | `input_tokens` und `output_tokens`. Es werden nur Eingabetokens berechnet. |

`confidence` eignet sich als Schwellenwert: Bei einer sicheren Antwort handeln Sie automatisch, bei einer unsicheren lassen Sie sie von einem Menschen oder einem großen Modell prüfen. Die Antwort sagt, was ausgewählt werden soll, während `confidence` angibt, ob Sie handeln sollten.

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

Stellen Sie alle Fragen zu einem state in einer Anfrage: Sie werden parallel bewertet, und state wird nur einmal übertragen. Laut TypeSafe war in deren Beispiel mit 13 Fragen eine gemeinsame Anfrage 12,2-mal günstiger und 10-mal schneller als 13 nacheinander gesendete Einzelanfragen, bei denselben Antworten.

Teilen Sie komplexe Bewertungen besser in einfache Fragen auf und führen Sie die Antworten im Code zusammen: Statt „Bewerte den Antrag“ können Sie beispielsweise Markt, Umsetzbarkeit und Unterschiede zur Konkurrenz getrennt bewerten. Die Gewichtungen ändern Sie dann im Code, nicht 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": "Preisgestaltung, Upgrades, neue Kunden"
      }
    },
    "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/api/systemone/#use-cases)Geeignete Einsatzbereiche

- **Routing.** Eine Kundenanfrage an die richtige Abteilung oder eine Anfrage an den passenden Bearbeiter weiterleiten: einfachen Code, ein großes Modell oder einen Menschen.
- **Sortierung und Priorisierung.** Dringlichkeit, Tonalität und Risiko auf einer Skala, mit Schwellenwerten im Code.
- **Moderation und Prüfungen.** Ob eine Nachricht gegen Regeln verstößt, eine Quelle ein Zitat belegt oder ein Dokument die Antwort auf eine Frage enthält, bevor der Text weitergegeben wird.
- **Scoring und Ranking.** Dokumente, Kandidaten oder gefundene Textstellen nach Ihrer eigenen Bewertungsrubrik beurteilen und im Code entscheiden, was weiterverwendet wird.
- **Statt eines fragilen „Gib JSON zurück“.** Ein Aufruf, der von vornherein typisierte Werte zurückgibt, statt Text, der geparst werden muss.

## [](https://ailoot.ai/docs/de/api/systemone/#not-for)Nicht geeignete Einsatzbereiche

- **Chat, Antworten an Nutzer sowie Text- oder Codegenerierung.** Jev schreibt keinen Text; dafür gibt es [Textmodelle](https://ailoot.ai/models/de/?kind=text).
- **Modell für Claude Code, Cursor und andere Agenten.** jev-latest kann nicht als Ersatz für das Modell eines Agenten eingesetzt werden: Der Agent benötigt ein Modell, das Text schreibt und Tools aufruft. Sie können Jev aus dem Code aufrufen, den der Agent für Sie schreibt.
- **Arithmetik, Zählen und Datumsvergleiche.** Laut TypeSafe lässt sich dies zuverlässiger im Code erledigen. Fragen Sie das Modell nur nach dem inhaltlichen Teil, etwa um über choice Bestandteile eines Datums zu extrahieren.
- **Bilder, Audio und Video.** Das Modell akzeptiert nur Text; wandeln Sie solche Daten vorab in Text um.

Das Modell arbeitet am besten, wenn jede Frage genau eine konkrete, eng umrissene Bewertung enthält. Formulieren Sie die Bedingung ausdrücklich: Laut TypeSafe versteht das Modell die Frage wörtlich, und ein großer state mit unnötigen Daten verringert die Genauigkeit. Filtern Sie diese Daten im Code.

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

Es werden nur Eingabetokens berechnet, das Feld `usage.input_tokens` der Antwort: **$0.084 pro 1 Million**. Ausgabetokens sind kostenlos.

Die Beispielanfrage auf dieser Seite (296 Eingabetokens) kostet weniger als $0.0001.

Vor der Anfrage reserviert Ailoot einen Betrag im Guthaben und bucht nach der Antwort einmal nach dem tatsächlichen Verbrauch ab; [so funktioniert es](https://ailoot.ai/docs/de/billing/reserve/).

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

| Merkmal | Limit |
| --- | --- |
| Gesamte Anfrage: state und alle Fragen | 64K Tokens |
| state zusammen mit der längsten Frage | 32K Tokens |
| Optionen in einer choice | bis zu 255 |
| Stufen in einem score | von 2 bis 10 |
| Eingabe | nur Text: Zeichenfolge, JSON-Objekt oder Array von Texten |

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

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

Fehler erscheinen im allgemeinen Ailoot-API-Format: Code, verständlicher Text und Request ID. Bei dieser Methode treten besonders häufig folgende Fehler auf:

| Code | Wann | Was zu tun ist |
| --- | --- | --- |
| **400** `invalid_request` | Der Anfrageinhalt hat die Validierung 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 die Anfrage anhand des Fehlertexts; unverändert wird sie die Prüfung erneut nicht bestehen. |
| **400** `context_length_exceeded` | state und Fragen überschreiten zusammen das Modelllimit. | Filtern Sie state im Code und behalten Sie nur die für die Fragen nötigen Daten. |
| **401** `invalid_api_key` | Der Schlüssel fehlt oder ist ungültig. | Übermitteln Sie den Schlüssel im Header Authorization. |
| **402** `insufficient_balance` | Für die Reservierung ist nicht genügend freies Guthaben vorhanden. | Guthaben aufladen |
| **404** `model_not_found`, `unsupported_endpoint` | Fehlerhafte ID oder Aufruf über die falsche Methode, zum Beispiel über /v1/chat/completions. | Rufen Sie jev-latest ausschließlich über POST /v1/systemone auf. |
| **429** `rate_limit_exceeded` | Zu viele Anfragen | Warten Sie die im Header Retry-After angegebene Anzahl an Sekunden und wiederholen Sie die Anfrage. |
| **503** `model_overloaded`, `model_unavailable` | Das Modell ist vorübergehend überlastet oder nicht verfügbar. | Bei X-Should-Retry: true wiederholen Sie die Anfrage nach den in Retry-After angegebenen Sekunden; bei false prüfen Sie zuerst die Request ID im Verlauf. |
| **504** `model_timeout` | Das Modell hat nicht rechtzeitig geantwortet. | Senden Sie die Anfrage nicht erneut, bevor Sie die Request ID im Verlauf geprüft haben. |

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

Noch Fragen? Senden Sie uns die Request ID und eine Beschreibung, damit wir Ihnen weiterhelfen können.[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.
