Entscheidungen in Millisekunden, direkt auf dem Mac.

Drei Fragetypen, ein Aufruf

Jede Antwort ist eine Verteilung, keine Textgenerierung. Die Konfidenz ist kalibriert, also taugt sie als Schwelle: sicher genug, um zu handeln, oder an einen Menschen weitergeben. Die Balken unten sind echte Antworten von laya auf das Ticket aus dem Bild, in einem Aufruf, 27 ms.

Welches nehmen?

JevCoreML zuerst. Es ist ein Paket statt drei, beantwortet mehrere Fragen in einem Durchlauf, nimmt lange Zustände und viele Optionen, und sein Server versteht bestehende Jev-Clients. laya lohnt sich, wenn die Texte in vielen Sprachen kommen (der mehrsprachige Checkpoint ist über 100 Sprachen gemessen, JevCoreML ist auf englischen Daten trainiert und auf Deutsch nicht vermessen), wenn eine App klein bleiben muss (JevCoreML belegt geladen bis zu 18 GB im Temp-Verzeichnis, laya unter einem), oder wenn es um eine einzelne Klassifikationsfrage mit hoher Trefferquote geht (AG News 92,9 %). Beide liefern dieselbe Antwortform, ein Wechsel kostet eine Zeile.

Gleich wie das Original, nur schneller

Gemessen auf einem M5 Max, dieselben Anfragen auf beiden Seiten, Median. laya im Original läuft als PyTorch auf der CPU, so wie es sich selbst misst.

Gegen den Cloud-Dienst Jev 1.13, der auf kev beruht: dieselbe Trefferquote auf Banking77 mit 77 Kategorien, 78,8 %, in 70 statt 320 ms und ohne Kosten je Aufruf.

Einbinden

Ein Swift-Paket, eine Kommandozeile, ein HTTP-Server. Alles aus demselben Repo.

// Package.swift
.package(url: "https://github.com/GodModeAI2025/JevCoreML", from: "1.0.0")

import JevDecisionKit

let laya = try LayaRouted.bundled()   // Modelle als Ressourcen im App-Target
let result = try await laya.answer(
    state: .object([("message", .string(ticketText))]),
    questions: [
        ("team", .choice(instructions: "An welches Team geht das Ticket?", criteria: [
            (name: "billing", description: "Rechnungen, Zahlungen"),
            (name: "tech", description: "Fehler, Ausfälle"),
        ])),
        ("dringend", .noul(instructions: "Ist das dringend?")),
    ])

for (id, answer) in result.answers {
    print(id, answer.answer, answer.confidence)
}

git clone https://github.com/GodModeAI2025/JevCoreML.git && cd JevCoreML
scripts/fetch-models.sh alle           # laya und das kev-Paket, rund 3,3 GB; "kev" oder ohne Argument für einen Teil
swift build -c release

.build/release/jev --engine laya --models Models --demo --repeat 15
.build/release/jev --engine laya --models Models --request Examples/support-triage.json

.build/release/jev --engine laya --models Models --serve --port 8008

curl -s localhost:8008/v1/systemone -d '{
  "state": "Der Kunde wurde zweimal belastet und will sein Geld zurück.",
  "questions": {"erstattung": {"type": "noul", "instructions": "Will der Kunde Geld zurück?"}}
}'

# Antwort in der Form von laya.Router.predict, samt routing und act_probability

In vier Schritten zur ersten Entscheidung

1. Repo klonen. Voraussetzung ist ein Mac mit Apple Silicon, macOS 15 und Xcode 16. Das Swift-Paket baut auch für iOS 18 und läuft im iPhone-Simulator, dort ohne GPU: JevCoreML trifft dieselben Entscheidungen wie PyTorch, die Wahrscheinlichkeiten liegen bis 0,01 daneben, beim gepackten Mehrfragenlauf bis 0,034; laya weicht bis 0,04 ab. Auf einem echten iPhone ist nichts gemessen.
2. scripts/fetch-models.sh lädt die Core-ML-Pakete aus dem Release und prüft die Prüfsummen.
3. Demo/JevDemo.xcodeproj öffnen und starten, oder swift build für die Kommandozeile.
4. In der eigenen App das Paket einbinden und die Modelle als Ressourcen ins Target legen.

Die Modelle

Jedes Paket nimmt mehrere Eingabelängen an, und eine Anfrage läuft in der kürzesten, in die sie passt. So rechnet auch laya im Original. Die Pakete liegen als ZIP im Release models-v2, jede Zeile unten hat ihren Download; scripts/fetch-models.sh holt und prüft sie in einem Schritt.

Prüfsummen: SHA256SUMS. Entpackt liegt jedes Paket als .mlpackage vor, das Xcode beim Bauen übersetzt.

JevCoreML: ein Paket für alles

JevCoreML ist ein Decoder mit Pointer-Kopf, die Gewichte sind kev-0.6b auf Qwen3-0.6B-Base, nach Core ML übertragen, fp16, 1,1 GB. Früher gab es davon drei Zuschnitte für drei Längen, und man musste wissen, welcher zur Anfrage passt. Jetzt trägt ein Paket alle sechs Längen als aufgezählte Eingabeformen, und die Laufzeit rechnet jede Anfrage in der kürzesten, in die sie passt. Eine kurze Frage kostet 7,5 ms, ein langer Zustand mit 3000 Token 270 ms, ohne dass jemand etwas einstellt.

Nach dem Entpacken: JevCoreML.mlpackage und tokenizer.json nebeneinander ablegen, dann SystemOne(modelURL:tokenizerURL:). Oder im geklonten Repo scripts/fetch-models.sh kev, das lädt, prüft und entpackt.

Wie geprüft wurde

Jede Stufe einzeln gegen das Original, weil ein Fehler auf jeder Stufe lautlos bleibt: plausible Antworten, nur manchmal andere.

• Tokenizer. 31 238 Fälle bei laya, 15 032 bei JevCoreML, byte-identisch, dazu jeder Unicode-Codepunkt einzeln.
• Encoder. Die Sequenz Token für Token gegen die des Originals, samt Kürzungsregeln.
• Modell. Logits gegen PyTorch auf Referenzanfragen und zwei öffentlichen Datensätzen.
• Router. 116 Entscheidungen über Schrift, Sprache und Vorrang, alle gleich.
• HTTP. Antworten Feld für Feld neben die von Router.predict gelegt.
• Befunde. Neural Engine, NaN in fp16, Unicode-Versionen, Positionswinkel in fp16: alles gefunden, gemessen, behoben.

Die ausführlichen Berichte: laya-Port · Benchmark-Bericht · Rohdaten