Foundation Models no Private Cloud Compute

O Foundation Model no dispositivo ganhou um irmão. O iOS 27 dá ao framework um modelo em escala de servidor que roda no Private Cloud Compute, com uma janela de contexto de 32K e raciocínio, e você o alcança mudando uma única linha de código¹. A mesma LanguageModelSession, o mesmo Generable, o mesmo protocolo Tool⁴. O movimento maior está por baixo: a Apple abriu o framework para praticamente qualquer LLM por meio de um protocolo público, então o modelo no dispositivo, o modelo na nuvem, um modelo local que você distribui, um modelo open-source do Hugging Face e, em breve, Claude e Gemini, todos respondem à mesma API Swift². Você para de programar contra um modelo e começa a programar contra um slot que pode trocar.

Este post é a camada de nuvem e provedor sobre a referência do framework. Se você ainda não conhece a LanguageModelSession, o protocolo Tool ou a geração guiada, comece pelo explicativo do framework Foundation Models e pelo post sobre tool-calling no iOS 27, e depois volte aqui.

TL;DR

• O Private Cloud Compute traz um modelo de servidor maior para o framework Foundation Models, alternável ao mudar uma linha a partir do modelo no dispositivo. Ele oferece uma janela de contexto de 32K contra os 4K no dispositivo, suporta raciocínio em três níveis e roda a partir de iOS, macOS, visionOS e watchOS¹².
• A postura de privacidade corresponde à do modelo do sistema: a Apple projetou o PCC de modo que os dados do usuário nunca são armazenados e são usados apenas para a requisição, com verificação independente por pesquisadores, sem chaves de API, sem configuração de conta e sem custo de token para o desenvolvedor¹.
• Cada usuário recebe um limite diário de requisições contabilizado em sua conta do iCloud, ampliável por meio do iCloud+. Trate o limite na sua UI verificando o estado de cota do modelo e exibindo um controle persistente e acionável em vez de um alerta. Solicite acesso no site para desenvolvedores; disponível para apps com menos de 2M de downloads¹.
• O novo protocolo LanguageModel torna cada modelo intercambiável: System, PCC, Core AI para modelos locais na ANE, MLX para a comunidade do Hugging Face e, em breve, pacotes de provedores da Anthropic e do Google².
• O DynamicProfile permite que uma única sessão se mova entre esses modelos no meio de uma conversa, então um turno de brainstorming pode usar o PCC com temperatura alta e um turno de revisão pode cair para o modelo no dispositivo para economizar chamadas ao servidor³.

Um modelo maior, as mesmas três linhas

No ano passado o argumento era que solicitar ao modelo no dispositivo leva três linhas: criar uma sessão, chamar respond, ler a resposta¹. Este ano esse argumento se estende para a nuvem. O framework oferece uma API Swift unificada independentemente de qual modelo você conversa, então alternar do modelo System no dispositivo para o modelo PCC muda o modelo que você constrói e nada mais¹. A saída estruturada via Generable e o tool-calling se comportam de forma idêntica em ambos¹.

Louis na sessão 319: solicitar ao modelo no dispositivo leva três linhas, e alternar para o modelo de servidor PCC é uma mudança de uma linha para um modelo muito maior, com mais contexto e raciocínio.

O formato da troca, nos próprios termos do framework:

import FoundationModels

// On-device: the System model.
let onDevice = LanguageModelSession(model: SystemLanguageModel.default)

// Cloud: swap the model. Same session API, same prompts, same tools.
let cloud = LanguageModelSession(model: PrivateCloudComputeLanguageModel.default)

let summary = try await cloud.respond(to: "Summarize this 30-page contract.")

Os nomes dos símbolos vêm direto da sessão: a Apple expõe o modelo de nuvem como PrivateCloudComputeLanguageModel, e a sessão mostra o tamanho do contexto lido de uma propriedade contextSize tanto em SystemLanguageModel quanto em PrivateCloudComputeLanguageModel¹. Como o modelo de nuvem está em conformidade com o mesmo protocolo LanguageModel ao qual todos os outros modelos se conformam, o resto do seu código não percebe a diferença².

