Blog • AI / Agent

Wird Siri AI zum AI Agent? Apple Intelligence, App Actions, API und wie JSON funktioniert

Bei Siri AI denkt man schnell an einen ChatGPT-artigen Agent, der selbst Tools wählt und APIs zusammenbaut. Das hat Apple auf der WWDC 2026 nicht geliefert.

Siri AI wird zum System-Agent: persönlicher Kontext, Inhalt auf dem Bildschirm, App Actions appübergreifend. Es ist kein offener Agent. Das Modell erfindet keine REST-Pfade und schreibt kein beliebiges JSON auf Ihren Server.

Dieser Artikel erklärt:

• Welche Schicht Apple Intelligence besitzt, welche Siri AI
• Was App Actions auf der Entwicklerseite sind (App Intents + App Schemas)
• Wie Daten durch eine appübergreifende Aufgabe fließen
• Auf welchem Hop JSON vorkommt — und auf welchem nicht
• Der Vergleich zu Function Calling / MCP-Agenten und wie Sie Aktionsparameter in JSONNote prüfen

Zuerst die Antwort: System-Agent, kein offener Agent

Das Wort Agent ist überdehnt. Manche meinen einen gesprächigen Assistenten. Andere eine Runtime, die Tools im Kreis aufruft, bis die Sache erledigt ist. Siri AI liegt näher am Zweiten — aber wo die Tools herkommen, unterscheidet sich völlig von einem offenen Agent.

Ein offener Agent (ChatGPT, Claude, eine selbstgebaute Runtime) läuft meist so: Das Modell liest ein Gespräch, wählt name und arguments aus einer tools-Liste, die Runtime führt aus, das Ergebnis geht zurück ins Gespräch. Den Katalog schreiben Sie. JSON Schema ist der Eingabevertrag. MCP übernimmt oft Entdeckung und Ausführung. Ein anderer Artikel auf dieser Site zerlegt die vier Schichten:

2026 AI-Agent-Stack: Wie passen LLM, MCP, Function Calling und JSON Schema zusammen?

Der Loop von Siri AI läuft im System. Der Nutzer spricht mit Siri oder zeigt auf „dieses“ auf dem Bildschirm. Das systemseitige Modell (auf dem Gerät oder Private Cloud Compute) versteht die Absicht und wählt aus dem Aktionskatalog installierter Apps. Ihre App besitzt die Sitzung nicht. Sie ist nur der Fähigkeitenanbieter, zu dem geroutet wird.

Die Antwort ist also kein flaches Ja oder Nein. Siri AI plant, füllt Slots und arbeitet appübergreifend in Folge — das ist bereits Agent-Verhalten. Es wird keine offene Runtime, an die Sie beliebig einen MCP-Server hängen. Beide Ketten berühren Apps, APIs und JSON. Wer die Sitzung besitzt und wer Parameter erzeugt, ist nicht dasselbe.

Was Apple Intelligence ist und was Siri AI

Trennen Sie die Produktnamen zuerst. Vermischen Sie sie, haben App Actions und JSON keinen Landeplatz.

Apple Intelligence ist die Plattform: generative Modelle in Systemfähigkeiten von iPhone, iPad und Mac. Schreiben, Bilder, Benachrichtigungszusammenfassungen, Visual Intelligence und ein Teil der Inferenz, die das Gerät verlassen muss, hängen an dieser Schicht. Anfragen außerhalb des Geräts gehen über Private Cloud Compute, nicht über gewöhnliche Public-Cloud-Logs. Offizieller Einstieg:

Apple Intelligence.

Siri AI ist die neue Siri, auf der WWDC im Juni 2026 vorgestellt, angetrieben von der nächsten Generation von Apple Intelligence. Apples eigene Formulierung: gesprächiger, persönlicher Kontext, Weltwissen, Bildschirmwahrnehmung und mehr systemweite App Actions. Dazu kommt eine eigene Siri-App, um Gespräche geräteübergreifend nachzulesen. Newsroom:

