Laya einrichten: Jev lokal auf dem Laptop, so stufst du deine CRM-Leads offline ein

Jev hat vor zwei Wochen gezeigt, dass eine KI keinen Text schreiben muss, um nützlich zu sein. Sie kann auch einfach entscheiden: heiß oder kalt, anrufen oder liegen lassen, Buchhaltung oder Technik. Für Firmen hat Jev aber einen Haken. Es läuft nur über die API von TypeSafe, deine Daten gehen also auf fremde Server. Deine kompletten Kundendaten aus Salesforce oder HubSpot willst du da nicht einfach reinkippen.

Dafür gibt es Laya, einen offenen Nachbau unter Apache 2.0, der komplett auf deinem Rechner läuft. Ich hab ihn auf meinem MacBook installiert, mit deutschen Texten getestet und 200 Leads durchlaufen lassen. Hier steht das ganze Setup in fünf Schritten, vom Installieren bis zum Anlernen mit deinen eigenen alten Leads. Der letzte Punkt ist der wichtigste: Frisch ausgepackt ist Laya schwächer als Jev, angelernt liegt es auf dem Benchmark der Entwickler davor.

Was Laya macht

Laya funktioniert wie Jev. Du gibst ihm einen Text, zum Beispiel die Notiz zu einem Lead, und dazu Fragen mit festen Antworten. Es antwortet in einem einzigen Durchlauf und hängt eine Wahrscheinlichkeit dran. Drei Fragetypen gibt es:

• choice: wähle eine aus mehreren Optionen, etwa “heiß, warm, kalt”
• score: ordne auf einer Skala ein, etwa “nicht dringend, bald, sofort”
• noul: ja oder nein, etwa “Will der Kunde ein Angebot?”

Das Modell gibt es in drei Varianten. Für deutsche Texte nimmst du laya-multilingual, die kann über 100 Sprachen. Laya erkennt die Sprache selbst und schickt deutschen Text automatisch dorthin, das hab ich geprüft.

Schritt 1: Laya installieren

Du brauchst Python 3.10 oder neuer. Auf meinem Mac war das System-Python zu alt, deshalb hab ich eine eigene Umgebung mit uv angelegt:

uv venv --python 3.12 .venv-laya
VIRTUAL_ENV=.venv-laya uv pip install laya

Wer kein uv hat, nimmt python -m pip install laya. Die Umgebung ist bei mir rund 740 MB groß, weil PyTorch mitkommt.

Ein Stolperstein: Falls TensorFlow auf deinem Rechner liegt, kann Laya beim Start hängen bleiben. Setz vorher USE_TF=0, dann ist Ruhe.

Beim ersten Aufruf lädt Laya die Modellgewichte von Hugging Face, bei mir rund 1,3 GB. Das dauerte gut eine Minute. Danach läuft alles offline.

Schritt 2: Erster Test mit einer deutschen Mail

Bevor du an die Leads gehst, prüf, ob alles läuft. Ich hab Laya eine deutsche Beschwerde gegeben: doppelt abgebucht, Kunde droht mit Kündigung.

import os
os.environ["USE_TF"] = "0"
from laya import Router

router = Router(preload=False)

mail = ("Moin, ihr habt mir den März zweimal abgebucht. Bitte erstattet die "
        "doppelte Buchung noch heute zurück, sonst kündige ich den Vertrag.")

fragen = {
    "abteilung": {"type": "choice", "instructions": "Welche Abteilung soll das bearbeiten?",
                  "criteria": {"buchhaltung": "Rechnungen, Zahlungen, Erstattungen",
                               "technik": "Bugs, Ausfälle, Systemfehler",
                               "vertrieb": "Preise, neue Verträge"}},
    "kuendigung": {"type": "noul", "instructions": "Droht der Kunde mit Kündigung?"},
    "erstattung": {"type": "noul", "instructions": "Fordert der Kunde eine Erstattung?"},
}

ergebnis = router.predict(mail, fragen, model="multilingual")
print(ergebnis["answers"])

Ergebnis: Buchhaltung mit 99,9 Prozent, Kündigungsrisiko 0,80, Erstattung gefordert 0,96. Eine Entscheidung dauerte auf dem M2 rund 19 Millisekunden, zehn Fragen am Stück knapp 100 Millisekunden. Ohne Internet und ohne einen Cent.

Schritt 3: CRM-Leads einstufen

Für den eigentlichen Fall exportierst du deine Leads aus Salesforce oder HubSpot als CSV. Wichtig ist das Notizfeld. Da steht drin, was keiner mehr liest: “will bis Monatsende entscheiden”, “hat abgesagt”, “Chefin war beim Termin dabei”.

