Блог • AI / Agent

Siri AI станет AI Agent? Apple Intelligence, App Actions, API и как работает JSON

Услышав Siri AI, легко представить Agent вроде ChatGPT: сам выбирает инструменты, сам склеивает API. Apple на WWDC 2026 выпустила не это.

Siri AI становится системным Agent: понимает личный контекст, видит экран, выполняет App Actions между App. Это не открытый Agent. Модель не выдумает REST-пути и не запишет произвольный JSON на ваш сервер.

В этой статье:

• Какой слой у Apple Intelligence, какой у Siri AI
• Чему App Actions соответствуют у разработчика (App Intents + App Schemas)
• Как текут данные в одной задаче между App
• На каком переходе есть JSON, на каком нет
• Как это сопоставить с Function Calling / MCP Agent и как проверить параметры действия в JSONNote

Сначала ответ: системный Agent, не открытый

Слово Agent уже стёрли. Кто-то имеет в виду «болтливого помощника», кто-то — runtime, который крутит инструменты, пока дело не сделано. Siri AI ближе ко второму, но откуда берутся инструменты — совсем не как у открытого Agent.

Открытый Agent (ChatGPT, Claude, свой Runtime) обычно так: модель читает диалог, из списка tools выбирает name и arguments, Runtime исполняет, результат возвращает в диалог. Каталог пишете вы. JSON Schema — контракт входа. MCP часто отвечает за обнаружение и выполнение. Другая статья на сайте разводит эти четыре слоя:

Стек AI Agent 2026: как сочетать LLM, MCP, Function Calling и JSON Schema?

Цикл Siri AI живёт в системе. Пользователь говорит Siri или указывает на «это» на экране. Системная модель (на устройстве или Private Cloud Compute) понимает намерение и выбирает из каталога действий установленных App. Ваш App не хозяин сессии — только маршрутизируемая возможность.

Поэтому ответ не «да» или «нет». Siri AI планирует, заполняет слоты и делает последовательную работу между App — это уже поведение Agent. Он не станет открытым runtime, куда вы по желанию вешаете MCP Server. Обе цепочки касаются App, API и JSON, но кто владеет сессией и кто генерирует параметры — разное.

Чем Apple Intelligence отличается от Siri AI

Сначала разведите имена продуктов. Смешаете — App Actions и JSON некуда посадить.

Apple Intelligence — платформа: генеративные модели в системных возможностях iPhone, iPad и Mac. Письмо, изображения, сводки уведомлений, Visual Intelligence и часть вывода, который должен покинуть устройство, висят на этом слое. Запросы вне устройства идут через Private Cloud Compute, не в обычные логи публичного облака. Официальный вход:

Apple Intelligence.

Siri AI — новое поколение Siri с WWDC в июне 2026, на следующем поколении Apple Intelligence. Формулировка Apple: лучше диалог, личный контекст, знания о мире, восприятие экрана и больше App Actions по системе. Плюс отдельное приложение Siri, чтобы пересматривать диалоги между устройствами. Пресс-релиз:

Apple представляет Siri AI.

Тесты для разработчиков начались в день WWDC: iOS 27, iPadOS 27, macOS 27, visionOS 27. На начало сентября 2026 это ещё бета осенних систем (в конце августа вышла iOS 27 developer beta 8). На момент статьи не считайте это готовой функцией, включённой у всех пользователей по умолчанию.

Есть третья цепочка, не смешивайте её с Siri: ваш App сам поднимает сессию Foundation Models. Тогда модель бежит в вашем процессе, инструменты внедряете вы, система не выберет «какой App открыть». Описание фреймворка:

Foundation Models.

WWDC 2026 также добавила Gemini как опциональную внешнюю foundation-модель рядом с прежним ChatGPT. Для пользователя это ещё один выход за знаниями о мире. Для разработчика контракт App Actions почти не меняется: внешняя модель всё равно не тронет Intent, который вы не объявили.

App Actions: как Siri вызывает ваш App

Пользователь слышит App Actions: что Siri может сделать с этим App. Разработчик поставляет App Intents. Чтобы Siri AI оркестрировал действие, его ещё нужно выровнять по App Schema (assistant schema) — иначе предобученная системная модель не узнает класс действия.

На WWDC26 Apple говорит прямо: Siri стала сильнее благодаря Apple Intelligence; способ разработчика участвовать в Apple Intelligence — App Intents. Сессия

Build intelligent Siri experiences with App Schemas

сводит возможности Siri к трём вещам: доступ к вашим сущностям, выполнение действий через Intent, понимание контекста экрана.

App Intents — каталог возможностей