Uma restrição é herdada do modelo no dispositivo e merece uma verificação rigorosa: o PCC roda apenas em dispositivos que suportam o Apple Intelligence. Verifique a API de disponibilidade e trate o caso em que o Apple Intelligence está indisponível, da mesma forma que você já restringe o modelo no dispositivo¹.

O que o PCC oferece e quanto custa

O PCC é a resposta da Apple para os casos de uso que o modelo no dispositivo não consegue alcançar: assistentes que raciocinam sobre grandes entradas do usuário, ou recursos que disparam muitas chamadas de ferramentas com saídas grandes¹. A troca é concreta em vez de baseada em sensações, e a sessão a apresenta como um confronto direto.

Duas linhas carregam a maior parte da decisão. O salto de 4K para 32K é o que torna o recurso de “resumir um documento longo com imagens” viável no modelo de nuvem e apertado no modelo no dispositivo¹. O raciocínio é a outra: onde uma resposta simples lê o prompt e gera, uma resposta com raciocínio gera texto extra em um segmento separado da transcrição antes de responder¹. Os três níveis escalonam esse orçamento de pensamento. O leve reúne um pouco de contexto extra, o moderado raciocina mais a fundo e o profundo pode produzir um segmento de raciocínio mais longo que a própria resposta¹. Você define o nível ao chamar respond na sessão¹.

O raciocínio não é gratuito. O segmento de raciocínio é texto que o modelo gera, então ele consome tokens e conta contra o orçamento de contexto de 32K¹. A sessão é direta sobre a disciplina que isso exige: decida entre no dispositivo e PCC, e escolha o nível de raciocínio, a partir de dados em vez de sensações¹. A Apple lançou um novo framework de Evaluations no Xcode exatamente para isso, porque o modelo no dispositivo tem um desempenho melhor do que você espera em muitas tarefas, e a única forma de saber é medir¹.

A postura de privacidade é a manchete

Um modelo de servidor que lida com a entrada privada do usuário costuma ser onde a história de privacidade desmorona. O PCC é construído para que isso não aconteça. A Apple projetou o Private Cloud Compute com privacidade de ponta a ponta em mente, garantindo que os dados do usuário nunca sejam armazenados e sejam usados apenas para a requisição, e os pesquisadores verificaram o design de forma independente¹. O PCC já alimenta as próprias tarefas complexas do Apple Intelligence; o framework abre essa mesma infraestrutura para o seu app¹.

As consequências operacionais são a parte que os desenvolvedores sentem. O PCC é integrado ao sistema operacional junto com o iCloud, então não há autenticação para configurar, nem chaves de API para rotacionar, nem configuração de conta para pedir ao usuário¹. O usuário precisa de um dispositivo que suporte o Apple Intelligence e nada mais. Não há custos de token para você como desenvolvedor; cada usuário recebe um limite diário, e os usuários podem ampliá-lo por meio do iCloud+¹. O modelo está disponível para apps com menos de 2M de downloads, e você se inscreve no site para desenvolvedores¹.

Sessão 319 sobre as garantias de privacidade: sem configuração de conta, sem autenticação, sem chaves de API e sem custo de token para o desenvolvedor, com as requisições de cada usuário contabilizadas em sua conta do iCloud.

Atualização, 8 de junho de 2026: o PCC sai do Apple silicon

Na mesma semana em que a WWDC abriu, a Apple publicou um post de segurança que muda onde o PCC roda. O PCC agora se estende ao Google Cloud em GPUs NVIDIA para novas cargas de trabalho do Apple Intelligence, “estendendo nossos compromissos líderes do setor de privacidade do PCC para data centers de terceiros pela primeira vez”⁵. O framework que você visa não muda. A infraestrutura por baixo dele, sim.