Für meinen Test hab ich 200 Leads ausgedacht, jeweils mit Firma, Rolle und Notiz, und jede Zeile vorher selbst eingestuft. So konnte ich hinterher zählen, wie oft Laya richtig liegt.

Am besten funktionierten bei mir zwei einfache Ja-Nein-Fragen statt einer großen Auswahl:

import csv

fragen = {
    "kauf": {"type": "noul",
             "instructions": "Will der Kunde bald kaufen oder hat er ein Angebot oder einen Rückruf angefragt?"},
    "tot": {"type": "noul",
            "instructions": "Hat der Kunde abgesagt, kein Interesse, keinen Bedarf oder reagiert er nicht?"},
}

def schritt(a):
    if a["kauf"]["noul"] > 0.5:
        return "anrufen"
    if a["tot"]["noul"] > 0.5:
        return "liegen lassen"
    return "Mail"

with open("leads.csv") as f:
    for lead in csv.DictReader(f):
        a = router.predict(lead["notiz"], fragen, model="multilingual")["answers"]
        print(lead["firma"], "->", schritt(a))

Tempo: 200 Leads in 8,6 Sekunden, rund 43 Millisekunden pro Lead, auf dem Laptop.

Die Trefferquote lag mit dieser Variante bei 62 Prozent. Mit einer großen Auswahlfrage und allen Feldern im Text waren es 51 Prozent. Einige Fehler waren ärgerlich: “Hat selbst angerufen, braucht schnell ein Angebot” landete bei “Mail”. “Hat die Preisliste zweimal geöffnet und nach einem Termin gefragt” landete bei “liegen lassen”. Firma, Rolle und Branche im Text haben das Ergebnis eher verrauscht, die Notiz allein war besser.

Das passt zu dem, was die Entwickler selbst schreiben. Die Model Card ist da ungewöhnlich offen:

• Ohne Anlernen ist Laya kaum besser als Raten. Auf ihrem Benchmark mit 2.000 Entscheidungen liegen die Basis-Checkpoints bei 0,36 und 0,35. Zufall wäre 0,318. Jev schafft auf demselben Benchmark 0,727.
• Viele Optionen mag es nicht. Ab rund 20 Antwortmöglichkeiten bricht es ein. Bei einem Test mit 77 Kategorien kommt Laya auf 0,425, Jev auf 0,870.
• Es ist zu selbstsicher. laya-multilingual kommt ganz ohne eingestellte Kalibrierung. Die Wahrscheinlichkeiten stimmen erst, wenn du sie auf deinen eigenen Daten nachjustierst.

Frisch ausgepackt bekommst du also eine schnelle, aber wacklige Vorsortierung, die ein Mensch noch mal anschaut. Damit die KI wirklich sagt, wen du morgen früh anrufst, kommt Schritt 4.

Schritt 4: Laya mit deinen alten Leads anlernen

Die Entwickler nennen Laya selbst “eine schnelle Basis zum Spezialisieren”. Angelernt auf Daten aus dem eigenen Bereich kommt dasselbe Modell auf ihrem Benchmark auf 0,766. Jev liegt dort bei 0,727. Hier holt Laya den Abstand auf und zieht vorbei.

Dein CRM weiß bei alten Leads längst, wie es ausgegangen ist: gewonnen, verloren oder versandet. Genau diese Paare aus Notiz und Ausgang zeigst du Laya. Danach erkennt es in neuen Notizen die Muster, die bei dir zu Aufträgen geführt haben. Dafür gibt es zwei Wege.

Weg A: lokal mit stuntd (mein Tipp für den Anfang)

stuntd ist ein kleines Werkzeug aus der Laya-Community. Es lässt Laya unverändert und trainiert pro Entscheidung einen kleinen Kopf obendrauf, rund 50 MB groß. Das läuft auf deinem Rechner, auf dem Mac über den Apple-Chip. In den Demos brauchten drei Köpfe mit je 3.000 Beispielen auf einer Nvidia-Laptop-Karte rund sechs Minuten.

1. Alte Leads als Lernmaterial exportieren. Aus dem CRM-Export baust du eine Datei leads-alt.jsonl, eine Zeile pro Lead, mit der Notiz als Text und dem Ausgang als Antwort:

{"text": "Chefin war beim Termin dabei, will bis Monatsende entscheiden", "answer": "gewonnen"}
{"text": "Preisliste geschickt, danach keine Reaktion mehr", "answer": "versandet"}
{"text": "Hat abgesagt, Budget ist an einen Mitbewerber gegangen", "answer": "verloren"}