Для системного Agent App — не «открыть и посмотреть», а каталог обнаруживаемых возможностей. Через AppIntent вы объявляете имена действий, описания на естественном языке, типы параметров и результаты. Spotlight, Shortcuts, Siri и Apple Intelligence делят этот каталог. Когда кто-то говорит «отметить этот счёт оплаченным», система должна сопоставить фразу с вашим MarkInvoicePaidIntent, а не дать модели тыкать по интерфейсу.

Документация:

App Intents

и

Подключить actions к Siri и Apple Intelligence.

App Schemas учат Siri категории

Обычный App Intent уже может появиться в Shortcuts. Чтобы Siri AI вызывал его естественным языком, Intent, Entity и Enum нужно пометить assistant schema — photos.openAsset, notes.createNote и так далее. У schema фиксированная форма параметров. Xcode проверяет совпадение на этапе компиляции.

В этом главный разрыв с открытым Agent. Имена инструментов открытого Agent вы придумываете сами; имена Siri AI должны попасть в предметный словарь, который Apple уже обучала. Более «креативное» имя действия система может просто не выбрать.

@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()
    }
}

В этом фрагменте нет JSON. Siri отдаёт типизированные параметры. Бизнес вы делаете в perform(). Если нужна сеть, доменный сервис затем кодирует JSON.

Не начинайте тесты с Siri. Apple даёт AppIntentsTesting: вызвать Intent в изоляции, передать параметры, проверить результат. Затем смотрите форму в Shortcuts. Только потом отдайте Siri путь end-to-end. Перевернёте порядок — покажется, что «модель творит чепуху», а schema просто не совпала.

Поток данных одной задачи между App

Соберите слои одним запросом. Пользователь видит в Сообщениях «пятница, ужин вскладчину, ты несёшь салат», указывает на текст и говорит Siri: запиши в Заметки, затем добавь салат-латук и оливковое масло в список покупок.

1. 1
   Контекст экрана входит в систему

   Через onscreen awareness Siri знает, что «это» — сообщение. Ваши view должны быть связаны с App Entity, иначе система не разрешит указание и модель будет гадать по пикселям.

2. 2
   Модель только планирует и выбирает

   Системная модель режет фразу на два шага: создать в Notes, добавить пункт в Shopping. Она не склеивает URL и не пишет SQL.

3. 3
   Заполнить параметры по Schema

   Заголовок, дата, имена пунктов становятся типизированными значениями. Если слот пуст, Siri спросит ещё раз. Контракт этого шага — assistant schema, не ваш документ OpenAPI.

4. 4
   Каждый App выполняет perform()

   Notes и Shopping каждый выполняют свой Intent. HTTP JSON появляется только если нужно синхронизировать с сервером.

5. 5
   Результат возвращается в системную сессию

   Siri собирает ответ из результатов Intent. Сущности между App можно передавать через Transferable, а не выливать весь JSON в диалог.

Типичные ямы на этой цепочке: Intent, который «делает всё»; слишком широкое description, и модель срабатывает на любой запрос; или perform() возвращает весь JSON заказа и раздувает системный контекст. Лучше вернуть сводку, детали взять вторым действием по id.

Три роли JSON на этой цепочке

Типы Swift — контракт компиляции, JSON — контракт выполнения. Переход Siri может быть без JSON. Как только действие выходит из текущего процесса — бэкенд, файл, тестовая фикстура, другой Agent — форма должна стать языконезависимым текстом.

JSON играет минимум три роли. Смешаете две — получите «парсится, но все поля неверны».

Первый слой чаще всего пропускают. App Intents Console в Xcode печатает вызовы и параметры. Тот же вызов нужно уметь записать JSON-объектом, иначе отладке нечего воспроизвести. Второй слой — где реально живут биллинг и auth. Третий уже обычен в 2026: один и тот же markPaid служит и Siri, и внутреннему Claude Agent.

JSON Schema не заменяет App Schema. App Schema — предметный контракт для системной модели; JSON Schema — контракт данных для бэкенда, тестов и внешних моделей. Поля должны совпадать. Не ждите, что Siri прочитает ваш файл OpenAPI. Почему стороне ИИ вообще нужен этот контракт, см.

Зачем ИИ нужен JSON Schema?

Что сравнивать с Function Calling / MCP

Сравнивайте одно: во что сериализуется решение.

У открытого Agent API модели возвращает JSON: выбранное имя инструмента плюс arguments, которые укладываются в parameters. Runtime проверяет, затем исполняет. MCP кладёт ту же форму на inputSchema / structuredContent. Подробности:

Зачем AI Agent нужен JSON Schema? От Tool Calling до Structured Output.

