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

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

# Jev — beslutningsmodell

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

Beslutningsmodellen Jev fra TypeSafe svarer på typede spørsmål om tekst eller JSON: alternativvalg, vurdering på en skala eller «ja/nei» med sannsynligheter. Dette er verken chat eller tekstgenerering.

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

Jev — beslutningsmodell

```bash
curl https://api.ailoot.ai/v1/systemone \
  -H "Authorization: Bearer $AILOOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Hjelp! Utbetalingene mine har feilet de siste 3 dagene.",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "Uttrykker dette at det haster?"
      }
    }
  }' 
```

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

body = {
    "model": "jev-latest",
    "state": "Hjelp! Utbetalingene mine har feilet de siste 3 dagene.",
    "questions": {
        "is_urgent": {"type": "noul", "instructions": "Uttrykker dette at det haster?"},
    },
}
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: "Hjelp! Utbetalingene mine har feilet de siste 3 dagene.",
    questions: {
      is_urgent: { type: "noul", instructions: "Uttrykker dette at det haster?" },
    },
  }),
});
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 er en beslutningsmodell i klassen System One fra TypeSafe. Den skriver ikke tekst og fører ikke en samtale: du sender inn **tilstanden** (`state`) — tekst eller JSON — og et sett med **spørsmål**, og får typede verdier med sannsynligheter tilbake. Koden kan bruke dem direkte til forgrening, sortering og ruting, uten å tolke fritekst.

Alle spørsmålene i én forespørsel vurderes parallelt og uavhengig av hverandre, mot samme `state`. Ifølge TypeSafe endrer ekstra spørsmål nesten ikke svartiden, og spørsmålene påvirker ikke hverandre.