A Apple mantém o contrato idêntico. Os cinco requisitos centrais permanecem exatamente como eram: “computação sem estado, garantias aplicáveis, sem acesso privilegiado em tempo de execução, não direcionabilidade e transparência verificável”⁵. O que muda é a implementação, que a Apple nomeia como “NVIDIA Confidential Computing com GPUs NVIDIA, CPUs Intel com TDX e o chip Titan do Google”⁵. A Apple reforça essa base para além de uma implantação padrão de computação confidencial de duas maneiras que os desenvolvedores devem notar. Ela mantém “um registro criptograficamente verificável e somente de adição de todo o hardware do Google Cloud que faz parte da frota PCC”, e para componentes que poderiam exfiltrar dados do usuário, “a atestação de software está ancorada em pelo menos duas raízes de confiança separadas de fornecedores independentes”⁵.

A frase que mais importa para a postura de privacidade é sobre controle. A Apple afirma que “a Apple mantém controle total sobre o software do PCC; os dispositivos Apple só confiarão em software do PCC que seja criptograficamente aprovado pela Apple”⁵. A história de verificação para os pesquisadores também é mantida: a Apple diz que publicará todos os binários para inspeção pública e fornecerá acesso a nós PCC ao vivo em modo de pesquisa por meio do Apple Security Bounty Program⁵. A implantação é faseada, “avançando em direção ao conjunto completo de proteções ao longo do período de prévia do verão”, então um recurso que você lança contra o PCC herda um conjunto móvel de garantias durante a prévia, em vez do conjunto final⁵.

A conclusão para o código deste post: as afirmações de privacidade acima valem para o modelo PCC, quer ele responda a partir do Apple silicon ou do Google Cloud, porque a Apple mantém os mesmos cinco requisitos e o mesmo portão de confiança do lado do dispositivo. O PCC também é a resposta de primeira parte da Apple onde modelos de terceiros não conseguem chegar, o que se combina com a resposta de primeira parte da Apple ao prompt injection da mesma semana.

Nota de laboratório: as garantias do PCC param na fronteira do framework

Um ponto sobre o qual os labs da WWDC foram diretos vale a pena trazer à tona ao lado dessa expansão, porque traça a linha que o marketing não traça. As garantias do PCC, computação sem estado, não direcionabilidade e armazenamento efêmero, não se estendem a modelos de terceiros que você alcança por meio do protocolo de modelo de linguagem do framework, como Gemini ou Claude. Quando sua sessão roteia para um pacote de provedor em vez do modelo System ou PCC, o desenvolvedor é responsável por ler os termos desse provedor e divulgar os fluxos de dados resultantes, inclusive nos rótulos nutricionais de privacidade da App Store⁶. O protocolo dá a você uma API Swift entre os modelos, mas não dá a você uma postura de privacidade única entre eles. Esse trabalho de divulgação recai sobre você, não sobre a Apple.

Lidando com o limite diário sem quebrar a UI

O limite diário é o único lugar em que um modelo de nuvem invade a UX, e a sessão tem opinião sobre como lidar com isso. As requisições contam contra a conta do iCloud do usuário, e uma requisição que excede o limite lança um erro¹. Exibir esse erro bruto na UI é a escolha errada, porque o erro não é acionável¹.

Em vez disso, verifique o estado de cota no modelo e renderize seu próprio controle. A sessão verifica isLimitReached no quotaUsage do modelo e, quando o limite é excedido, mostra um botão que permite ao usuário gerenciar ou ampliar seu limite¹. Duas regras regem a apresentação. Não use um alerta, porque o estado de limite deve persistir em vez de ser descartado; atualize o estado da sua UI, por exemplo desabilitando o botão de requisição e mostrando um rótulo sutil com uma ação de ampliação abaixo dele¹. E detecte também o caso de aproximação: o modelo expõe um estado belowLimit para que você possa avisar um usuário que está próximo, deixando-o decidir quais requisições valem a pena gastar¹.