{
  "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 такого JSON нет. Эквивалент — @AppIntent(schema:) плюс @Parameter. Модель по-прежнему «выбирает действие, заполняет слоты». Поменялся только формат сериализации: типизированный системный вызов.

Поэтому не оборачивайте App Intent ещё одним слоем «пусть Siri выведет JSON». Лишний промпт систему не стабилизирует, только отберёт проверку типов у отладки. Стабильность нужна после perform(): объект, который получил доменный сервис, можно без потерь закодировать в тот arguments выше.

Выбор конкретный. Пользователь уже на устройствах Apple, действие укладывается в системный каталог — Siri AI. Действие нужно Android, вебу или внутреннему Slack-боту — Function Calling плюс MCP. Не рисуйте обе цепочки одной «универсальной Agent-схемой» только чтобы сказать, что у вас есть Agent.

Какой JSON приходит на HTTP API

Должен ли Intent сразу бить в сеть? Короткие действия можно закончить в perform(). Как только нужны auth, пагинация или идемпотентность, perform() делает только «проверить параметры + вызвать доменный сервис»; сервис отправляет JSON-запрос.

Ниже нагрузка, когда «отметить счёт оплаченным» доходит до бэкенда. Имена полей типичны для внутренней биллинг-системы. Цифры — пример, не реальный банковский 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
  }
}

С этим объектом вы отвечаете на три вопроса: кто инициировал, можно ли воспроизвести, сошлись ли деньги. Нет idempotency_key — один retry Siri отметит счёт дважды. amount_cents станет строкой — дальше поедут все отчёты.

{
  "$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
}

Системному Agent не нужен ваш REST-путь, ему нужен успех или неудача Intent. Путь нужен вам: аудит и retry живут на слое API. Спроектируйте параметры Intent как набор полей, который записывается JSON-объектом — и адаптер открытого Agent станет дешевле на целый слой.

Проверить параметры Action в JSONNote

Медленная часть редко в макросах Swift. Она в том, что JSON двух вызовов не сходится: Siri на retry добавила поле, Shortcuts потеряла enum, внутренний Agent записал amount_cents как 128.00. JSONNote работает локально в браузере:

1. 1
   Сначала отформатировать один вызов

   Вставьте объект из App Intents Console или бэкенд-логов в Формат JSON, уберите отступы и синтаксический шум.

2. 2
   Закрепить обязательные поля схемой

   Вставьте черновик на страницу JSON Schema и убедитесь, что action, idempotency_key, invoice_id ещё на месте.

3. 3
   Сравнить вызов Siri и открытого Agent

   Через JSON Diff посмотрите, сменился ли source с siri-ai на mcp и не поплыли ли arguments.

4. 4
   Делиться только когда коллеге нужно

   Через Hash-шаринг положите образец (никогда секреты) в URL fragment. На сервер эти данные не уходят.

FAQ

Siri AI — это AI Agent?

Это системный Agent, не открытый. Умеет выбирать действия между App, заполнять параметры и сшивать сценарии, но каталог инструментов зафиксирован App Intents и App Schemas. Модель не выдумает API.

App Actions и App Intents — одно и то же?

Не одно имя продукта. App Actions — формулировка для пользователя и системы: что Siri может сделать с App. Разработчик поставляет App Intents и выравнивает их по App Schema, иначе Siri не узнает этот класс действий.

Siri напрямую бьёт в мой REST API?

Нет. Siri вызывает только объявленный вами Intent. HTTP вы сами бьёте в perform(). Системному Agent нужна семантика успеха или неудачи; биллинг, auth и retry живут на вашем слое API.

Apple использует типы Swift. Зачем тогда JSON Schema?

Типы Swift закрывают compile time. Как только действие покидает процесс — бэкенд, логи, воспроизведение тестов, внешний Agent — форма должна стать языконезависимым JSON. Schema проверяет этот переход, не переход Siri.

Брать Siri AI или собирать свой Function Calling Agent?

Пользователь уже на iPhone, действие укладывается в системный каталог — Siri AI. Действие должно идти через облака, платформы или свою модель — Function Calling плюс MCP. Один набор доменных функций обслуживает обе цепочки; меняется только адаптер.

Итог

Siri AI станет Agent — но Agent внутри операционной системы, не открытый Runtime, куда вы по желанию вешаете инструменты.

Apple Intelligence даёт модель, App Actions (App Intents + App Schemas) дают оркестрируемые действия, JSON — контракт после того, как эти действия покинули устройство.

Сначала спроектируйте параметры Intent как поля, которые записываются JSON-объектом, затем повесьте одну Schema на цепочку Siri и на цепочку Function Calling. Модели и системные входы ещё изменятся. Слой проверки ведёт от демо к продакшену: этот JSON можно форматировать, проверять и сравнивать локально в JSONNote, без загрузки.

← Назад к блогу