| Hva | Kort fortalt |
| --- | --- |
| Modell | `jev-latest` — et alias for den nyeste stabile Jev-versjonen; [oppføring i katalogen](https://ailoot.ai/models/nb/#m=jev-latest) |
| Metode | `POST /v1/systemone`. Dette er ikke chat: OpenAI-, Anthropic- og Gemini-formatene passer ikke for Jev. Svaret leveres i sin helhet som ett JSON-objekt |
| Støttede inndata | Bare tekst: en streng, et JSON-objekt eller en liste med tekster. Konverter bilder, lyd og video til tekst først |
| Kontekst | 64K tokener per forespørsel — state og alle spørsmålene samlet; state og det lengste spørsmålet samlet — opptil 32K |
| Språk | Ifølge TypeSafe er modellen mest nøyaktig på engelsk; andre språk godtas, men nøyaktigheten er lavere — test med dine egne data |
| Pris | Inndata $0.084 per 1 million tokener, utdata gratis |

## [](https://ailoot.ai/docs/nb/api/systemone/#request)Forespørsel

### Autentisering

| Parameter | Type | Påkrevd | Beskrivelse |
| --- | --- | --- | --- |
| `Authorization` | header | påkrevd | Ailoot-nøkkel i formatet `Bearer sk-…`. |

### Forespørselskropp

| Parameter | Type | Påkrevd | Beskrivelse |
| --- | --- | --- | --- |
| `model` | string | påkrevd | `jev-latest`. |
| `state` | string \| object \| array | påkrevd | Hva som skal vurderes: en tekststreng eller JSON — en kundehenvendelse, en databasepost, en samtale eller applikasjonens nåværende tilstand. Et objekt med forståelige feltnavn er vanligvis mer praktisk enn én streng. |
| `questions` | object | påkrevd | Spørsmål. Du velger nøklene selv, og svarene kommer under de samme nøklene; nøkkelen påvirker ikke svaret — selve spørsmålet angis i `instructions`. |
| `questions.*.type` | string | påkrevd | `noul`, `choice` eller `score` — se nedenfor. |
| `questions.*.instructions` | string \| object \| array | påkrevd | Selve spørsmålet. Et langt spørsmål med data kan sendes som et objekt: spørsmålet i ett felt og dataene i andre; referer til feltene med navnet i gravaksenter. |
| `questions.*.criteria` | object \| array |  | Svaralternativer, ulike for hver type: beskrivelser av «ja» og «nei» for noul (valgfritt), en ordbok med alternativer for choice og en ordnet liste med nivåer for score. |

## [](https://ailoot.ai/docs/nb/api/systemone/#question-types)Spørsmålstyper

| Type | Hva det spørres om | Hva som returneres |
| --- | --- | --- |
| `noul` | Om påstanden er sann: ja eller nei | `noul` — sannsynligheten for «ja» fra 0 til 1 |
| `choice` | Hvilket av de angitte alternativene som passer | `choice`, `probabilities`, `confidence` |
| `score` | Hvor state ligger på nivåskalaen din | `score`, `legend`, `probabilities`, `confidence` |

Typene kan kombineres i én forespørsel.

### noul — ja eller nei

Feltet `criteria` er valgfritt: her kan du beskrive hva «ja» (`true`) og «nei» (`false`) betyr. Svaret `noul` — et tall fra 0 (nei) til 1 (ja).

```json
"is_urgent": {
  "type": "noul",
  "instructions": "Uttrykker dette at det haster?",
  "criteria": {
    "true": "Uttrykkelig tidskritisk",
    "false": "Ingen hast uttrykt"
  }
}
```

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

### choice — velg et alternativ

`criteria` — en ordbok av typen «alternativ → beskrivelse»; hvis ingen beskrivelse er nødvendig, angir du `null`. Opptil 255 alternativer. I svaret er `choice` — det mest sannsynlige alternativet, `probabilities` — sannsynligheten for hvert alternativ (summen er 1), `confidence` — sikkerhet fra 0 til 1.

```json
"department": {
  "type": "choice",
  "instructions": "Hvilket team bør håndtere dette?",
  "criteria": {
    "billing": "Betalinger, fakturering, refusjoner",
    "technical": "Feil, driftsavbrudd, integrasjoner",
    "sales": "Priser, oppgraderinger, nye kunder"
  }
}
```

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

### score — vurdering på en skala

`criteria` — nivåer fra lavest til høyest, maksimalt 10 (TypeSafe anbefaler minst to). I svaret er `score` — en verdi vektet etter nivåenes sannsynligheter (kan ligge mellom nivåene), `legend` — nivånummeret og beskrivelsen av nivået, `probabilities` og `confidence`. Ifølge TypeSafe er `score` egnet til å sammenligne med en terskel, men ikke til å angi et nøyaktig tall mellom nivåene.

```json
"frustration": {
  "type": "score",
  "instructions": "Hvor frustrert er kunden?",
  "criteria": ["Rolig", "Frustrert", "Veldig sint"]
}
```

```json
"frustration": {
  "type": "score",
  "score": 1.05,
  "legend": { "0": "Rolig", "1": "Frustrert", "2": "Veldig sint" },
  "probabilities": { "0": 0.0, "1": 0.95, "2": 0.05 },
  "confidence": 0.92
}
```

## [](https://ailoot.ai/docs/nb/api/systemone/#response)Svar

| Parameter | Type | Påkrevd | Beskrivelse |
| --- | --- | --- | --- |
| `model` | string |  | Hvilken modellversjon som svarte. Aliaset jev-latest peker over tid til nyere versjoner: hvis du har tilpasset tersklene `confidence` til en bestemt versjon, bør du følge med på dette feltet. |
| `answers` | object |  | Ett svar per spørsmål, under de samme nøklene. Hvert svar har `type`, choice og score har i tillegg `confidence`. |
| `usage` | object |  | `input_tokens` og `output_tokens`. Bare inndatatokener belastes. |

`confidence` egner seg som terskel: er svaret sikkert, kan du handle automatisk; er det usikkert, sender du det til kontroll hos et menneske eller en stor modell. Svaret sier hva du skal velge, mens `confidence` — sier om du bør handle.

## [](https://ailoot.ai/docs/nb/api/systemone/#many-questions)Flere spørsmål i én forespørsel

Still alle spørsmål om samme state i én forespørsel: de vurderes parallelt, og state sendes bare én gang. Ifølge TypeSafe var én samlet forespørsel i deres eksempel med 13 spørsmål 12,2 ganger billigere og 10 ganger raskere enn 13 separate forespørsler sendt etter hverandre, med de samme svarene.

Del gjerne en kompleks vurdering opp i enkle spørsmål og kombiner svarene i koden: for eksempel separate vurderinger av marked, gjennomførbarhet og forskjeller fra konkurrenter i stedet for «vurder søknaden». Da endrer du vektene i koden, ikke i spørsmålsteksten.

```json
{
  "model": "jev-latest",
  "state": "Hjelp! Utbetalingene mine har feilet de siste 3 dagene.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Hvilket team bør håndtere dette?",
      "criteria": {
        "billing": "Betalinger, fakturering, refusjoner",
        "technical": "Feil, driftsavbrudd, integrasjoner",
        "sales": "Priser, oppgraderinger, nye kunder"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "Hvor frustrert er kunden?",
      "criteria": ["Rolig", "Frustrert", "Veldig sint"]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "Uttrykker dette at det haster?"
    }
  }
}
```

## [](https://ailoot.ai/docs/nb/api/systemone/#use-cases)Når den passer

- **Ruting.** Send en henvendelse til riktig avdeling og en forespørsel til riktig behandler: enkel kode, en stor modell eller et menneske.
- **Sortering og prioritering.** Hastegrad, tone og risiko — på en skala, med terskler i koden.
- **Moderering og kontroll.** Om en melding bryter reglene, om en kilde bekrefter et sitat, eller om et dokument inneholder svaret på et spørsmål — før teksten sendes videre.
- **Vurdering og rangering.** Vurder dokumenter, kandidater eller søkeresultater etter dine egne kriterier og avgjør i koden hva som går videre.
- **I stedet for et skjørt «returner JSON».** Et kall som returnerer typede verdier som en del av utformingen, i stedet for tekst som må tolkes.

## [](https://ailoot.ai/docs/nb/api/systemone/#not-for)Når den ikke passer

- **Chat, svar til brukeren eller generering av tekst og kode.** Jev skriver ikke tekst — til det finnes [tekstmodeller](https://ailoot.ai/models/nb/?kind=text).
- **Som modell for Claude Code, Cursor og andre agenter.** Du kan ikke erstatte agentens modell med jev-latest: agenten trenger en modell som skriver tekst og kaller verktøy. Jev kan kalles fra koden agenten skriver for deg.
- **Aritmetikk, telling og datosammenligning.** Ifølge TypeSafe er dette mer pålitelig i kode; spør modellen bare om meningsinnholdet — for eksempel å hente ut deler av en dato med choice.
- **Bilder, lyd og video.** Modellen godtar bare tekst — konverter slike data til tekst på forhånd.

Modellen fungerer best når hvert spørsmål ber om én konkret, avgrenset vurdering. Skriv betingelsen direkte: ifølge TypeSafe tolker modellen spørsmålet bokstavelig, og en stor state med overflødige data reduserer nøyaktigheten — filtrer dataene i koden.

## [](https://ailoot.ai/docs/nb/api/systemone/#price)Pris

Bare inndatatokener belastes — feltet `usage.input_tokens` i svaret: **$0.084 per 1 million**. Utdatatokener er gratis.

Eksempelforespørselen på denne siden (296 inndatatokener) koster mindre enn $0.0001.

Før forespørselen reserverer Ailoot et beløp på saldoen, og etter svaret belastes det én gang etter faktisk forbruk — [slik fungerer det](https://ailoot.ai/docs/nb/billing/reserve/).

## [](https://ailoot.ai/docs/nb/api/systemone/#limits)Grenser

| Hva | Grense |
| --- | --- |
| Hele forespørselen: state og alle spørsmålene | 64K tokener |
| state sammen med det lengste spørsmålet | 32K tokener |
| Alternativer i ett choice | opptil 255 |
| Nivåer i ett score | fra 2 til 10 |
| Inndata | bare tekst: en streng, et JSON-objekt eller en liste med tekster |

Modellgrensene er oppgitt av TypeSafe. Nøkkel- og saldobegrensningene gjelder som for alle andre Ailoot-modeller: [Feil og grenser](https://ailoot.ai/docs/nb/errors/).

## [](https://ailoot.ai/docs/nb/api/systemone/#errors)Feil

Feil returneres i Ailoot APIs felles format: kode, forståelig tekst og Request ID. De vanligste feilene for denne metoden er:

| Kode | Når | Hva du bør gjøre |
| --- | --- | --- |
| **400** `invalid_request` | Forespørselskroppen besto ikke valideringen: state, model eller questions mangler, ukjent type, mer enn 255 alternativer i choice eller mer enn 10 nivåer i score | Rett forespørselen etter feilmeldingen: uten endringer vil den bli avvist igjen |
| **400** `context_length_exceeded` | state og spørsmålene samlet overskrider modellgrensen | Filtrer state i koden og behold det spørsmålene trenger |
| **401** `invalid_api_key` | Nøkkelen mangler eller er ugyldig | Send nøkkelen i Authorization-headeren |
| **402** `insufficient_balance` | Ikke nok tilgjengelig saldo til reservasjonen | Legg til midler |
| **404** `model_not_found`, `unsupported_endpoint` | Feil ID eller modellen er kalt med feil metode, for eksempel via /v1/chat/completions | Kall jev-latest bare via POST /v1/systemone |
| **429** `rate_limit_exceeded` | For mange forespørsler | Vent antallet sekunder som er angitt i Retry-After-headeren, og prøv igjen |
| **503** `model_overloaded`, `model_unavailable` | Modellen er midlertidig overbelastet eller utilgjengelig | Hvis X-Should-Retry: true — prøv igjen etter Retry-After sekunder; hvis false — kontroller først Request ID i historikken |
| **504** `model_timeout` | Modellen svarte ikke innen tidsgrensen | Ikke send forespørselen på nytt før du har kontrollert Request ID i historikken |

Den fullstendige listen over koder finnes på siden [Feil og grenser](https://ailoot.ai/docs/nb/errors/).

Flere spørsmål? Send Request ID og en beskrivelse, så hjelper vi deg.[Kontakt brukerstøtte](mailto:support@ailoot.ai)

## Ailoot · Selskapet og dets prosjektportefølje





Ailoot bygger på etablert driftserfaring, en stor kundebase, stabil tjeneste og løpende KPI-kontroll.





Selskapet og dets prosjektportefølje: millioner av kunder; månedlig salg for milliarder.





Ailoot bruker denne driftserfaringen til API-tilgang til AI-funksjoner i kundenes produkter, agenter, applikasjoner og automatiseringer.