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

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

# Jev — beslutsmodell

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

Beslutsmodellen Jev från TypeSafe besvarar typade frågor om text eller JSON: val av alternativ, bedömning på en skala eller ”ja/nej” med sannolikheter. Det är varken chatt eller textgenerering.

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

Jev — beslutsmodell

```bash
curl https://api.ailoot.ai/v1/systemone \
  -H "Authorization: Bearer $AILOOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Hjälp! Mina utbetalningar har misslyckats i 3 dagar.",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "Uttrycker detta brådska?"
      }
    }
  }' 
```

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

body = {
    "model": "jev-latest",
    "state": "Hjälp! Mina utbetalningar har misslyckats i 3 dagar.",
    "questions": {
        "is_urgent": {"type": "noul", "instructions": "Uttrycker detta brådska?"},
    },
}
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: "Hjälp! Mina utbetalningar har misslyckats i 3 dagar.",
    questions: {
      is_urgent: { type: "noul", instructions: "Uttrycker detta brådska?" },
    },
  }),
});
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 är en beslutsmodell i klassen System One från TypeSafe. Den skriver inte text och för inte någon dialog: du skickar **ett tillstånd** (`state`) — text eller JSON — och en uppsättning **frågor**, och får typade värden med sannolikheter tillbaka. Koden kan direkt använda dem för förgrening, sortering och routning utan att tolka fri text.

Alla frågor i ett anrop bedöms parallellt och oberoende av varandra utifrån samma `state`. Enligt TypeSafe påverkar fler frågor knappt svarstiden, och frågorna stör inte varandra.