Der Text muss genauso aussehen wie das, was du später zum Einstufen schickst. Wenn du später nur die Notiz schickst, lernst du auch nur mit der Notiz an.

2. stuntd installieren und auf den deutschen Checkpoint stellen. In derselben Umgebung wie Laya:

VIRTUAL_ENV=.venv-laya uv pip install "stuntd[train]"
hf download convaiinnovations/laya --include "multilingual/*" --local-dir laya-modell
stuntd config init

In der erzeugten stuntd.toml trägst du unter [training] drei Werte ein:

[training]
base_model = "laya-modell/multilingual"
device = "mps"
epochs = 24

Ohne base_model nimmt stuntd den englischen Checkpoint. mps ist der Apple-Chip, auf Windows mit Nvidia-Karte steht da cuda. Die 24 Durchläufe stammen aus den Demos von stuntd. Mit dem Standardwert 3 kam laut Anleitung dort fast nichts raus.

3. Einlesen, anlernen, prüfen:

stuntd import ausgang leads-alt.jsonl --labels gewonnen,verloren,versandet
stuntd train
stuntd report ausgang

ausgang ist der Name der Entscheidung. stuntd legt automatisch ein Fünftel der Leads zur Seite und prüft den angelernten Kopf daran. report zeigt dir, wie oft er richtig liegt und ab welcher Sicherheit er antworten darf. Darunter gibt er die Frage zurück, statt zu raten.

4. Laya mit dem angelernten Kopf starten:

stuntd enable ausgang
stuntd serve

stuntd läuft jetzt unter http://127.0.0.1:8787 und spricht dieselbe Sprache wie Jev. Jedes Tool, das für Jev gebaut ist, fragst du jetzt lokal an, du änderst nur die Adresse. Die Frage heißt ausgang, die Antworten sind gewonnen, verloren und versandet. Daraus leitest du den nächsten Schritt ab: gewonnen heißt anrufen, versandet heißt Mail, verloren heißt liegen lassen.

Was die Demos von stuntd zeigen: Bei einer Risiko-Frage im Banking-Beispiel stieg die Trefferquote durchs Anlernen von 30 auf 72,5 Prozent, bei einer Support-Kategorie von 69,5 auf 99,5 Prozent. Gemessen wurde da gegen die Antworten von Jev, mit je 3.000 Beispielen pro Entscheidung.

Drei Dinge, die ich mir aus der Anleitung gemerkt hab:

• Mindestens 300 Beispiele pro Entscheidung, darunter trainiert stuntd gar nicht. Mehr ist besser.
• Eine Entscheidung pro Frage. “Ist es dringend und wer ist zuständig” lernt schlechter als zwei getrennte Fragen.
• Schreib Zahlen als Satz. Laya lernt Text, keine Rechnung über Felder. “Umsatz 40.000, letzter Kontakt vor 3 Tagen” geht schlechter als “Großer Kunde, hat sich vor drei Tagen gemeldet”. Und wenn deine Entscheidung eigentlich eine Rechnung ist, schreib die Rechnung ins Skript statt ins Modell.

Bei stuntd bleiben die Daten auf dem Rechner. Es speichert alles in einer lokalen Datenbank, schwärzt E-Mail-Adressen und Telefonnummern von selbst und schickt keine Nutzungsdaten raus. Das Tool ist allerdings noch in Version 0.1, und durchgezogen hab ich das Anlernen selbst noch nicht. Die Befehle oben stammen aus der Anleitung.

Weg B: volles Fine-Tuning mit dem offiziellen Notebook

Wenn du das ganze Modell anlernen willst und nicht nur einen Kopf, nimmst du das Fine-Tuning-Notebook der Entwickler. Damit haben sie die 0,766 erreicht. Es läuft auf den zwei kostenlosen Grafikkarten bei Kaggle und macht alles am Stück: Datensatz bauen, trainieren, Kalibrierung einstellen, testen und das Ergebnis auf Hugging Face hochladen. Für rund 30.000 Fragen rechnen die Entwickler mit vier bis fünf Stunden, mit ein paar hundert Leads entsprechend kürzer.

Ein anderer Entwickler hat genau das für einen Browser-Agenten gemacht, auf einer einzigen Grafikkarte mit 16 GB. Die richtige Klick-Stelle unter rund 45 Kandidaten traf Laya vorher in 10 Prozent der Fälle, danach in 66 Prozent. Echte Aufgaben schaffte der Agent vorher gar nicht, danach in 62 Prozent der Fälle, bei 17 bis 23 Millisekunden pro Schritt.

