🦅 Jataayu

Im Ramayana war Jataayu der Adler, der sah, wie Ravana Sita entführte. Er wartete nicht auf ein passendes Muster. Er erkannte die Bedrohung, beurteilte die Situation und handelte — allein, ohne Zögern. Das ist Jataayu.

---

Die Laufzeit-Autorisierungsschicht für werkzeugnutzende KI-Agenten. Sperre die Aktion, nicht die Zeichenkette.

Jataayu entscheidet — deterministisch —, ob die Aktion eines Agenten ausgeführt werden darf, basierend auf dem Schaden der Wirkung × der Provenienz der Eingabe × deiner Fähigkeitsrichtlinie. Ein Agent, der eine angreiferkontrollierte Webseite gelesen hat, kann sie trotzdem zusammenfassen; er kann nur nicht dazu verleitet werden, den Shell-Befehl auszuführen, das Geheimnis zu lesen oder deine Daten per POST zu senden, was der Angreifer wollte. Um diesen Kern herum fügt es Defense-in-Depth-Prüfung hinzu (eingehende Injection, ausgehende Privatsphäre, Exfiltrationskanäle, Skill-Lieferkette) und wiedergabefähige Audit-Traces.

Warum „sperre die Aktion, nicht die Zeichenkette"

Die meiste Agenten-Sicherheits-Tooling versucht, den Angriffstext zu erkennen. Das ist ein aussichtsloses Wettrüsten: Ein adaptiver Angreifer schreibt die Zeichenkette einfach um, bis der Klassifikator sie verfehlt. Jataayus These — diejenige, auf die sich die Standards von 2026 (OWASP Agentic Top 10, NIST) verständigt haben — ist, dass die dauerhafte Grenze die Aktion ist, beurteilt danach, woher die beeinflussende Eingabe stammt:

• Was der Agent TUT, ist die eigentliche Garantie. Aus nicht vertrauenswürdiger Quelle stammende Eingabe, die einen Shell-Befehl, ein Geheimnis-Lesen oder einen Netzwerk-Schreibvorgang steuert, wird verweigert oder zur Genehmigung zurückgehalten — unabhängig davon, ob ein Detektor den Text markiert hat. Dies ist deterministisch (kein LLM) und ist Jataayus Kern.
• Was HEREINKOMMT (Defense-in-Depth). Injection gelangt über die erste Nachricht, ein vergiftetes Werkzeugergebnis oder etwas aus dem Gedächtnis Abgerufenes herein. Jataayu prüft all dies — als günstigen Vorfilter und Taint-Quelle, ausdrücklich nicht als das, worauf du dich verlässt.
• Was HINAUSGEHT. Privater Kontext kann lecken, wenn der Agent in einem Gruppenchat antwortet oder einen Issue kommentiert — meist über einen Exfiltrations-Kanal (eine datentragende URL / automatisch abgerufenes Bild), nicht über Prosa. Jataayu fängt den Kanal ab, nicht nur den Text.

Was es ist / was es nicht ist

• ✅ Ist: ein determinitives Aktionsautorisierungs-Primitiv + Provenienz-/Taint-Verfolgung + Audit-Trace für werkzeugnutzende Agenten. Die Wirkungsgrenze ist das Stück, auf dem man aufbauen sollte.
• ✅ Ist: Defense-in-Depth-Prüfung (eingehend / ausgehend / Egress / Skill-Prüfung), die darüber geschichtet ist.
• ⚠️ Ist nicht: ein erstklassiger Prompt-Injection-Klassifikator. Die Regex-Stufe ist ein Vorfilter, bewusst die schwächste Schicht; als eigenständiger allgemeiner Detektor ist sein Recall bescheiden (siehe Erkennungsleistung). Setze es nicht als deine einzige Verteidigung ein — das ist genau der Punkt, die Garantie auf die Aktion zu verlagern.

---

Status

v0.3.1 — Alpha. Noch nicht auf PyPI. Installation von GitHub (siehe unten). Die API kann sich vor 1.0 noch ändern. Siehe CHANGELOG.md für das, was in jeder Version gelandet ist, und ARCHITECTURE.md für das Design.

---

Installation

# Core (effect boundary + regex pre-filter, no LLM deps)
pip install git+https://github.com/saikrishnarallabandi/jataayu.git

