Source: https://ailoot.ai/models/sv/jev-latest/
Canonical: https://ailoot.ai/models/sv/jev-latest/
Language: sv

# jev-latest

[Markdown](https://ailoot.ai/models/sv/jev-latest/index.md) · [JSON](https://ailoot.ai/models/sv/jev-latest/facts.json)

## [jev-latest](https://ailoot.ai/models/sv/jev-latest/)

Beslutsmodell från TypeSafe: skriver inte text utan svarar på typade frågor om text eller JSON, med val av alternativ, skalbedömning eller ”ja/nej” med sannolikheter. Passar för routning, sortering av ärenden, moderering och poängsättning. Alla frågor i ett anrop bedöms parallellt.

- [**Ailoot · System One** `POST /v1/systemone` `jev-latest`](https://ailoot.ai/models/sv/jev-latest/#method-0)

Om modellen

Den här beskrivningen omfattar modellens förmågor. Tillgängliga indata, utdata och alternativ i Ailoot anges nedan för den valda metoden.

Jev är TypeSafes flaggskeppsmodell och den första modellen i den nya klassen **System One**. Den skriver inte text utan fattar snabbt beslut som ett program kan använda direkt. Du skickar ett **tillstånd** (`state`), text eller JSON, och en uppsättning **frågor**, och får typade värden med kalibrerade sannolikheter tillbaka.

Språkmodeller skriver ord för människor. Enligt TypeSafe ligger Jev närmare kod: svaret är direkt i kodens önskade form, med hög hastighet och inga värden utanför de angivna alternativen. Modellen är utformad för stabila svar vid upprepade anrop.

#### Så skiljer sig System One från en språkmodell

- **Genererar inte.** Jev skriver inte användarsvar, kod eller förklaringar av resonemang. Du anger de möjliga svaren genom en av tre frågetyper.
- **Tränad för kalibrerade beslut.** TypeSafe tränar modellen med RLCD (Reinforcement Learning for Calibrated Decisions): sannolikheterna anpassas till verkliga utfall och speglar osäkerhet. Bland många svar med sannolikhet 0,8 bör ungefär 80% vara korrekta. Kalibrering är en egenskap för stora urval, inte en garanti för att ett enskilt svar är rätt.
- **Annat träningsmål.** Chattmodeller tränas att tilltala människor (RLHF). Enligt TypeSafes observationer uppmuntrar det inställsamhet och självsäkert uttryckta fel. En av RLHF:s medförfattare, Diogo Almeida, är medgrundare av TypeSafe.

Namnet syftar på ”System 1” i Daniel Kahnemans bok ”Tänka, snabbt och långsamt”: snabbt intuitivt omdöme jämfört med det långsamma, genomtänkta tänkandet i ”System 2”. Jev är skapad för snabba, avgränsade bedömningar.

#### Tre frågetyper

En fråga är en bedömning av tillståndet. Svaret är ett värde som koden jämför med en tröskel, sorterar eller skickar vidare.

1. **Choice – val av alternativ.** Avdelning för ett ärende, produktkategori eller språk i ett kodavsnitt. Alternativen är en ordlista ”alternativ → beskrivning”, med upp till 255 alternativ. Svaret innehåller vald `choice`, `probabilities` för alla alternativ (med summan 1) och säkerhet `confidence`. Om listan kanske inte täcker alla fall kan ”annat” eller ”inget av ovanstående” läggas till.
2. **Score – skalbedömning.** Placering på en ordnad skala som du beskriver: felets allvar, kundens irritation eller färdighetsnivå. Från 2 till 10 nivåer, från lägsta till högsta. Modellen bedömer varje nivå separat utan att se dess nummer eller grannar. Svaret innehåller `score` (summan av nivånumren multiplicerade med deras sannolikheter, så värdet kan hamna mellan nivåer), `legend` med nivåbeskrivningar, `probabilities` och `confidence`.
3. **Noul – ja eller nej.** Om påståendet är sant. Svaret `noul` är sannolikheten för ”ja” från 0 till 1: nära 1 ett säkert ”ja”, nära 0 ett säkert ”nej”, nära 0,5 tvekar modellen. Separat `confidence` finns inte. Ett tal beskriver hela svaret. Valfri `criteria` preciserar vad som ska räknas som ”ja” respektive ”nej”.

Så väljer du: kända oordnade alternativ använder choice, steg i ett spektrum score och rent ”ja/nej” där själva sannolikheten är viktig noul. Noul 0,5 innebär lika chanser för ”ja” och ”nej”, inte en ”medelnivå”. Graden mäts med score. Om två typer passar, välj den som koden direkt kan agera på: choice för grenar, score för trösklar och noul för `if`.

Typer kan blandas i samma anrop. Svaret begränsas alltid av dina alternativ och beror inte på andra frågor. Frågor kan läggas till och tas bort utan att övriga svar ändras.

#### Tillstånd

Tillståndet är det som modellen bedömer: kundens meddelande, ett dokumentutdrag, en databaspost eller applikationens tillstånd.

- **Sträng** när det finns en text: ett meddelande, en artikel eller ett utdrag.
- **Objekt** för namngivna fält, relaterade poster eller applikationstillstånd. TypeSafe rekommenderar objekt för de flesta anrop: varje del får ett tydligt namn.
- **Array** för en följd av meddelanden eller poster.

Förbered det som material för experter: lägg korrespondens, beställning och returregler tillsammans om beslutet kräver jämförelse. Behåll innehållet i tillståndet och bedömningarna i frågorna. Om en fråga gäller en del av tillståndet, ange sökvägen till den inom backtick-tecken, till exempel `ticket.messages[0].text`.

#### Så formuleras frågor

- **En snabb bedömning per fråga.** En bra fråga kan en kunnig person med rätt kontext besvara på en sekund: ”Finns brådska i meddelandet?” ”Analysera meddelandet och avgör vad som ska göras” kräver redan långsamt resonemang och behöver delas i enkla frågor.
- **Hela frågan i `instructions`.** Frågans nyckel, till exempel `refund_requested`, behövs bara för din kod och skickas inte till modellen.
- **Alla frågor om samma tillstånd i ett anrop.** Modellen bedömer dem parallellt. Enligt TypeSafe ökar extra frågor knappt svarstiden och kostar bara sina egna token. En fråga ”för säkerhets skull” kostar nästan inget. Koden avgör själv vilka svar som behövs.
- **Dela upp komplexa bedömningar.** I stället för ”bedöm startupansökan”, fråga separat om marknadsstorlek, teknisk genomförbarhet och skillnader mot konkurrenterna. Beräkna resultatet i kod med vikter. Ändrade prioriteringar innebär ändrade vikter, inte en omskriven fråga.
- **Beroende frågor i ett andra anrop.** Svaren i samma anrop utgör inte kontext för varandra. Ett andra anrop behövs bara om det inte går att bygga utan det första svaret, till exempel om data måste hämtas eller nästa frågas alternativ väljas.
- **Lång fråga som objekt.** `instructions` och `criteria` är vanligtvis strängar men kan vara objekt eller arrayer: frågan i ett fält och data i andra. Det är praktiskt för att jämföra ett CV med databasposter i samma fråga.

#### Säkerhet

För choice och score visar `confidence` från 0 till 1 hur koncentrerad sannolikheten är till ett svar: 1 innebär allt på ett alternativ och 0 lika mycket på alla. För score minskar en intilliggande nivå säkerheten mindre än en avlägsen. För noul är säkerheten själva värdet. Ju längre från 0,5, desto säkrare svar.

TypeSafe rekommenderar tre intervall:

1. **Hög säkerhet** – agera automatiskt.
2. **Medelhög** – agera försiktigt, till exempel be användaren bekräfta.
3. **Låg** – lämna fallet till en människa, precisera förfrågan eller använd en reservväg, till exempel en kraftfullare modell med resonemang.

Ju dyrare felet är, desto striktare tröskel: högre för oåterkalleliga åtgärder än för läsning. Svaret anger vad som ska väljas och säkerheten om det är lämpligt att agera. Anpassa trösklarna till egna data genom att jämföra säkerhet och precision.

#### Så byggs ett system kring Jev

Jev är inte utformad för agenter som själva väljer nästa steg och kan tappa riktningen i varje cykel, utan för program där koden styr flödet och modellen svarar på avgränsade betydelsefrågor. TypeSafes åtta designsteg:

1. Gör allt som kan göras i kod med kod, tillförlitligt och billigt.
2. Lägg bara det som de aktuella frågorna behöver i tillståndet. Hämta aktuella fakta från din egen kunskapsbas, inte modellens minne.
3. Struktur i tillståndet: nästlad JSON och sökvägen till rätt fält inom backtick-tecken i frågan om det minskar mångtydighet.
4. De mest avgränsade och specifika frågorna är enligt TypeSafe kanske huvudregeln: en bred fråga gömmer flera bedömningar bakom ett svar.
5. Struktur i frågorna: själva frågan är kort. Förklaringar, exempel och värden från din databas finns i närliggande fält i objektet `instructions` eller `criteria`, inte i en lång sträng.
6. Många oberoende frågor om samma tillstånd i ett anrop ger mer nytta per dollar.
7. Koden kombinerar svaren med regler, viktad summa eller som egenskaper för en klassisk maskininlärningsmodell.
8. Förgrening efter säkerhet: osäkra fall lämnas till en människa eller en modell med resonemang.

Jev är varken chatt eller kodkompletteringsmodell och kan inte ersätta en språkmodell i en programmeringsagent. Däremot kan en agent skriva kod åt dig som anropar Jev där ett snabbt kalibrerat svar behövs.

#### Användningsområden

- **Bakgrundsautomatisering** – beslut som körs en miljon gånger utan en människa i närheten.
- **Realtid** – enligt TypeSafe utförs de flesta anrop på ungefär 100 ms, vilket räcker för löpande bearbetning och gränssnitt.
- **Stora datamängder** – sökning i enorma korpusar, märkning av agentloggar och egenskaper för prognoser.
- **Granskning av andra modeller** – förfrågningar, extraheringar, resonemang och verktygsanrop: kringgående av begränsningar, citeringsfel och påhitt.
- **Sökning och rangordning** – relevans för paret ”fråga – kandidat”, omrangordning och kontexturval.
- **Förgrening efter avsikt** – vad användaren vill och vilken hanterare som behövs: enkel logik, specialiserad modell eller människa. Ämne, svårighet och risk avgör vilken språkmodell som får förfrågan.
- **Skyddskontroller** – språkmodellens indata, utdata och verktygsanrop: injicerade instruktioner, regelöverträdelser och personuppgiftsläckor.
- **Support** – ärendets ämne och avsikt, brådska, irritation, avhoppsrisk, återbetalningsbegäran och kö.
- **Moderering** – enligt plattformens regler: toxicitet, trakasserier, skräppost, bedrägeri, farliga råd och personuppgifter. Allvar och säkerhet avgör om material släpps igenom, får en varning, granskas eller blockeras.
- **Branscher** – försäkringsfall, finansiella utredningar och KYC, avtal och reklam, produktkort, rekrytering, leads, spel, risker, efterfrågeprognoser, kunskapsgrafer, vetenskapliga översikter och semantiska kodkontroller i CI.

#### Egenskaper

- **`jev-latest`** är alias för den senaste stabila versionen, för närvarande Jev 1.13. Versionen som svarade finns i fältet `model`, till exempel `jev-1.13.0`. Med en ny version pekar aliaset på den och svaren kan ändras utan dina ändringar. Följ fältet om trösklarna är anpassade till en viss version.
- **Kontext** är 64K token per anrop för tillstånd och alla frågor tillsammans. Tillstånd med den längsta frågan får vara upp till 32K. Modellen läser tillståndet en gång och prövar alla frågor mot det parallellt.
- **Indata** är bara text: sträng, JSON-objekt eller textarray. Bilder, ljud och video stöds ännu inte. Omvandla dem till text i förväg.
- **Språk** – huvudspråket i träningen är engelska och precisionen är för närvarande högst på det. Andra språk, bland annat kinesiska, japanska och koreanska, tas emot av modellen men med lägre precision. Pröva på egna data.
- **Priser och debitering i Ailoot API** — villkoren beror på den valda metoden och anges på metodens kort.
- **Anpassning** – Jev finjusteras inte på kunddata. Egna material läggs i `state` och ämnesområdets regler i `instructions` och `criteria`.
- **Data** – TypeSafe uppger att Jev inte tränas på kunders anrop och svar.

#### Kända svagheter i Jev 1.13

TypeSafe räknar öppet upp den aktuella versionens svagheter och lovar att åtgärda mycket i kommande versioner. Modellen är snabb, kalibrerad och bedömer väl med sunt förnuft, men:

1. **Läser bokstavligt.** Svarar på den skrivna frågan, inte den underförstådda. Förbehåll, negationer och dolda villkor förstås ordagrant. Skriv exakta villkor och gränsfall i `criteria`. Dela ofrånkomlig tolkning i två bokstavliga frågor.
2. **Ingen räknare.** Räkning av tecken, upprepningar och listelement är opålitlig och felen växer med storleken. Räkna i kod med en fråga per kandidat. Modellen förstår färger i hex eller RGB sämre än färgnamn. `score` passar för en tröskel men inte för ett exakt tal mellan nivåer.
3. **Datum och tid.** Vilket datum som är tidigare, avståndet mellan dem och om ett datum ligger inom en period är opålitligt, särskilt med blandade format och relativa datum. Extrahera datumdelar med choice och alternativet ”ej angivet” och jämför i kod.
4. **Indirekthet.** Dubbla negationer och frågor om egenskaper hos egenskaper sänker precisionen. Skriv direkt och namnge tillståndets delar.
5. **Överflöd i tillståndet.** Ovidkommande text sänker precisionen. Filtrera i kod, eller avskilj irrelevanta delar med noul-frågor om filtrering inte är möjlig.
6. **Fientlig text.** Modellen förväntar sig inte som standard knep i tillståndet. En injicerad instruktion eller text som argumenterar om sin egen klassificering kan påverka svaret. Skriv exakta kriterier och kontrollera gränsfall före start.
7. **Motsägelser.** Om `instructions` och `criteria` begär olika saker, till exempel om ”ja” för noul beskrivs som ”nej”, sjunker precisionen. Kriterierna är en fortsättning på frågan.
8. **Alternativordning.** Ibland föredrar modellen det första choice-alternativet. Ändra ordningen och kontrollera att svaret inte ändras.
9. **Generering.** Jev har inte tränats att skriva text. För dataextrahering kan kandidater hittas med reguljära uttryck eller en generativ modell. Låt sedan Jev välja den rätta med choice.

**Ailoot · System One** `POST /v1/systemone` `jev-latest`

[`jev-latest`](https://ailoot.ai/models/sv/#m=jev-latest&route=Core&caller=jev-latest&fmt=systemone)

TypeSafe /`jev-latest`

### Start

Beslutsmodell från TypeSafe: skriver inte text utan svarar på typade frågor om text eller JSON, med val av alternativ, skalbedömning eller ”ja/nej” med sannolikheter. Passar för routning, sortering av ärenden, moderering och poängsättning. Alla frågor i ett anrop bedöms parallellt.

Godkända indata

Text

Resultat

structured

### Tillgängligt i Ailoot · indata & metoder

**Ailoot · System One** `POST /v1/systemone`

Indatatyper

`text`

Utdatatyper

`structured`

Kontext

64 000 tokens

Utdataformat

json

| Fält | Typ | Krav | Värden & gränser | Standard |
| --- | --- | --- | --- | --- |
| Fält`model` | Typ`string` | KravObligatoriskt | Värden & gränser jev-latest | Standard— |
| Fält`state` | Typ`string\|object\|array` | KravObligatoriskt | Värden & gränser | Standard— |
| Fält`questions` | Typ`object` | KravObligatoriskt | Värden & gränser Minsta antal objektfält: 1 | Standard— |
| Fält`questions.<id>.type` | Typ`string` | KravObligatoriskt | Värden & gränser noul, choice, score | Standard— |
| Fält`questions.<id>.instructions` | Typ`string\|object\|array\|null` | KravValfritt | Värden & gränser | Standard— |
| Fält`questions.<id>.criteria` | Typ`object\|array\|null` | KravValfritt | Värden & gränser Villkor: noul: valfria beskrivningar av true/false som får vara null; choice: kriterieobjekt; score: icke-tom kriteriearray | Standard— |
| Fält`stream` | Typ`boolean\|null` | KravValfritt | Värden & gränser false, null | Standard— |

Kombinationer av indatamaterial

**noul** · Krävs: state, questions.\<id\>.type=noul

**choice** · Krävs: state, questions.\<id\>.type=choice, criteria object

**score** · Krävs: state, questions.\<id\>.type=score, nonemptycriteriaarray

Metodparametrar och livscykel

| Parameter | Avtal |
| --- | --- |
| Parameter`material_types` | Avtaltext |
| Parameter`required` | Avtalmodel, state, questions |
| Parameter`optional_controls` | Avtalnull |
| Parameter`content_type` | Avtalapplication/json |

Livscykel: `exact retained published method`

Metodernas strukturer och ID:n är exakta; leverantörens funktioner är åtskilda från att begäran tillåts.

### Priser

#### Priser för Ailoot-metoder

Indata

≈0,000084 US$ */ 1K*

Utdata

0,00 US$ */ 1K*

Ailoot reserverar ett uppskattat belopp före en begäran. Efter resultatet slutregleras avgiften utifrån uppmätt förbrukning. Slutreglering för strömning använder den slutliga förbrukningsposten. [Så fungerar reservation och slutreglering →](https://ailoot.ai/docs/sv/billing/reserve/)

### Exempelbegäranden

#### Ailoot · System One

Klassificeringsexempel

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 customer message}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "jev-latest", "state": "", "questions": {"is_urgent": {"type": "noul", "instructions": "Does the supplied customer message express urgency?"}}}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["state"]=text
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/systemone \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```

### Ta emot och spara resultat

#### Ailoot · System One

json

##### Behåll alla färdiga resultat

Behåll varje fullständigt returnerat svar, fil och innehållsdel.

Behåll varje svar med dess angivna fråge-ID, sannolikhet och teckenförklaring; konfidensformeln som använder n kräver n\>1 utan att därmed fastställa någon regel för API:ets minsta antal alternativ.

Svarsfält

| Fält | Typ |
| --- | --- |
| Fält`answers.<id>.type` | Typstring |
| Fält`answers.<id>.noul` | Typnumber |
| Fält`answers.<id>.choice` | Typstring |
| Fält`answers.<id>.score` | Typnumber |
| Fält`answers.<id>.confidence` | Typnumber |
| Fält`answers.<id>.probabilities` | Typobject |
| Fält`answers.<id>.legend` | Typobject |
| Fält`usage` | Typobject |

Fel och nästa steg

| Svar | Villkor | Nästa steg |
| --- | --- | --- |
| Svar400 · `invalid_request_error` | VillkorOgiltiga obligatoriska fält, ogiltig representation av underlaget eller ogiltigt parametervärde | Nästa stegKorrigera de angivna fälten före en ny begäran om att skapa. |

### Alias

#### Modellalias

**Ailoot** [`jev-latest`](https://ailoot.ai/models/sv/#m=jev-latest&route=Core&caller=jev-latest&fmt=systemone)

#### Alias för metodsökvägar

Använd metodsökvägarna som visas ovan.

#### Relaterade anropar-ID:n

[`jev-latest`](https://ailoot.ai/models/sv/#m=jev-latest&route=Core&caller=jev-latest&fmt=systemone)

FAQ · jev-latest

Vilka indata och resultat finns?

`POST /v1/systemone` · `jev-latest`: `text` → `structured`

Vilka fält använder begäran?

`POST /v1/systemone` · `jev-latest`: `model`, `state`, `questions`, `stream`

Vilka gränser gäller?

`POST /v1/systemone` · `jev-latest`: `ctx`: `64000`

Anslut Ailoot till Claude Code, OpenCode, Hermes eller din app.

## Företaget och dess projektportfölj

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

## Köp token med rabatt.

Prenumerationsrabatt för återkommande arbete. Kampanjkoder ger upp till 50% vid tokenköp.

Prenumeration

Välj en rabatterad plan för återkommande anrop.

Kampanjkod upp till 50%

Ange koden vid köpet. Priset räknas om enligt kampanjen.

Kostnader i historiken

Modell, token och belopp sparas för varje anrop.

[Välj prenumeration](https://ailoot.ai/docs/sv/billing/subscriptions/) · [Se modellpriser](https://ailoot.ai/models/sv/)

## Anslut API till produkten som du säljer.

SaaS, appar och botar enligt Ailoots officiella villkor och licensavtal. Begär återförsäljarlicens för vidareförsäljning.

Kommersiell applikation

Bygg text-, bild-, video- och ljudgenerering i tjänstens betalda funktioner.

Återförsäljarlicens

Skicka projektbeskrivning och åtkomstupplägg. Begär skriftliga villkor för användning och vidareförsäljning.

Dokument på webbplatsen

Officiella villkor, licensavtal och databehandlingspolicy finns tillgängliga före anslutning.

[Begär återförsäljarlicens](mailto:support@ailoot.ai) · [Officiella villkor och licensavtal](https://ailoot.ai/legal/offer?lang=sv)

## 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.