Apple stellt Siri AI vor.

Entwicklertests starteten am WWDC-Tag für iOS 27, iPadOS 27, macOS 27 und visionOS 27. Anfang September 2026 steckt es noch im Herbst-OS-Testzyklus (Ende August war iOS 27 Developer Beta 8). Behandeln Sie es beim Schreiben dieses Artikels nicht als fertiges Feature, das auf jedem Nutzergerät standardmäßig an ist.

Es gibt eine dritte Kette. Nicht mit Siri vermischen: Ihre App startet selbst eine Sitzung mit Foundation Models. Dann läuft das Modell in Ihrem Prozess, Tools injizieren Sie, und das System wählt nicht „welche App öffnen“. Framework-Hinweise:

Foundation Models.

Die WWDC 2026 hat Gemini als optionales externes Foundation-Modell neben dem früheren ChatGPT ergänzt. Für Nutzer ist das ein weiterer Ausgang für Weltwissen. Für Entwickler ändert sich der Vertrag von App Actions kaum: Ein externes Modell erreicht weiterhin kein Intent, das Sie nicht deklariert haben.

App Actions: wie Siri Ihre App aufruft

Nutzer hören App Actions: was Siri mit dieser App tun kann. Entwickler liefern App Intents. Soll Siri AI eine Aktion orchestrieren, müssen Sie sie an einem App Schema (assistant schema) ausrichten, damit das vortrainierte Systemmodell die Aktionskategorie erkennt.

Apples WWDC26-Satz ist direkt: Siri wurde stärker durch Apple Intelligence; der Weg für Entwickler in Apple Intelligence sind App Intents. Die Session

Build intelligent Siri experiences with App Schemas

faltet Siris Fähigkeiten in drei Dinge: Zugriff auf Ihre Entities, Aktionen über Intents, Verständnis des Bildschirmkontexts.

App Intents sind ein Fähigkeitenkatalog

Für den System-Agent ist eine App kein „öffnen und rumschauen“. Sie ist ein auffindbarer Fähigkeitenkatalog. Sie deklarieren Aktionsnamen, natürlichsprachliche Beschreibungen, Parametertypen und Ergebnisse mit AppIntent. Spotlight, Shortcuts, Siri und Apple Intelligence teilen diesen Katalog. Sagt jemand „markiere diese Rechnung als bezahlt“, muss das System die Äußerung auf Ihr MarkInvoicePaidIntent mappen — nicht das Modell in der UI herumtippen lassen.

Dokumentation:

App Intents

und

Aktionen an Siri und Apple Intelligence anbinden.

App Schemas bringen Siri die Kategorie bei

Ein gewöhnliches App Intent erscheint schon in Shortcuts. Damit Siri AI es in natürlicher Sprache aufruft, markieren Sie Intent, Entity und Enum mit einem assistant schema — photos.openAsset, notes.createNote und so weiter. Das Schema hat eine feste Parameterform. Xcode prüft die Übereinstimmung zur Compile-Zeit.

Das ist der größte Unterschied zum offenen Agent. Tool-Namen offener Agenten gehören Ihnen. Tool-Namen von Siri AI müssen in ein Domänenvokabular fallen, das Apple schon trainiert hat. Ein „kreativerer“ Aktionsname — das System wählt ihn vielleicht nie.

@AppIntent(schema: .finance.markInvoicePaid)
struct MarkInvoicePaidIntent: AppIntent {
    @Parameter var invoice: InvoiceEntity
    @Parameter var paidAt: Date

    func perform() async throws -> some IntentResult {
        try await InvoiceService.markPaid(
            id: invoice.id,
            paidAt: paidAt
        )
        return .result()
    }
}

In dem Snippet steht kein JSON. Siri übergibt typisierte Parameter. Die Facharbeit machen Sie in perform(). Brauchen Sie das Netz, kodiert der Domänenservice als Nächstes JSON.