// Sketch following the session's pattern.
let quota = PrivateCloudComputeLanguageModel.default.quotaUsage
if quota.isLimitReached {
    // Persistent label + upgrade button. No alert.
    showUpgradeAffordance()
} else if quota.belowLimit {
    // Optional: warn the user they are nearing the daily limit.
    showNearingLimitNotice()
}

O Xcode ajuda você a construir isso sem queimar cota real. Nas Debug Options do scheme, a configuração “Simulate Apple Foundation Models Availability” oferece “Quota Usage Limit Reached” e “Nearing Usage Limit”, então você pode exercitar ambos os estados de UI no simulador¹.

Traga seu próprio LLM: o protocolo de provedor

A mudança mais profunda no iOS 27 é que o Foundation Models deixou de ser um framework de modelo único. A Apple reconstruiu o modelo System no dispositivo e adicionou mais três opções de primeira parte, e então abriu a porta para todos os demais. O PCC traz o modelo de servidor com raciocínio e contexto de 32K. O Core AI roda modelos locais de forma eficiente no Apple Neural Engine. O MLX desbloqueia os milhares de modelos da comunidade MLX no Hugging Face por ID do modelo². E como tudo isso está sobre um novo protocolo público, provedores de fronteira podem distribuir seus próprios pacotes Swift; a Apple nomeou Anthropic e Google como trazendo Claude e Gemini para os desenvolvedores Swift por meio do mesmo framework².

Christopher Webb na sessão 339: além do modelo do sistema, o framework adiciona PCC, Core AI e MLX, e um protocolo público permite que provedores como Anthropic e Google o estendam com seus próprios pacotes Swift.

O protocolo tem duas partes, e a divisão é todo o design. O LanguageModel descreve o modelo para o framework: ele declara capacidades e devolve uma configuração. O LanguageModelExecutor é onde o trabalho acontece, com um inicializador que recebe essa configuração, um prewarm para carregar pesos ou abrir conexões antes da primeira requisição, e um respond que transmite a geração de volta para a sessão². A configuração é o elo entre as duas, e é a chave de busca. Cada sessão mantém um armazenamento de executores; quando um modelo produz uma configuração que o armazenamento ainda não viu, o framework constrói um executor e o coloca em cache, e a sessão descreve a configuração como Hashable, então um segundo modelo com a mesma configuração resolve para o mesmo executor². Esse cache é o que permite que uma integração com estado mantenha um cache KV ou uma conexão persistente entre chamadas, em vez de refazer o trabalho².

Para um provedor de modelo, o trabalho do executor é tradução. O framework lhe entrega uma transcrição, uma sequência de entradas tipadas, e o executor mapeia essas entradas para quaisquer papéis que o seu próprio motor de inferência fale². A Apple define seis tipos de entrada: instruções, prompts, chamadas de ferramentas, saídas de ferramentas, respostas e raciocínio². Um modelo apenas com papéis de sistema, usuário e assistente mapeia chamadas de ferramentas e raciocínio para o assistente; um modelo com um papel de ferramenta dedicado roteia para lá em vez disso². Cada requisição também carrega a intenção do desenvolvedor em dois conjuntos de propriedades: ContextOptions para o que entra no prompt, como o nível de raciocínio ou um esquema de resposta, e GenerationOptions para o loop do decodificador, como amostragem, temperatura e comprimento². Na saída, o executor transmite eventos por um canal, começando com uma atualização de metadados (IDs do modelo e da requisição) e uma atualização de uso (contagem de tokens do prompt) antes dos deltas de texto, então o desenvolvedor descobre o custo de uma requisição sem esperar pelo stream inteiro².

A história de erros importa para os desenvolvedores de apps mesmo que eles nunca escrevam um provedor. O Foundation Models inclui o LanguageModelError para os casos que todo modelo enfrenta: estouros da janela de contexto, limites de taxa, recusas e mais². Um provedor deve lançar um desses quando fizer sentido, porque qualquer usuário do framework já sabe como capturá-lo, e reservar tipos de erro personalizados para falhas que só seu próprio serviço produz, como um nível de assinatura ou estado de conta². Os provedores também ganham espaço para se diferenciar por meio de metadados de resposta personalizados (tokens por segundo, tempo até o primeiro token) e tipos de segmento personalizados que estendem o protocolo a novas modalidades como áudio ou vídeo, tudo fluindo pela mesma sessão². Os provedores de nuvem recebem um lembrete direto sobre credenciais: não receba uma chave de API como uma string simples; ofereça um provedor de token ou fluxo de login, persista os tokens no Keychain e combine isso com a atestação de dispositivo por meio do App Attest².