| Vad | Kortfattat |
| --- | --- |
| Modell | `jev-latest` — ett alias för den senaste stabila versionen av Jev; [posten i katalogen](https://ailoot.ai/models/sv/#m=jev-latest) |
| Metod | `POST /v1/systemone`. Detta är inte chatt: formaten OpenAI, Anthropic och Gemini passar inte för Jev. Svaret levereras i sin helhet som ett JSON-objekt |
| Indata som stöds | Endast text: en sträng, ett JSON-objekt eller en array med texter. Omvandla först bilder, ljud och video till text |
| Kontext | 64K token per anrop — state och alla frågor tillsammans; state tillsammans med den längsta frågan — högst 32K |
| Språk | Enligt TypeSafe är modellen mest träffsäker på engelska; den godtar andra språk, men träffsäkerheten är lägre — testa med dina egna data |
| Pris | Indata $0.084 per 1 miljon token, utdata utan kostnad |

## [](https://ailoot.ai/docs/sv/api/systemone/#request)Anrop

### Autentisering

| Parameter | Typ | Obligatorisk | Beskrivning |
| --- | --- | --- | --- |
| `Authorization` | header | obligatoriskt | Ailoot-nyckel i formatet `Bearer sk-…`. |

### Anropskropp

| Parameter | Typ | Obligatorisk | Beskrivning |
| --- | --- | --- | --- |
| `model` | string | obligatoriskt | `jev-latest`. |
| `state` | string \| object \| array | obligatoriskt | Det som ska bedömas: en textsträng eller JSON — ett kundärende, en databaspost, en konversation eller appens aktuella tillstånd. Ett objekt med tydliga fältnamn är vanligen enklare att använda än en enda sträng. |
| `questions` | object | obligatoriskt | Frågor. Du väljer nycklarna, och svaren returneras med samma nycklar; nyckeln påverkar inte svaret — själva frågan anges i `instructions`. |
| `questions.*.type` | string | obligatoriskt | `noul`, `choice` eller `score` — se nedan. |
| `questions.*.instructions` | string \| object \| array | obligatoriskt | Själva frågan. En lång fråga med data kan skickas som ett objekt: frågan i ett fält och data i andra; hänvisa till fälten med deras namn inom bakåtriktade apostrofer. |
| `questions.*.criteria` | object \| array |  | Svarsalternativ som skiljer sig mellan typerna: beskrivningar av ”ja” och ”nej” för noul (valfritt), en uppsättning namngivna alternativ för choice och en ordnad lista av nivåer för score. |

## [](https://ailoot.ai/docs/sv/api/systemone/#question-types)Frågetyper

| Typ | Vad frågan gäller | Vad som returneras |
| --- | --- | --- |
| `noul` | Om påståendet är sant: ja eller nej | `noul` — sannolikheten för ”ja” från 0 till 1 |
| `choice` | Vilket av de angivna alternativen som passar | `choice`, `probabilities`, `confidence` |
| `score` | Var state ligger på din nivåskala | `score`, `legend`, `probabilities`, `confidence` |

Typerna kan kombineras i samma anrop.

### noul — ja eller nej

Fältet `criteria` är valfritt: här kan du beskriva vad ”ja” (`true`) och ”nej” (`false`) betyder. Svaret `noul` — ett tal från 0 (nej) till 1 (ja).

```json
"is_urgent": {
  "type": "noul",
  "instructions": "Uttrycker detta brådska?",
  "criteria": {
    "true": "Uttryckligen tidskänsligt",
    "false": "Ingen brådska uttrycks"
  }
}
```

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

### choice — val av alternativ

`criteria` — en uppsättning ”alternativ → beskrivning”; om beskrivningen inte behövs anger du `null`. Högst 255 alternativ. I svaret är `choice` — det mest sannolika alternativet, `probabilities` — sannolikheten för varje alternativ (summan är 1), `confidence` — säkerhet från 0 till 1.

```json
"department": {
  "type": "choice",
  "instructions": "Vilket team bör hantera detta?",
  "criteria": {
    "billing": "Betalningar, fakturering, återbetalningar",
    "technical": "Buggar, avbrott, integrationer",
    "sales": "Prissättning, uppgraderingar, nya kunder"
  }
}
```

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

### score — bedömning på en skala

`criteria` — nivåer från lägst till högst, högst 10 (TypeSafe rekommenderar minst två). Svaret innehåller `score` — ett värde viktat efter nivåernas sannolikheter (kan hamna mellan nivåerna), `legend` — nivåns nummer och beskrivning, `probabilities` och `confidence`. Enligt TypeSafe är `score` lämpligt för jämförelser med ett tröskelvärde, men inte för att ange ett exakt tal mellan nivåerna.

```json
"frustration": {
  "type": "score",
  "instructions": "Hur frustrerad är kunden?",
  "criteria": ["Lugn", "Frustrerad", "Mycket arg"]
}
```

```json
"frustration": {
  "type": "score",
  "score": 1.05,
  "legend": { "0": "Lugn", "1": "Frustrerad", "2": "Mycket arg" },
  "probabilities": { "0": 0.0, "1": 0.95, "2": 0.05 },
  "confidence": 0.92
}
```

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

| Parameter | Typ | Obligatorisk | Beskrivning |
| --- | --- | --- | --- |
| `model` | string |  | Vilken modellversion som svarade. Aliaset jev-latest pekar med tiden på nya versioner: om du har anpassat tröskelvärdena `confidence` till en viss version bör du hålla koll på detta fält. |
| `answers` | object |  | Ett svar per fråga, med samma nycklar. Varje svar har `type`, choice och score har dessutom `confidence`. |
| `usage` | object |  | `input_tokens` och `output_tokens`. Endast indatatoken debiteras. |

`confidence` kan användas som tröskelvärde: vid ett säkert svar agerar du automatiskt, vid ett osäkert skickar du det till en människa eller en stor modell för granskning. Svaret anger vad du ska välja, medan `confidence` — anger om du bör agera.

## [](https://ailoot.ai/docs/sv/api/systemone/#many-questions)Flera frågor i ett anrop

Ställ alla frågor om samma state i ett anrop: de bedöms parallellt, och state skickas bara en gång. Enligt TypeSafe var ett gemensamt anrop i deras exempel med 13 frågor 12,2 gånger billigare och 10 gånger snabbare än 13 separata anrop som skickades efter varandra, med samma svar.

Dela gärna upp en komplex bedömning i enkla frågor och kombinera svaren i koden: till exempel separata bedömningar av marknad, genomförbarhet och skillnader mot konkurrenter i stället för ”bedöm ansökan”. Då ändras vikterna i koden, inte i frågetexten.

```json
{
  "model": "jev-latest",
  "state": "Hjälp! Mina utbetalningar har misslyckats i 3 dagar.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Vilket team bör hantera detta?",
      "criteria": {
        "billing": "Betalningar, fakturering, återbetalningar",
        "technical": "Buggar, avbrott, integrationer",
        "sales": "Prissättning, uppgraderingar, nya kunder"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "Hur frustrerad är kunden?",
      "criteria": ["Lugn", "Frustrerad", "Mycket arg"]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "Uttrycker detta brådska?"
    }
  }
}
```

## [](https://ailoot.ai/docs/sv/api/systemone/#use-cases)När den passar

- **Routning.** Skicka ett ärende till rätt avdelning och ett anrop till rätt hanterare: enkel kod, en stor modell eller en människa.
- **Sortering och prioritering.** Brådskandegrad, ton och risk — på en skala, med tröskelvärden i koden.
- **Moderering och kontroller.** Om ett meddelande bryter mot reglerna, om en källa styrker ett citat eller om ett dokument innehåller svaret på en fråga — innan texten skickas vidare.
- **Poängsättning och rangordning.** Bedöm dokument, kandidater eller sökträffar efter dina egna kriterier och avgör i koden vad som går vidare.
- **I stället för ett skört ”returnera JSON”.** Ett anrop som är utformat för att returnera typade värden, inte text som måste tolkas.

## [](https://ailoot.ai/docs/sv/api/systemone/#not-for)När den inte passar

- **Chatt, användarsvar och generering av text eller kod.** Jev skriver inte text — för det finns [textmodeller](https://ailoot.ai/models/sv/?kind=text).
- **Som modell för Claude Code, Cursor och andra agenter.** Det går inte att ersätta agentens modell med jev-latest: agenten behöver en modell som skriver text och anropar verktyg. Jev kan anropas från koden som agenten skriver åt dig.
- **Aritmetik, räkning och jämförelse av datum.** Enligt TypeSafe är detta mer tillförlitligt i kod; fråga modellen endast om den innehållsmässiga delen — exempelvis att extrahera datumdelar med choice.
- **Bilder, ljud och video.** Modellen godtar endast text — omvandla sådana data till text i förväg.

Modellen fungerar bäst när varje fråga gäller en konkret, avgränsad bedömning. Skriv villkoret tydligt: enligt TypeSafe tolkar modellen frågan bokstavligt, och ett stort state med överflödiga data minskar träffsäkerheten — filtrera datan i koden.

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

Endast indatatoken debiteras — fältet `usage.input_tokens` i svaret: **$0.084 per 1 miljon**. Utdatatoken är kostnadsfria.

Exempelanropet på den här sidan (296 indatatoken) kostar mindre än $0.0001.

Före anropet reserverar Ailoot ett belopp på saldot och debiterar sedan en gång efter svaret utifrån faktisk förbrukning — [så fungerar det](https://ailoot.ai/docs/sv/billing/reserve/).

## [](https://ailoot.ai/docs/sv/api/systemone/#limits)Gränser

| Vad | Gräns |
| --- | --- |
| Hela anropet: state och alla frågor | 64K token |
| state tillsammans med den längsta frågan | 32K token |
| Alternativ i ett choice | högst 255 |
| Nivåer i ett score | från 2 till 10 |
| Indata | endast text: en sträng, ett JSON-objekt eller en array med texter |

Modellens gränser är uppgifter från TypeSafe. Begränsningar för din nyckel och ditt saldo gäller som för alla Ailoot-modeller: [Fel och gränser](https://ailoot.ai/docs/sv/errors/).

## [](https://ailoot.ai/docs/sv/api/systemone/#errors)Fel

Fel returneras i Ailoot API:s gemensamma format: kod, begriplig text och Request ID. Vanligast för denna metod är:

| Kod | När | Vad du ska göra |
| --- | --- | --- |
| **400** `invalid_request` | Anropskroppen klarade inte valideringen: state, model eller questions saknas, okänd type, fler än 255 alternativ i choice eller fler än 10 nivåer i score | Rätta anropet enligt felmeddelandet: utan ändring avvisas det igen |
| **400** `context_length_exceeded` | state och frågorna tillsammans överskrider modellens gräns | Filtrera state i koden och behåll det som frågorna behöver |
| **401** `invalid_api_key` | Nyckeln saknas eller är ogiltig | Skicka nyckeln i Authorization-headern |
| **402** `insufficient_balance` | Tillgängligt saldo räcker inte till reserveringen | Fyll på saldot |
| **404** `model_not_found`, `unsupported_endpoint` | Felaktigt ID eller modellen anropas med fel metod, till exempel via /v1/chat/completions | Anropa jev-latest endast via POST /v1/systemone |
| **429** `rate_limit_exceeded` | För många anrop | Vänta det antal sekunder som anges i Retry-After-headern och försök igen |
| **503** `model_overloaded`, `model_unavailable` | Modellen är tillfälligt överbelastad eller otillgänglig | Om X-Should-Retry: true — försök igen efter Retry-After sekunder; om false — kontrollera först Request ID i historiken |
| **504** `model_timeout` | Modellen svarade inte inom tidsgränsen | Skicka inte anropet på nytt förrän du har kontrollerat Request ID i historiken |

Den fullständiga kodlistan finns på sidan [Fel och gränser](https://ailoot.ai/docs/sv/errors/).

Har du fler frågor? Skicka Request ID och en beskrivning, så hjälper vi dig.[Kontakta supporten](mailto:support@ailoot.ai)

## Ailoot · Företaget och dess projektportfölj





Ailoot bygger på etablerad driftserfarenhet, en stor kundbas, stabil service och löpande KPI-kontroll.





Företaget och dess projektportfölj: miljontals kunder; månatlig försäljning för miljarder.





Ailoot använder denna driftserfarenhet för API-åtkomst till AI-funktioner i kundernas produkter, agenter, applikationer och automatiseringar.
