What is Apple Intelligence and how can it be used in my app?

Apple Intelligence is Apple's on-device AI framework introduced in iOS 18.1, combining large language model capabilities with on-device privacy. Developers access it through the Foundation Models framework (for language tasks) and the core Apple Intelligence features (summarization, writing tools, etc.). The Foundation Models framework allows apps to run language model inference entirely on-device — no API calls, no data sent to external servers. Integration requires iOS 18.1+ and a device with an A17 Pro chip or Apple Silicon.

What is the difference between Core ML and Apple Foundation Models?

Core ML is Apple's universal on-device ML inference framework — it runs .mlmodel packages covering classification, detection, regression, and any custom model exported via coremltools. Apple Foundation Models is a newer, higher-level API specifically for language generation tasks — it provides access to Apple-hosted language models running entirely on-device. The right choice depends on the use case: structured prediction tasks use Core ML; language generation, summarization, and text tasks use Foundation Models. Many apps benefit from both.

Will AI features slow down the app?

On-device inference performance depends heavily on implementation choices: compute unit selection (ANE vs GPU vs CPU), model quantization, async dispatch patterns, and whether inference blocks the main thread. The integration sprint includes a performance profiling phase specifically to address latency and memory. Most Core ML models run faster than users expect — the A-series Neural Engine is optimized for this workload. Streaming inference via AsyncStream provides a responsive UX even for longer generation tasks.

Does this work for apps that already have a backend?

Yes. On-device AI can run alongside a cloud backend. A common pattern is to use on-device inference for latency-sensitive or privacy-sensitive tasks (e.g., semantic search, content classification, offline features) while the backend handles synchronization and other tasks. The integration defines a clear boundary between what happens on-device and what can be sent to a server.

Is this the right service for a new app that doesn't have AI yet?

The On-Device AI Integration sprint is designed for existing apps adding AI features. If you are building a new app that needs AI from day one, the Apple Platform MVP Sprint is the correct starting point — it includes AI integration as an in-scope option within the full architecture and implementation sprint.

AI Integration · 3–5 Weeks

On-Device AI Integration

Add production-grade AI to your existing iOS or iPadOS app using Core ML, Apple Foundation Models, or both. No cloud dependency. No data leaving the device. AI that works offline and respects user privacy.

Timeline

3–5 weeks

Platform

iOS 18.1+ · iPadOS

Frameworks

Core ML · Foundation Models

Investment

From €5,400

Add AI to your app →Full service details

Official Reference Stack

This service is scoped against Core ML, Foundation Models, and Apple's App Privacy Details requirements. Apple provides the APIs and privacy rules; the engagement turns those documents into a working feature inside your existing architecture.

What's included

Every engagement produces a production-ready AI feature — not a proof of concept. The sprint covers the full path from use-case definition through performance-validated production code.

AI use-case definition

A focused workshop to identify the right AI use case for your product — which tasks benefit from on-device inference, what the privacy boundary is, and which Apple framework to use.

Model strategy (local vs hybrid)

Selecting the correct approach: Core ML with .mlmodel, Apple Foundation Models (iOS 18.1+ language tasks), Create ML for custom training, or a hybrid strategy. The decision is driven by latency, accuracy, iOS version requirements, and offline requirements.

SwiftUI integration

AI inference wired into your existing architecture without violating layer boundaries. SwiftUI components built for AI results, including streaming output via AsyncStream, loading states, and graceful fallback for unsupported devices.

Performance and memory optimization

Instruments profiling of on-device inference. Compute unit selection (ANE vs GPU vs CPU). Model quantization where appropriate. Memory footprint reduction to stay within iOS background limits.

Privacy-first implementation

All inference runs entirely on-device. No model data, user input, or inference output is transmitted to external servers. Implementation is checked against Apple's App Privacy Details requirements, privacy nutrition labels, and GDPR obligations.

Production-ready AI feature

The sprint ends with a working AI feature, tested on real hardware across target iOS versions, with no regressions in the existing app. Delivered to your repository — no lingering dependency on this engagement.

How it works

Week 1

Use-case definition and model strategy

Audit your existing app architecture, define the AI use case, select the framework, and design the data flow. Output: a written technical spec before any implementation starts.

Week 2–3

Model integration and SwiftUI binding

Core ML or Foundation Models integrated into the existing architecture. SwiftUI components built. Swift Concurrency patterns applied for non-blocking inference.

Week 4–5

Performance, memory, and production validation

Instruments profiling, compute unit optimization, memory optimization. Privacy validation. Final testing across target iOS versions. Code delivered to your repository.

Who this is for

Good fit

✓Existing iOS apps adding an AI feature
✓Privacy-first products that cannot use cloud inference
✓Teams adopting Apple Foundation Models (iOS 18.1+)
✓Apps needing offline AI capabilities

Not a fit

—Greenfield apps without an existing codebase
—'Let's experiment with AI' without a defined use case
—Backend AI (server-side ML, cloud LLM wrappers)

Common questions

What is Apple Foundation Models and can my app use it?↓

Apple Foundation Models is a framework introduced in iOS 18.1 that lets apps run language model inference entirely on-device — no API calls, no data sent to servers. See developer.apple.com/documentation/foundationmodels. Access requires a device with A17 Pro or Apple Silicon and iOS/iPadOS 18.1+. For apps targeting iOS 17 or older devices, Core ML (developer.apple.com/documentation/coreml) is the correct path for AI features.

Core ML or Foundation Models — which is right for my use case?↓

Core ML handles structured prediction: image classification, object detection, tabular data, custom .mlmodel exports. Foundation Models handles language generation, summarization, text classification, and other natural language tasks on iOS 18.1+. Many apps use both. The use-case definition phase of the sprint determines the correct framework before implementation begins.

Will adding AI slow down my existing app?↓

On-device inference runs on the Neural Engine separately from the main CPU and GPU — when implemented correctly, it does not degrade app responsiveness. The sprint includes a performance phase specifically to validate inference latency and memory footprint, and to apply any necessary optimizations.

This is for an existing app — can we integrate AI without breaking anything?↓

Yes. The integration is designed around your existing architecture, not against it. The first week is spent auditing the codebase to identify integration points that don't require restructuring existing code. AI features are added as new layers, not invasive rewrites.

Related case study

OffGrid AI — Local inference with streaming output

How llama.cpp and a custom Swift streaming layer delivered full offline AI inference on iOS — with zero cloud dependency.

Other services

iOS Architecture Audit

Deep review of an existing iOS codebase · from €1,440

SwiftUI MVP Development Sprint

Build a new iOS app from scratch · from €8,400

Ready to add on-device AI to your app?

Apply with a description of your existing app and the AI capability you want to add. No commitment — applications are reviewed and scoped within 48 hours.

Apply for AI Integration See case study →