Implicações agênticas: roteie modelos dentro de uma sessão

O protocolo de provedor e o PCC valem a pena quando você para de pensar em um modelo por app e começa a pensar em um modelo por tarefa. É isso que o DynamicProfile permite. Ele deixa uma única LanguageModelSession alternar modelos no meio de uma conversa, selecionando a melhor configuração para a tarefa à sua frente³.

Erik e Oliver na sessão 242: um app de artesanato declara perfis que atuam como agentes, fazendo brainstorming no PCC com temperatura alta, planejando com raciocínio profundo e revisando no modelo no dispositivo para economizar chamadas ao servidor.

O exemplo da sessão é um app de artesanato com três fases. O brainstorming quer conhecimento amplo e criatividade, então seu perfil usa PrivateCloudComputeLanguageModel com a temperatura definida em 1³. O planejamento quer profundidade, então permanece no PCC e define o reasoningLevel como profundo³. A revisão é orientação rotineira enquanto o usuário trabalha, então cai para SystemLanguageModel para economizar chamadas desnecessárias ao servidor, o que também preserva a cota diária de PCC do usuário para o trabalho que precisa dela³. O corpo de um DynamicProfile é reavaliado a cada prompt, então conforme o app muda de modo a sessão muda de persona: trocando de chapéu, ou trocando de agente³.

Rotear entre modelos de tamanhos de contexto diferentes força uma disciplina que o framework apenas no dispositivo nunca exigiu. Mover dos 32K do PCC para os 4K no dispositivo pode exigir cortar entradas para caber, e a sessão também nomeia um uso de privacidade: redija informações privadas das entradas existentes ao mover para um modelo menos privado³. O historyTransform do framework aplica uma transformação local e não destrutiva antes de solicitar, então você corta para um modelo sem perder o contexto que o próximo turno pode precisar³. A mutação tem um custo: adicionar à transcrição preserva o cache KV e minimiza o tempo até o primeiro token, enquanto reescrever o histórico (remover entradas, mudar ferramentas, atualizar instruções) normalmente invalida o cache e adiciona latência³. No ano passado a API de sessão era somente de adição para garantir essa otimização; este ano a Apple tirou as rodinhas, e a única forma de conhecer o comportamento de cache de um modelo é medir com o Foundation Models Instrument no Xcode³.

Decisão: no dispositivo, PCC ou seu próprio provedor

As três opções não são uma escada. Cada uma é certa para um formato diferente de problema.

Recorra primeiro ao modelo System no dispositivo. Ele é gratuito, funciona offline, não tem limites de requisição, e a reconstrução do iOS 27 o tornou melhor em seguir instruções e adicionou entrada de imagem². Seu contexto de 4K é o verdadeiro teto¹. Avalie antes de supor que você precisa de mais, porque a sessão avisa que você ficará surpreso com o quão bem ele se desempenha¹.

Recorra ao Private Cloud Compute quando a tarefa exceder o modelo no dispositivo e os dados forem sensíveis. Documentos longos que precisam da janela de 32K, raciocínio em múltiplas etapas, ou muitas chamadas de ferramentas com saídas grandes¹. O PCC é a única opção de nuvem que mantém a postura de privacidade da Apple sem chaves, sem conta e sem custo de token, paga por um limite diário por usuário em torno do qual você projeta¹. Escolha-o quando você, de outra forma, montaria seu próprio modelo de servidor e temeria a revisão de privacidade.