Der Haken: Kaggle ist eine Cloud. Echte Kundendaten gehören da nur anonymisiert rein. Sonst lernst du auf einer eigenen Grafikkarte an oder bleibst bei Weg A.

Egal welcher Weg: Testsatz zurückhalten

Bevor du dem angelernten Laya vertraust, prüf es an Leads, die es beim Anlernen nie gesehen hat. stuntd macht das automatisch mit einem Fünftel der Daten. Noch besser: Such ein paar hundert Leads raus, bei denen ein Mensch den Ausgang geprüft hat, leg sie in eine eigene Datei und lass sie mit stuntd report ausgang --gold geprueft.jsonl bewerten. Diese Datei darfst du vorher nicht importieren, sonst misst du nur, ob Laya sich erinnert.

Schritt 5: Laya als Dienst in der Firma

Auf dem Laptop zu testen ist das eine. Im Alltag willst du, dass dein CRM-Export oder dein Postfach jeden Morgen automatisch durchläuft. Dafür gibt es drei Wege:

• stuntd serve aus Schritt 4, mit deinem angelernten Kopf und der Jev-Schnittstelle
• pip install "laya[serve]", der eingebaute HTTP-Server von Laya
• docker-laya, ein fertiges Docker-Image für eine VM in deinem Netz

Deine Skripte fragen Laya dann dort an statt auf dem Laptop. Getestet hab ich bisher nur den Laptop, der Server-Weg steht so in den Anleitungen.

Wer einen Mac mit Apple-Chip hat, kann sich außerdem laya-mlx anschauen, eine Version, die direkt auf dem Apple-Chip rechnet. Die Entwickler nennen 7 bis 14 Millisekunden pro kurzer Entscheidung auf einem M3 Max.

OpenAI zieht nach: die Decisions API

Am 29. September hat OpenAI auf dem DevDay die Decisions API vorgestellt, und die arbeitet nach demselben Prinzip wie Jev und Laya. Du legst Fragen mit festen Antwortmöglichkeiten fest, gibst Text oder ein Bild als Kontext mit und bekommst eine Antwort, mit der dein Skript direkt weiterarbeiten kann. OpenAI nennt als Beispiele Inhalte einordnen, Anfragen weiterleiten und den nächsten Schritt eines Agenten wählen. Dahinter steckt eine angepasste Version von GPT-6 Luna, dem kleinsten Modell der GPT-6-Familie. Eine Entscheidung dauert laut OpenAI 150 Millisekunden, ein normaler Aufruf von Luna 1,6 Sekunden. Gestartet ist die API als eingeschränkte Vorschau, die breite Freigabe soll in den nächsten Tagen kommen. Einen eigenen Preis und eine öffentliche Dokumentation gibt es noch nicht (Bericht bei The Decoder).

Für deine CRM-Daten ist die Lage damit dieselbe wie bei Jev: Die Leads gehen an fremde Server. Laya bleibt der Weg, wenn sie das Haus nicht verlassen dürfen. Getestet hab ich die Decisions API noch nicht. Spannend ist das Signal: Wenn OpenAI dasselbe Prinzip baut, werden Entscheidungsmodelle gerade zum Standardbaustein.

Meine Einschätzung

Heute ist Jev das bessere Modell, wenn du es einfach anschließen willst und deine Daten in die Cloud dürfen. Laya ist die bessere Wahl, sobald die Daten das Haus nicht verlassen dürfen und du bereit bist, es einmal mit deinen alten Leads anzulernen. Dann ist es auf dem Benchmark der Entwickler sogar besser als Jev, läuft kostenlos und kennt die Muster deiner Firma.

Ich glaube, der Abstand zu Jev schrumpft schnell. Jev ist seit dem 15. September draußen, und zwei Wochen später gibt es mit Laya einen offenen Nachbau mit über 25.000 Sternen auf GitHub, eigene Versionen für Apple-Chips, Docker-Images, ein kostenloses Anlern-Notebook und Werkzeuge wie stuntd, die das Anlernen auf ein paar Befehle runterbrechen. So lief das bei Sprachmodellen auch: erst das geschlossene Modell, dann offene Modelle, die für die meisten Aufgaben reichen. Ich erwarte, dass die Entscheidungsmodelle denselben Weg gehen, nur schneller.

Mein Rat: Installier Laya jetzt und lass es einmal über einen alten CRM-Export laufen. Dann exportier die Leads mit bekanntem Ausgang und lern es an. Der Testsatz sagt dir, ob es für deine Firma reicht.