Tests nicht bei Siri beginnen. Apple liefert AppIntentsTesting: Intent isoliert aufrufen, Parameter übergeben, Ergebnis asserten. Dann die Form in Shortcuts prüfen. Erst danach Siri den End-to-End-Pfad geben. Umgekehrt fühlt es sich an wie „das Modell spinnt“, obwohl das Schema nie passte.

Datenfluss einer appübergreifenden Aufgabe

Die Schichten an einer konkreten Anfrage aufreihen. Der Nutzer sieht in Nachrichten „Freitag gemeinsames Essen, du bringst Salat“, zeigt auf den Text und sagt zu Siri: in Notes legen, dann Salat und Olivenöl auf die Shopping-Liste.

1. 1
   Bildschirmkontext kommt ins System

   Über onscreen awareness weiß Siri, dass „dieses“ eine Nachricht ist. Ihre Views müssen an eine App Entity anbinden, damit das System die Referenz auflöst — nicht Pixel raten.

2. 2
   Das Modell plant und wählt nur

   Das Systemmodell teilt die Äußerung in zwei Schritte: eine Create-Aktion in Notes, eine Add-Item-Aktion in Shopping. Es bastelt keine URLs und schreibt kein SQL.

3. 3
   Parameter gegen das Schema füllen

   Titel, Datum und Eintragsnamen werden zu typisierten Werten. Fehlt ein Slot, fragt Siri nach. Der Vertrag dieses Schritts ist das assistant schema, nicht Ihr OpenAPI-Dokument.

4. 4
   Jede App führt perform() aus

   Notes und Shopping führen jeweils ihr eigenes Intent aus. HTTP-JSON erscheint nur, wenn die Arbeit auf einen Server muss.

5. 5
   Ergebnisse zurück zur Systemsitzung

   Siri baut die Antwort aus Intent-Ergebnissen. Appübergreifende Entity-Übergabe kann Transferable nutzen, statt ein ganzes JSON-Dokument ins Gespräch zu kippen.

Typische Fallen auf diesem Pfad: ein Intent, das alles macht; eine description so breit, dass das Modell bei jedem Request feuert; oder perform() gibt ein volles Bestell-JSON zurück und sprengt den Systemkontext. Besser eine Zusammenfassung zurückgeben. Details holt eine zweite Aktion per id.

Drei Rollen von JSON auf dieser Kette

Swift-Typen sind der Compile-Zeit-Vertrag. JSON ist der Laufzeitvertrag. Der Siri-Hop kann ganz ohne JSON auskommen. Verlässt die Aktion den Prozess — Backend, Datei, Test-Fixture, ein anderer Agent — muss die Form sprachunabhängiger Text werden.

JSON spielt mindestens drei Rollen. Vermischen Sie zwei davon, bekommen Sie „es parst, aber jedes Feld ist falsch“.

Schicht eins wird am leichtesten übersprungen. Xcodes App Intents Console druckt Aufrufe und Parameter. Sie müssen denselben Aufruf als JSON-Objekt schreiben, sonst hat das Debuggen kein Replay. Schicht zwei ist, wo Rechnung und Auth wirklich passieren. Schicht drei ist 2026 schon üblich: dasselbe markPaid bedient Siri und einen internen Claude-Agent.

JSON Schema ersetzt App Schema nicht. App Schema ist der Domänenvertrag für das Systemmodell. JSON Schema ist der Datenvertrag für Backend, Tests und externe Modelle. Felder sollten ausgerichtet sein. Stellen Sie sich nicht vor, Siri lese Ihre OpenAPI-Datei. Warum die KI-Seite diesen Vertrag überhaupt braucht:

Warum braucht KI JSON Schema?

Was mit Function Calling / MCP zu vergleichen ist

Vergleichen Sie eine Sache: in welches Format die Entscheidung serialisiert wird.