Recorra ao seu próprio provedor quando você precisar de um modelo específico que a plataforma não fornece. Core AI para um modelo local que você empacota e roda na ANE, MLX para um modelo open-source por ID, ou um pacote de provedor (Claude, Gemini) para um modelo de fronteira². Você assume o tratamento de credenciais, a atestação e a divulgação de privacidade, e em troca ganha um modelo nomeado por trás da mesma LanguageModelSession que seu app já fala². A sessão é explícita ao dizer que os modelos no dispositivo e na nuvem têm características de privacidade muito diferentes, e o usuário merece saber qual deles está respondendo².

Misture-os em uma sessão quando as fases diferirem. Esse é o caso do DynamicProfile: PCC para os turnos pesados de criatividade ou raciocínio, o modelo no dispositivo para os rotineiros, cada perfil carregando seu próprio modelo, temperatura e nível de raciocínio³.

FAQ

Como faço para alternar do modelo no dispositivo para o Private Cloud Compute?

Mude o modelo que você passa para a LanguageModelSession. O framework oferece uma API Swift unificada entre os modelos, então mover do modelo System no dispositivo para o PrivateCloudComputeLanguageModel é uma mudança de uma linha, e seus prompts, a saída Generable e as ferramentas funcionam da mesma forma¹. O PCC roda apenas em dispositivos que suportam o Apple Intelligence, então mantenha sua verificação de disponibilidade¹.

O Private Cloud Compute é tão privado quanto o modelo no dispositivo?

A Apple projetou o PCC de modo que os dados do usuário nunca sejam armazenados e sejam usados apenas para a requisição, e o design foi verificado de forma independente por pesquisadores¹. Ele é integrado ao sistema operacional junto com o iCloud, então não há chaves de API, configuração de conta nem autenticação para você gerenciar¹. O modelo no dispositivo ainda vence em operação offline e requisições ilimitadas; o PCC vence em tamanho de contexto e raciocínio¹.

Quanto custa o PCC, e qual é o limite diário?

Não há custos de token para você como desenvolvedor¹. Cada usuário recebe um limite diário de requisições contabilizado em sua conta do iCloud, e os usuários podem ampliá-lo por meio do iCloud+ para um limite maior¹. Trate o limite na sua UI verificando o estado de cota do modelo (isLimitReached, belowLimit) e mostrando um controle de ampliação persistente e acionável em vez de um alerta¹. O modelo está disponível para apps com menos de 2M de downloads, e você se inscreve no site para desenvolvedores¹.

O que “traga seu próprio provedor de LLM” realmente significa?

A Apple adicionou um protocolo público LanguageModel, então qualquer modelo pode se conectar ao framework Foundation Models e ser chamado pela mesma API do próprio modelo da Apple². Além do modelo System e do PCC, o framework adiciona o Core AI para modelos locais na ANE e o MLX para modelos da comunidade do Hugging Face, e a Apple nomeou Anthropic e Google como distribuindo pacotes Swift para Claude e Gemini². Um provedor implementa o LanguageModel mais um LanguageModelExecutor que traduz a transcrição do framework para seu próprio formato e transmite a geração de volta².

Uma sessão pode usar mais de um modelo?

Sim. O DynamicProfile permite que uma única LanguageModelSession alterne modelos no meio de uma conversa, escolhendo a melhor configuração por tarefa³. Um perfil carrega seu próprio modelo, instruções, temperatura e nível de raciocínio, e o corpo do perfil é reavaliado a cada prompt, então uma sessão pode fazer brainstorming no PCC e revisar no modelo no dispositivo na mesma conversa³. Fique atento à diferença de tamanho de contexto entre os modelos e ao custo de cache KV de reescrever o histórico quando você fizer isso³.

O cluster completo do Apple Ecosystem: o explicativo do framework Foundation Models; os controles de tool-calling do iOS 27; a distinção de fluxo de trabalho agêntico; e o LLM no dispositivo. O hub é a Apple Ecosystem Series. Para um contexto mais amplo de iOS com agentes de IA, veja o guia de iOS Agent Development.