On-Device AI for Mobile Apps: Core ML and Core AI, LiteRT (Formerly TensorFlow Lite) and Gemini Nano
Core ML, TensorFlow Lite and Gemini Nano are not three versions of the same thing, and one of those names has changed while a second Apple framework now sits beside Core ML. Here is what each one is according to Apple's and Google's own documentation as of 16 November 2026, what each requires, and how to decide between shipping your own model and using the one the operating system provides.
If you search for "Core ML vs TensorFlow Lite vs Gemini Nano", you are comparing three different kinds of thing, and the landscape has moved: one of those names has changed and Apple has added a second framework beside Core ML. As of 16 November 2026: Google's documentation describes the TensorFlow Lite Interpreter API as "formerly TensorFlow Lite" and presents LiteRT as its on-device inference engine; Apple's Core ML page now points apps that use the latest model architectures to a newer framework called Core AI, which Apple's documentation lists as introduced in iOS 27, while Core ML stays the framework for other model types; and Gemini Nano is not a runtime you ship at all but a model that Android's AICore system service supplies on supported devices. Everything below is taken from Apple's and Google's own documentation, dated, and the comparison of what to choose is our own engineering opinion.
Three Different Kinds of Thing
The first design question is not "which library" but "whose model". Core ML, Core AI and LiteRT are frameworks that run a model that you supply, on the device's CPU, GPU or neural hardware. Gemini Nano, and on Apple platforms the Foundation Models framework, are models that the operating system supplies, which your app calls through an API. The two approaches have very different consequences for app size, update cycle, quality control and device reach, and most real products end up using a mix.
- Bring your own model (Core ML or Core AI, LiteRT): you choose or train the model, convert it, ship or download it, and own its quality. It works across the devices the runtime supports. You carry the size, the updates and the evaluation.
- Use the system model (Gemini Nano through AICore, Apple's Foundation Models framework): there is no model to ship or update, because the OS manages it. In exchange you accept the capabilities, the device list and the version differences the platform gives you.
What Each Platform Documents
Source dates are in the Sources section. Apple's documentation pages do not carry a "last updated" date, so we cite them as read on 16 November 2026.
Apple: Core ML
Core ML integrates machine-learning models into an app, running them on the device with the CPU, GPU and Neural Engine and minimising memory and power use. Models can be built with Create ML or converted from other libraries with Core ML Tools, and Core ML can retrain or fine-tune a model on the device with the person's data. The documentation lists availability from iOS 11.0. Running strictly on the device removes the need for a network connection, which Apple notes helps keep data private and the app responsive.
Apple: Core AI
Core AI is described as a framework to build, run and deploy AI models on Apple silicon using the latest model architectures and inference techniques across the CPU, GPU and Neural Engine, with a Swift API, model specialisation and caching controls, and tooling to convert models into the .aimodel format and compile them ahead of time with the coreai-build command-line tool. Apple's documentation lists it as introduced in version 27.0 of its operating systems. Apple's Core ML page directs apps using the latest architectures to Core AI, and Core AI's page directs apps using other model types, such as decision trees or tabular feature engineering, to Core ML.
Apple: Foundation Models framework
The system-model option. The documentation describes access to the on-device and Private Cloud Compute models designed for Apple Intelligence, for text generation tasks such as summarisation, entity extraction, text and image understanding and refinement, with guided generation of Swift types and tool calling. It lists availability from iOS 26.0 and says people need a device that supports Apple Intelligence. For more reasoning and context size, Apple points to Private Cloud Compute or a server model.
Google: LiteRT
LiteRT is described as Google's on-device inference engine for deploying ML and generative AI models on edge platforms. The latest 2.x release introduces the CompiledModel API, recommended for developers seeking the best performance, while the Interpreter API (formerly TensorFlow Lite) remains available for backward compatibility. Models use the .tflite FlatBuffers format. The documentation lists a minimum Android SDK of 24 and an iOS deployment target of iOS 15.0. It states that the LiteRT runtime's iOS distribution is still pre-release, with Swift Package Manager support in progress, and that on Apple platforms today LiteRT-LM is the production-ready option.
Google: LiteRT-LM
LiteRT-LM is described as the production-ready orchestration layer for running large language models with LiteRT, across Android, iOS, web, desktop and IoT, with GPU and NPU acceleration and function-calling support for agentic workflows. Its documentation names open-weight model families such as Gemma, Llama, Phi-4 and Qwen as supported.
Google: Gemini Nano via ML Kit GenAI and AICore
Gemini Nano runs in Android's AICore system service, which manages the model and its updates. ML Kit's GenAI APIs sit on top, offering direct model access (a GenerativeModel class for custom prompts, with text or multimodal input and typed structured output, which Google's navigation labels Alpha), an agentic AgentRunner, and task-specific APIs for summarisation, proofreading, rewriting, image description and more. The direct model access (Prompt) API and the task-specific APIs we opened (summarisation, proofreading, rewriting and image description) are each offered in beta, and Google's pages state they are not subject to any SLA or deprecation policy, so changes may break backward compatibility.
At a Glance (Vendor Documentation, as of 16 November 2026)
| Aspect | Core ML / Core AI (Apple) | LiteRT, incl. LiteRT-LM (Google) | Gemini Nano via ML Kit GenAI (Google) |
|---|---|---|---|
| What it is | Frameworks that run models you supply on Apple silicon | Inference engine that runs models you supply, across platforms | A system-provided model on supported Android devices, called via an API |
| You ship the model? | Yes (or download it) | Yes (or download it) | No; AICore manages and updates it |
| Platforms | Apple platforms only | Android, iOS, web, desktop, IoT | Android devices on Google's supported list |
| Documented minimum | Core ML from iOS 11.0; Core AI listed as introduced in 27.0 | Android SDK 24; iOS 15.0 deployment target | Supported-device list; model version varies by device |
| Documented maturity notes | Core AI is new; Core ML remains the route for non-neural model types | iOS runtime distribution pre-release; LiteRT-LM called production-ready on Apple platforms | Prompt API and task APIs in beta (structured output labelled Alpha), no SLA or deprecation policy |
| LLM route | Core AI; or Apple's Foundation Models framework for the system model | LiteRT-LM with open-weight models | Gemini Nano itself |
The Constraints That Shape the Design
Device reach is a list, not a version number. Google's ML Kit GenAI overview describes support for direct model access and the task APIs as a list of specific devices, and notes that Gemini Nano versions differ by device (the page distinguishes Gemini Nano 2, 3 and 4), with availability depending on the device's RAM configuration, OS version and AICore update status. Apple's Foundation Models framework likewise requires a device that supports Apple Intelligence. In both cases, a feature built on the system model will not exist on every device your users own.
The same prompt can behave differently. Google's page warns that different versions of Gemini Nano may return different output from the same prompt, and tells developers to evaluate prompt quality across versions. That makes a per-device-class evaluation set part of the work, not an optional extra. Our agent evaluation framework applies.
The platform meters you. AICore enforces an inference quota per app: too many requests in a short period return a busy error, and exceeding a longer-duration quota (for example a daily one) can return a battery-use quota error. Google also states that GenAI API inference is permitted only when the app is the top foreground application; use from the background, including from a foreground service, returns an error. A feature that wants to summarise in the background, or run bulk processing, does not fit this model.
Local models are bounded. Google's own Gemini Nano documentation says the model has on-device constraints such as token limits, device hardware limits and model capability boundaries, and recommends hybrid inference, for example the Firebase AI Logic Hybrid API, to fall back to cloud models when Gemini Nano is unavailable. Apple's Foundation Models page makes the same trade explicit by pointing to Private Cloud Compute or a server model for more reasoning and context size. The design conclusion is the same on both platforms: build a capability ladder (on-device where available, cloud where not) and make the feature degrade gracefully.
A Capability Ladder, Sketched
def summarise(text: str, ctx) -> Result:
if ctx.user_allows_local and device_can_run_local("summarise"):
try:
return run_local_model("summarise", text) # system model or a bundled model
except LocalUnavailable: # quota, busy, background, version
pass # fall through to the next rung
if ctx.data_may_leave_device and ctx.online:
return run_cloud_model("summarise", text) # server model
return Result.unavailable("This feature is not available on this device right now.")Illustrative pseudocode only, not a platform API. device_can_run_local and the runners stand for platform-specific checks (for example, whether the system model is available on this device) and calls. The point is the structure: local first where it exists, cloud fallback, and a defined behaviour when neither is allowed.
We have deliberately left out model-size, memory and latency numbers. The pages we opened do not give comparable limits across the three options: they vary by device, model version and configuration, and Google's LiteRT documentation publishes latency and throughput tables only for specific named devices and specific models, which do not generalise to your model or your users' phones. Treat any benchmark as something to measure on your own target devices with your own model. Also treat the maturity flags above as a moving target. Beta APIs without a deprecation policy, a pre-release iOS runtime distribution and a framework Apple lists as new in iOS 27 are all reasons to isolate the platform call behind your own interface, so you can change the implementation without rewriting the feature.
How to Choose
- Start from the feature, not the library. Is it a standard task a system model already covers (summarise, rewrite, proofread, describe an image), or does it need your own model (a domain classifier, a custom vision model, an embedding model)?
- Use the system model for standard tasks when the device list fits your audience, and accept the quota, foreground and version rules, as well as Google's beta label on the ML Kit task APIs. Use your own model when you need control over behaviour, offline use on every supported device, or a task the system model does not cover.
- Pick the runtime by platform reach. Apple-only: Core ML for non-neural model types, Core AI for models using the latest architectures. Cross-platform or Android: LiteRT, with LiteRT-LM for language models. Check the pre-release notes for the platform you ship on.
- Plan the fallback before the feature. Decide what happens on unsupported devices, over quota, offline and in the background, and whether data is allowed to go to a cloud model at all.
- Evaluate per device class, because output can differ between model versions and between devices.
- Put the platform behind your own interface, so the beta and pre-release parts can change without touching the feature.
How Inductivee Intelligence Approaches This
This section is a design position, not a description of a client engagement. We do not publish client case studies; see our transparency page. For AI-native mobile engineering, our default is to decide the capability ladder first (what runs locally, what falls back to the cloud, what the feature does when neither is available), to wrap the platform runtime behind an interface of our own, and to evaluate on the device classes the audience actually uses. Where self-hosting a model is part of the picture, our open-weight deployment guide and cost optimisation guide cover the server side of the same trade-offs.
Sources (as of 16 November 2026)
Each page was opened on 16 November 2026. Where the page shows a last-updated date, it is given. Apple's documentation pages were read from Apple's published documentation data and carry no last-updated date. These pages change often, so check the current page before relying on a version number, a device list or a maturity flag.
- Android Developers, Gemini Nano (last updated 29 October 2026)
- Google for Developers, Overview of the ML Kit GenAI APIs (last updated 10 November 2026)
- Google for Developers, Send custom requests with Gemini Nano direct model access (last updated 27 October 2026)
- Google for Developers, GenAI Summarization API (last updated 9 November 2026)
- Google for Developers, GenAI Proofreading API (last updated 9 November 2026)
- Google for Developers, GenAI Rewriting API (last updated 9 November 2026)
- Google for Developers, GenAI Image Description API (last updated 9 November 2026)
- Google AI Edge, Getting started with LiteRT (last updated 13 October 2026)
- Google AI Edge, LiteRT-LM Overview (last updated 6 October 2026)
- Apple Developer Documentation, Core ML
- Apple Developer Documentation, Core AI
- Apple Developer Documentation, Foundation Models
Frequently Asked Questions
Is TensorFlow Lite still supported?
Is Core ML deprecated?
What is Gemini Nano, and do I ship it in my app?
Can an on-device model run in the background or without limits?
Should I use the system model or my own model?
Written By
Inductivee Intelligence Team
AuthorAgentic AI Engineering Team
The Inductivee Intelligence engineering team — multi-agent orchestration, RAG pipeline architecture, and data liquidity engineering. Our writing is grounded in what we actually build, break, and operate in production.
Inductivee Intelligence is a remote-first agentic AI engineering studio. Our engineering content is written by active practitioners and technically reviewed before publication.
Engineer This With Inductivee Intelligence
The engineering patterns in this article are what our team builds into production every day. Explore the related service to see how we deliver this capability at enterprise scale.
Agentic Custom Software Engineering
We engineer autonomous agentic systems that orchestrate enterprise workflows and unlock the hidden liquidity of your proprietary data.
ServiceAutonomous Agentic SaaS
Agentic SaaS development and autonomous platform engineering — we build SaaS products whose core loop is powered by LangGraph and CrewAI agents that execute workflows, not just manage them.
Related Articles
Llama 3.1 in the Enterprise: Self-Hosted LLM Deployment Architecture
LLM Cost Optimization in Production: Semantic Caching, Batching, and Smart Model Routing
How to Test Autonomous Agents: Evaluation Frameworks for Production Reliability
Ready to Build This Into Your Enterprise?
Inductivee Intelligence engineers agentic systems, RAG pipelines, and enterprise data liquidity solutions. Let's scope your project.
Start a Project