How Claude Joins the Apple Ecosystem via Foundation Models

What the package does

ClaudeForFoundationModels

is an official Anthropic Swift Package that implements the Apple LanguageModel protocol, allowing Claude to be used as a server‑side language‑model provider inside the Foundation Models framework.

System requirements

iOS 27 / macOS 27 / visionOS 27 / watchOS 27 (all beta)

Xcode 27 Beta

Anthropic API key (development)

These OS versions are beta and are expected to ship later this year.

Installation

Two ways:

dependencies: [
  .package(url: "https://github.com/anthropics/ClaudeForFoundationModels.git", from: "0.1.0")
]

or add the package via Xcode → File → Add Package Dependencies → paste the repository URL.

Quick start (5 lines)

import FoundationModels
import ClaudeForFoundationModels

let model = ClaudeLanguageModel(
  name: .sonnet4_6,
  auth: .apiKey(ProcessInfo.processInfo.environment["ANTHROPIC_API_KEY"] ?? "")
)
let session = LanguageModelSession(model: model)
let response = try await session.respond(to: "Plan a 4‑day trip to Buenos Aires.")
print(response.content)

The same LanguageModelSession API works for local models; swapping the model instance changes the backend with zero architectural changes.

Model selection

Use the ClaudeModel enum to pick a model:

ClaudeLanguageModel(name: .opus4_8, auth: auth)   // Opus 4.8
ClaudeLanguageModel(name: .sonnet4_6, auth: auth) // Sonnet 4.6

Enum values map directly to Anthropic model IDs (e.g., .opus4_8 → claude‑opus‑4‑8). New models appear via package updates; experimental models can be declared manually with custom capabilities.

Effort level – fine‑grained control of inference depth

Specify a fixed effort level:

ClaudeLanguageModel(name: .opus4_8, auth: auth, fixedEffort: .xhigh)

Five levels are available: low, medium, high, xhigh, max. The Apple framework’s built‑in reasoning levels map to low, medium, and high; higher levels require explicit fixedEffort.

When to use Claude vs. a local model

Fast response, privacy‑sensitive – use a local model (zero latency, data never leaves the device).

Large context window – use Claude (local models have limited context).

Complex reasoning – use Claude (state‑of‑the‑art inference).

Need online search or code execution – use Claude (server‑side tools support web search, fetch, and code execution).

Offline scenario – use a local model (no network required).

Because both backends share the same LanguageModelSession API, switching is as simple as changing the model: parameter, enabling dynamic fallback when Claude is rate‑limited.

Authentication

Development – use the API key directly:

ClaudeLanguageModel(name: .sonnet4_6, auth: .apiKey("YOUR_API_KEY"))

Production – route requests through a self‑hosted proxy that injects the x‑api‑key header, keeping the secret out of the binary:

ClaudeLanguageModel(
  name: .sonnet4_6,
  auth: .proxied(headers: ["X-App-Token": "..."]),
  baseURL: URL(string: "https://my‑proxy.example.com")!
)

Embedding the raw key in a released app is insecure.

Streaming responses

let stream = session.streamResponse(to: "Summarize today's top science stories.")
for try await partial in stream {
  print(partial.content)
}

Each partial is a cumulative snapshot, not an incremental delta.

Structured output

Annotate a Swift struct with @Generable to receive typed data:

@Generable
struct Trip {
  @Guide(description: "Destination city") var destination: String
  @Guide(description: "Length in days") var days: Int
}
let response = try await session.respond(to: "Plan a trip to Tokyo.", generating: Trip.self)
print(response.content.destination) // "Tokyo"

This provides strong‑type safety and eliminates manual JSON parsing.

Server tools

Configure Anthropic server‑side tools such as web search, web fetch, and code execution:

let model = ClaudeLanguageModel(
  name: .sonnet4_6,
  auth: auth,
  serverTools: [
    .webSearch(maxUses: 5),
    .codeExecution
  ]
)

Client‑side tools are listed under tools:, while serverTools: run on Anthropic’s infrastructure. Both support domain filtering and usage limits.

Error handling

do {
  let response = try await session.respond(to: prompt)
  print(response.content)
} catch ClaudeError.missingCredential {
  // Prompt user for API key
} catch let error as LanguageModelError {
  // Handle .contextSizeExceeded, .rateLimited, .timeout, etc.
} catch {
  // Network or transport errors
}

Claude‑specific errors map to LanguageModelError cases such as .contextSizeExceeded, .rateLimited, and .timeout. A common pattern is to fall back to a local model when .rateLimited occurs.

Current limitations (Beta)

Prompt‑caching control (TTL and breakpoints are not exposed)

Stop sequences

Batch API

Files API

Token counting

Beta‑only headers

The SDK only exposes capabilities defined by the Apple Foundation Models protocol; features outside that contract are unavailable.

Conclusion

ClaudeForFoundationModels

is a deliberately minimal SDK that makes Claude a first‑class language‑model provider inside Apple’s Foundation Models framework. For iOS/macOS developers this means zero learning curve, seamless mixing of local and cloud models, full Swift type safety with async/await, and production‑ready authentication options. Although the package is still in beta (OS 27 has not shipped), the API design is mature and worth watching for anyone building AI‑powered Apple‑platform apps.