Bei einem offenen Agent liefert die Modell-API JSON: den gewählten Tool-Namen plus arguments, die zu parameters passen. Die Runtime prüft, dann führt aus. MCP legt dieselbe Form auf inputSchema / structuredContent. Details:

Warum brauchen AI Agents JSON Schema? Tool Calling bis Structured Output erklärt.

{
  "type": "function",
  "function": {
    "name": "mark_invoice_paid",
    "description": "Mark one invoice as paid.",
    "parameters": {
      "type": "object",
      "required": ["invoice_id", "paid_at"],
      "properties": {
        "invoice_id": { "type": "string" },
        "paid_at": { "type": "string", "format": "date-time" },
        "amount_cents": { "type": "integer", "minimum": 0 },
        "currency": { "type": "string", "enum": ["USD", "CNY", "EUR"] }
      },
      "additionalProperties": false
    }
  }
}

Siri AI hat dieses JSON nicht. Das Äquivalent ist @AppIntent(schema:) plus @Parameter. Das Modell „wählt eine Aktion, füllt Slots“ weiterhin. Nur das Serialisierungsformat wurde zum typisierten Systemaufruf.

Packen Sie ein App Intent also nicht in eine weitere Schicht „lass Siri JSON ausgeben“. Extra-Prompts machen das System nicht stabiler; sie nehmen dem Debug-Pfad die Typprüfung. Die Stabilität, die Sie wollen, passiert nach perform(): Kann das Objekt, das der Domänenservice empfangen hat, verlustfrei in das arguments-Objekt oben kodiert werden?

Die Wahl ist konkret. Nutzer schon auf Apple-Geräten, Aktionen passen in einen Systemkatalog: Siri AI. Aktionen für Android, Web oder einen internen Slack-Bot: Function Calling plus MCP. Zeichnen Sie die zwei Ketten nicht als ein „Universal-Agent“-Diagramm, nur um zu sagen, Sie hätten einen Agent.

Wie das JSON an Ihrer HTTP-API aussieht

Soll das Intent das Netz direkt treffen? Kurze Aktionen können in perform() fertig werden. Sobald Auth, Pagination oder Idempotenz dazukommen, macht perform() nur „Parameter prüfen + Domänenservice aufrufen“; der Service sendet den JSON-Request.

Unten die Payload, wenn „Rechnung als bezahlt markieren“ das Backend trifft. Feldnamen sind typisch für ein internes Abrechnungssystem. Die Zahlen sind Beispiele, keine echte Bank-API.

{
  "action": "invoices.markPaid",
  "source": "siri-ai",
  "idempotency_key": "inv_1842:paid:2026-09-09",
  "arguments": {
    "invoice_id": "inv_1842",
    "paid_at": "2026-09-09T02:14:00Z",
    "currency": "USD",
    "amount_cents": 12800
  }
}

Mit diesem Objekt beantworten Sie drei Fragen: wer ausgelöst hat, ob Replay möglich ist, ob das Geld stimmt. Fehlt idempotency_key, markiert ein Siri-Retry die Rechnung zweimal als bezahlt. Wird amount_cents zum String, driftet jeder Report danach.

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["action", "source", "idempotency_key", "arguments"],
  "properties": {
    "action": { "const": "invoices.markPaid" },
    "source": { "type": "string", "enum": ["siri-ai", "shortcuts", "app"] },
    "idempotency_key": { "type": "string", "minLength": 8 },
    "arguments": {
      "type": "object",
      "required": ["invoice_id", "paid_at"],
      "properties": {
        "invoice_id": { "type": "string", "minLength": 1 },
        "paid_at": { "type": "string", "format": "date-time" },
        "amount_cents": { "type": "integer", "minimum": 0 },
        "currency": { "type": "string", "enum": ["USD", "CNY", "EUR"] }
      },
      "additionalProperties": false
    }
  },
  "additionalProperties": false
}

