Skip to main content
Architecture

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.

Inductivee Intelligence Team· AI EngineeringNovember 16, 202611 min read
TL;DR

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)

AspectCore ML / Core AI (Apple)LiteRT, incl. LiteRT-LM (Google)Gemini Nano via ML Kit GenAI (Google)
What it isFrameworks that run models you supply on Apple siliconInference engine that runs models you supply, across platformsA 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
PlatformsApple platforms onlyAndroid, iOS, web, desktop, IoTAndroid devices on Google's supported list
Documented minimumCore ML from iOS 11.0; Core AI listed as introduced in 27.0Android SDK 24; iOS 15.0 deployment targetSupported-device list; model version varies by device
Documented maturity notesCore AI is new; Core ML remains the route for non-neural model typesiOS runtime distribution pre-release; LiteRT-LM called production-ready on Apple platformsPrompt API and task APIs in beta (structured output labelled Alpha), no SLA or deprecation policy
LLM routeCore AI; or Apple's Foundation Models framework for the system modelLiteRT-LM with open-weight modelsGemini 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

python
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.

Warning

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.

Frequently Asked Questions

Is TensorFlow Lite still supported?

Google's current documentation describes the TensorFlow Lite Interpreter API as "formerly TensorFlow Lite" and says it remains available for backward compatibility inside LiteRT, which is Google's on-device inference engine. For new work, Google recommends LiteRT's CompiledModel API in the 2.x release, and for large language models its LiteRT-LM layer. There is a migration guide for existing TensorFlow Lite users. Check the current page before planning a migration.

Is Core ML deprecated?

Not according to Apple's documentation as we read it on 16 November 2026. The Core ML page still describes the framework and directs apps that use the latest model architectures to Core AI, and the Core AI page directs apps with other model types, such as decision trees or tabular feature engineering, to Core ML. Core AI is listed as introduced in version 27.0 of Apple's operating systems, so check which OS versions you must support.

What is Gemini Nano, and do I ship it in my app?

Gemini Nano is Google's on-device foundation model. You do not ship it: it runs in Android's AICore system service, which manages the model and its updates. You call it through ML Kit's GenAI APIs on devices Google lists as supported, and the model version differs by device.

Can an on-device model run in the background or without limits?

Not on Gemini Nano through ML Kit GenAI. Google's documentation says inference is allowed only when the app is the top foreground application and that AICore enforces per-app quotas. If your feature needs background or bulk processing, plan for a model you control or a cloud fallback.

Should I use the system model or my own model?

Use the system model for standard tasks it already covers, when the supported-device list fits your audience and you can accept the platform's quota, foreground and version rules. Use your own model when you need control over behaviour, consistent offline behaviour across all supported devices, or a task the system model does not cover. Many products use both, with a cloud fallback.

Written By

Inductivee Intelligence Team — AI Engineering at Inductivee Intelligence

Inductivee Intelligence Team

Author

Agentic 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.

Agentic AI ArchitectureMulti-Agent OrchestrationLangChainLangGraphCrewAIMicrosoft Agent Framework
LinkedIn profile

Inductivee Intelligence is a remote-first agentic AI engineering studio. Our engineering content is written by active practitioners and technically reviewed before publication.

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