# With cloud LLM backends (OpenAI + Anthropic) for the optional slow path
pip install "jataayu[llm] @ git+https://github.com/saikrishnarallabandi/jataayu.git"

# With Ollama (local, free slow path)
pip install "jataayu[ollama] @ git+https://github.com/saikrishnarallabandi/jataayu.git"

Erfordert Python ≥ 3.10. Die einzige harte Abhängigkeit ist requests; LLM-Backends sind optionale Extras.

---

Schnellstart

1. Autorisieren der Aktion (der Kern — hier beginnen)

Entscheide nach dem Schaden der Wirkung × der Provenienz der Eingabe, deterministisch (kein LLM):

from jataayu import jataayu_authorize_action

decision = jataayu_authorize_action(
    "shell.exec",
    {"cmd": "rm -rf /tmp/cache"},
    untrusted=True,   # these params were influenced by untrusted inbound content
)
# {tool_name, effect_class: 'shell', provenance: 'untrusted',
#  decision: 'allow'|'deny'|'needs_approval', reason, violations, commit_token}
if decision["decision"] == "deny":
    raise SecurityError(decision["reason"])

Aus nicht vertrauenswürdiger Quelle stammende Eingabe in eine Shell- / Code-Eval- / Secret-Read-Wirkung wird verweigert; in Netzwerk- / Datei-Schreib- / Speicher-Schreib-Wirkungen benötigt sie menschliche Genehmigung; alles andere ist erlaubt.

Für erzwungene Ausführung verwende die PREVIEW → COMMIT-Objekt-API — der commit_token bindet die exakte Anfrage, sodass das Verändern der Aktion nach der Autorisierung abgelehnt wird:

from jataayu import EffectBoundary, Value, Provenance

eb = EffectBoundary()
preview = eb.preview(
    "file.write",
    {"path": "notes.md", "text": text},
    values=[Value(text, Provenance.TRUSTED, source="user")],
)
if preview.approved:
    eb.commit(preview, {"path": "notes.md", "text": text}, lambda: write_file("notes.md", text))
# commit() raises CommitRejected if the preview wasn't ALLOW or the params changed

Eingeschleuster Inhalt kann dem Agenten auch als opaker Handle mit einer begrenzten Zusammenfassung übergeben werden, sodass ein Exfiltrationsversuch nur jemals einen Handle hält, nicht das rohe Geheimnis (Read-Boundary-Confinement).

2. Prüfe, was hereinkommt (Defense-in-Depth)

Injection gelangt über die erste Nachricht, über Werkzeugergebnisse und über alles herein, was der Agent aus dem Gedächtnis abgerufen hat. Dieselbe Engine, richtige Oberfläche — behandle dies als Taint-Quelle, die die Wirkungsgrenze speist, nicht als deine Garantie:

from jataayu import (
    jataayu_check_inbound,
    jataayu_check_tool_return,
    jataayu_check_memory_write,
    jataayu_check_memory_read,
)

result = jataayu_check_inbound(github_issue_body, surface="github-issue")
if result["status"] == "HIGH":
    raise SecurityError(f"Blocked: {result['findings']}")
# Returns: {status: 'SAFE'|'LOW'|'MEDIUM'|'HIGH', findings, risk_score, threat_types, blocked}

# A tool result or a memory recall can carry an injection — check before the agent consumes it
r = jataayu_check_tool_return(api_response, tool_name="web.search")
if r["blocked"]:
    raise SecurityError(r["findings"])
jataayu_check_memory_write(note)      # before persisting
jataayu_check_memory_read(recalled)   # before it re-enters context

3. Bewache, was hinausgeht — und fange den Exfiltrations-Kanal ab

Entferne PII/Geheimnisse, bevor du an gemeinsam genutzte Oberflächen sendest, und — wichtiger noch — blockiere die datentragende URL / das automatisch abgerufene Bild, das Kontext mit null Klicks leakt (die EchoLeak- / AgentFlayer- / Notion-Klasse). Der PII-Scanner sieht diese Nutzlast nie; der Egress-Guard schon:

from jataayu import jataayu_check_outbound, jataayu_check_egress

result = jataayu_check_outbound(
    draft_reply, surface="discord-channel",
    protected_names=["Alice", "Bob"],   # names that must never leak
)
safe_text = result["redacted"] if result["status"] in ("WARN", "BLOCK") else draft_reply