Der System-Agent braucht Ihren REST-Pfad nicht. Er braucht Intent-Erfolg oder -Fehler. Sie brauchen den Pfad, weil Audit und Retries in der API-Schicht liegen. Intent-Parameter als Feldmenge entwerfen, die sich als JSON-Objekt schreiben lässt — dann wird der Adapter für den offenen Agent deutlich billiger.

Action-Parameter in JSONNote prüfen

Der langsame Teil ist selten das Swift-Makro. Es sind zwei Aufrufe, deren JSON nicht passt: Siri hat ein Extrafeld beim Retry, Shortcuts hat ein Enum verloren, ein interner Agent hat amount_cents als 128.00 geschrieben. JSONNote bleibt im Browser lokal:

1. 1
   Zuerst einen Aufruf formatieren

   Das Objekt aus der App Intents Console oder den Backend-Logs in JSON formatieren einfügen und Einrückungs- sowie Syntaxrauschen entfernen.

2. 2
   Pflichtfelder mit einem Schema festnageln

   Den Entwurf auf der JSON Schema-Seite einfügen und prüfen, ob action, idempotency_key und invoice_id noch da sind.

3. 3
   Einen Siri-Aufruf mit einem Aufruf des offenen Agent vergleichen

   Mit JSON Diff sehen, ob source von siri-ai auf mcp gewechselt hat und ob arguments gedriftet sind.

4. 4
   Nur teilen, wenn ein Kollege es braucht

   Mit Hash-Teilen ein Sample (niemals Geheimnisse) ins URL-Fragment legen. Der Server empfängt diese Daten nicht.

FAQ

Ist Siri AI ein AI Agent?

Es ist ein System-Agent, kein offener Agent. Es wählt Aktionen, füllt Parameter und kettet Abläufe appübergreifend — aber der Werkzeugkatalog ist durch App Intents und App Schemas festgenagelt. Das Modell erfindet keine APIs.

Sind App Actions und App Intents dasselbe?

Nicht ein Produktname. App Actions ist die Nutzer- und Systemseite: was Siri mit einer App tun kann. Entwickler liefern App Intents und richten sie an einem App Schema aus, damit Siri die Aktionskategorie erkennt.

Ruft Siri meine REST-API direkt auf?

Nein. Siri ruft nur Intents auf, die Sie deklariert haben. In perform() machen Sie selbst HTTP. Der System-Agent will Erfolg- oder Fehler-Semantik; Rechnung, Auth und Retries liegen in Ihrer API-Schicht.

Apple nutzt Swift-Typen. Warum trotzdem JSON Schema?

Swift-Typen gelten zur Compile-Zeit. Verlässt die Aktion den Prozess — Backend, Logs, Test-Replay, Wiederverwendung durch einen externen Agent — muss die Form sprachunabhängiges JSON werden. Das Schema prüft diesen Hop, nicht den Siri-Hop.

Siri AI nutzen oder selbst einen Function-Calling-Agent bauen?

Nutzer schon auf dem iPhone, Aktion passt in einen Systemkatalog: Siri AI. Aktion muss Clouds, Plattformen oder die eigene Modellwahl überqueren: Function Calling plus MCP. Dieselben Domänenfunktionen können beide Ketten bedienen; nur die Adapterschicht wechselt.

Fazit

Siri AI wird zum Agent — zum Agent im Betriebssystem, nicht zu einer offenen Runtime, an die Sie beliebig Tools hängen.

Apple Intelligence liefert das Modell. App Actions (App Intents + App Schemas) liefern orchestrierbare Aktionen. JSON ist der Vertrag, nachdem diese Aktionen das Gerät verlassen.

Intent-Parameter als Felder entwerfen, die sich als JSON-Objekt schreiben lassen, dann dasselbe Schema an die Siri-Kette und die Function-Calling-Kette hängen. Modelle und Systemeingänge werden sich weiter ändern. Validierung ist der Graben vom Demo zur Produktion — dieses JSON lokal in JSONNote formatieren, prüfen und vergleichen. Nichts muss hochgeladen werden.

← Zurück zum Blog