Adding React Native AI features: upgrade first, then decide where the model runs

A product owner asks whether the app can summarize a long thread for the user. Before anyone picks a model, your mobile team has two things to settle: whether your React Native version can carry the work, and where the model should run.

This guide walks through adding React Native AI features in the order that avoids rework. Upgrade the app first. Put a backend in front of any model provider. Choose cloud or on-device for each feature, then get through store review and test on real phones. It's written for product owners, CTOs and mobile leads who already run a production app.

Before you start

The first item usually takes the longest, so check it before anything else.

• React Native 0.83 or later on the New Architecture (or Expo SDK 55+), if you want to run models on the device with React Native ExecuTorch.
• A server you control to hold model provider keys. It can be small.
• Real test devices, including the oldest phone you support. React Native ExecuTorch needs iOS 17+ and Android 13+.
• An Expo development build instead of Expo Go for any library that ships native code.

Step 1: Get the app onto the New Architecture

Start here, because the AI libraries already assume it. React Native ExecuTorch requires the New Architecture and React Native 0.83+ (or Expo SDK 55+). Reanimated is the same: its 4.x docs say it "works only with the React Native New Architecture," and many community libraries are following.

If you're behind, don't jump straight to the latest release. The 0.82 release post advises moving to React Native 0.81 or Expo SDK 54 first, the last versions that allowed the legacy architecture. Turn the New Architecture on there, test, and only then upgrade further. On Expo, npx expo-doctor checks your dependencies against React Native Directory, which is the fastest way to find the library that will block you.

There's no flag to hide behind anymore. React Native 0.82 ignores newArchEnabled=false on Android and RCT_NEW_ARCH_ENABLED=0 on iOS. 0.84 then stopped including legacy architecture code in iOS builds by default, which cuts build time and app size. On Expo, new projects have started on the New Architecture since SDK 52, and SDK 54 was the last version where you could disable it. Expo reports that about 83% of SDK 54 projects built with EAS Build used the New Architecture as of January 2026.

If your app still runs on the legacy architecture, our React Native development team would begin with a dependency audit and the 0.81 hop, before any AI code gets written.

What the New Architecture changes

Work on it started in 2018 as a ground-up rewrite. The old asynchronous "bridge" is gone. JavaScript and native code now call each other directly through the JavaScript Interface (JSI), with a new renderer, a new native module system and a defined event loop.

For your users, two effects matter. Components can read layout synchronously in useLayoutEffect, so they measure and position elements in the same frame, before anything visibly jumps. React's concurrent features, such as Suspense and Transitions, also arrive, so a newer state update can interrupt a slower one instead of waiting in line. Both help when an AI answer is streaming into a screen the user is still scrolling.

What's new in React Native, 0.76 to 0.88

The team ships a new minor version about every 2 months and maintains the latest 3 minor lines, per the release schedule. With 0.88 out on October 19, 2026, the 0.85 line moved to unsupported. The milestones below come from the official React Native blog.

Expo users get there through the Expo SDK 58 release (October 15, 2026), which moves projects from React Native 0.86 to 0.88.

Hermes V1 became the default JavaScript engine on both platforms in 0.84. The team describes better execution speed and lower memory use but publishes no benchmark numbers, so measure on your own app. If you already ran Hermes, nothing in your config changes. Precompiled iOS binaries, also default since 0.84, mean a clean build no longer compiles React Native core from source. React itself moved from 19 in 0.78 to 19.3.0 in 0.88, and since 0.78 the React Compiler only needs installing plus its Babel plugin to memoize components for you.

One item belongs on your iOS roadmap now. The 0.88 post warns that Apple requires the UIScene lifecycle from the iOS 27 SDK, and UIKit apps built with Xcode 27 "will fail to launch" without it. React Native 0.88 adds SceneDelegate support for that reason.

The rest is smaller but real. Since 0.87, types come straight from React Native's source, and deep imports into internal paths are a type error, with a temporary opt-out that lasts through 0.88. Version 0.86 fixed layout on Android 15+, where the OS enforces edge-to-edge even if you didn't ask for it. React Native also officially came to Meta Quest in February 2026.

The React Native roadmap after 0.88

There's no single long-range roadmap document. The direction shows up in release posts and the published schedule, and it's consistent.

The schedule lists 0.89 with a branch cut on November 3, 2026 and a planned release on December 7, 2026. Cleanup continues: 0.88 keeps the legacy event path behind an internal flag "expected to be removed" in a follow-up, and the legacy TypeScript types go in the release after 0.88. Web-style EventTarget events, DOM node APIs and stable Web Performance APIs all push React Native code toward behaving like web React.

The bigger change for the future of React Native is governance. React and React Native moved to the React Foundation, part of the Linux Foundation, announced on October 7, 2025. Its board includes Amazon, Callstack, Expo, Meta, Microsoft, Software Mansion and Vercel, and in 0.86 the repository moved from the facebook GitHub organization to react. So when a buyer asks whether React Native is going away, the answer is that it no longer depends on one company's priorities. Activity backs that up: the npm registry logged about 9 million downloads of react-native in the week of October 12–18, 2026. CI builds count too, so treat that as a sign of activity rather than a user count.

The tooling is moving toward AI as well. Expo made its MCP server available on every plan, including Free, in May 2026, so a coding assistant can work directly with your Expo project. Agents handle scaffolding and upgrade chores well, but they still need a reviewer who knows what the New Architecture changed.

Step 2: Put a backend between the app and any model provider

Do this before the first prototype ships, not after. Your app sends the request over HTTPS to your server. The server holds the API key, calls the model provider and streams the answer back.

The key never goes in the app. Google's Gemini API key guidance is blunt. "Do not hardcode API keys directly in web or mobile apps," it says. Keys in client code, it warns, "can be extracted by users," so anything inside the app bundle is effectively public. The same proxy gives you one place to add auth, rate limits, logging and cost caps.

Three well-documented ways to build it on React Native:

• Vercel AI SDK with Expo. The AI SDK Expo guide (Expo 52 or later) puts the model call in an Expo API route on the server. The app uses the useChat hook with expo/fetch to stream tokens into the UI.
• Your own endpoint plus expo/fetch. Expo's fetch API is WinterCG-compliant and reads a streaming response body chunk by chunk, which is what you need to show an answer as it's written.
• Firebase AI Logic. On Google's stack, @react-native-firebase/ai brings Firebase AI Logic to React Native. Firebase's docs say its proxy and App Check integration keep your Gemini API key "on the server."

Step 3: Decide where each React Native AI feature runs

Typical features are summaries, OCR on a photographed receipt or shipping label, semantic search over a user's notes, voice transcription and describing a photo the user just took. Each one lands in one of three places: a cloud model behind your backend, the model built into the phone's OS, or an open model you ship inside the app. Decide per feature, not per app. Many apps end up using two.

Model sizes come from Software Mansion's Llama 3.2 exports on Hugging Face, checked October 2026.

On-device inference skips the network round trip, so response time doesn't depend on signal strength. It also keeps data on the phone, which shortens the conversation with your own legal and security reviewers. Those two facts make it tempting to put everything on the device. Resist that.

A 1B–3B model is good at short, bounded jobs, not a 40-page contract. Apple's model needs an Apple Intelligence device, and Gemini Nano runs on a published list of mostly recent flagships. If your field team carries 4-year-old Android phones, the feature simply won't exist for them. A 1.08 GB download on first launch will also hurt activation where mobile data is expensive. And a model you ship is a model you maintain, test and re-release whenever a better one is worth switching to.

The cloud has its own costs. Token spend grows with every active user, latency depends on the network, and every request sends data off the device.

In practice, a hybrid split works well for many apps: the OS model handles quick, private tasks when the phone supports it, and your backend handles the rest. Firebase AI Logic's docs describe this pattern, with on-device inference that falls back to the cloud. For a first feature, summaries of content the user already has are a good candidate for the OS model.

Calling the model built into iOS or Android

Both platforms now ship a language model you can call without a download.

Apple's Foundation Models framework (iOS 26 and later) gives apps the on-device model behind Apple Intelligence, with structured output and tool calling. Apple's 2025 technical report describes an "approximately 3-billion-parameter model," with inference "free of cost." The current docs also cover Private Cloud Compute for tasks that need more reasoning.

On Android, Google's ML Kit GenAI APIs run Gemini Nano through AICore, a system service. They cover summarization, proofreading, rewriting, image description, speech recognition and a general prompt API. Google says input, inference and output data stay on the device. Most of these APIs are still beta, device support is limited, and inference only runs while your app is in the foreground.

Both are native APIs, so you reach them through a native module. Write a thin one yourself, or use Callstack's @react-native-ai/apple for Apple's models. It plugs into the Vercel AI SDK, so streamText and generateText work with local models. That keeps one code shape whether a request goes to Apple's model on the device or to a cloud model through your server.

Shipping your own model in the app

Bundle or download an open model when you need the same model on every device, offline use or a custom fine-tune.

• React Native ExecuTorch. Software Mansion's library runs models on PyTorch's ExecuTorch runtime, which Meta says powers on-device features in Instagram, WhatsApp, Facebook and Messenger. It covers LLMs, Whisper speech-to-text, text-to-speech, computer vision and embeddings. Hardware backends (XNNPACK on CPU, Core ML on Apple silicon, Vulkan on Android GPUs) tune performance for each chip. You can also load your own model exported to the .pte format.
• llama.rn. A React Native binding of llama.cpp for GGUF models, under active development in October 2026.
• MLC. Callstack's @react-native-ai/mlc runs open models through the MLC LLM runtime. Its docs note iOS devices need "sufficient memory (1-8GB depending on model)."
• Classic ML models. For classification, detection or OCR, react-native-fast-tflite runs TensorFlow Lite models with GPU delegates. Microsoft publishes onnxruntime-react-native for ONNX models.

This excerpt from the React Native ExecuTorch README (version 0.10.x, October 2026) loads a small model and streams each token to a callback:

// Excerpt from the react-native-executorch README (v0.10.x)
import { models, useLLMChatSession } from 'react-native-executorch';

const session = useLLMChatSession(models.llm.LFM2_5_1_2B.DEFAULT);

const turn = await session.sendMessage(
  'Explain on-device AI in one sentence.',
  (token) => console.log(token)
);

Install it with its peer dependencies, react-native-worklets and react-native-blob-util, and check the compatibility table before you pin versions.

Step 4: Stream the answer into the UI

Users judge an AI feature on its first second, not its last. Stream tokens into the UI as they arrive instead of waiting for the full answer. Both expo/fetch and the ExecuTorch token callback make that straightforward.

What separates a demo from a shipped feature is the unglamorous detail. Give people a cancel control that aborts the request or the generation. Show download progress for on-device models, which can run to gigabytes; the ExecuTorch hook exposes a downloadProgress value for this. Plan for errors with a clear message and a retry, never a spinner that doesn't end. And make sure Markdown that arrives half-finished can't break your layout or re-render the whole list on every token.

Step 5: Clear App Store and Google Play review

Both stores have rules that touch AI directly, and both are easy to miss until review.

• Apple, guideline 5.1.2(i). The App Store Review Guidelines (last updated October 16, 2026) spell it out. You "must clearly disclose where personal data will be shared with third parties, including with third-party AI," and get explicit permission first. A cloud LLM counts.
• Apple, guideline 1.2. The user-generated content rules explicitly include "AI content creation apps," so plan for moderation and reporting.
• Google Play. The AI-Generated Content policy says apps that generate content with AI "must contain in-app user reporting or flagging features." Google's policy explainer lists banned outputs, from deepfakes to malicious code.

Write the disclosure before you build the feature. Update the privacy text and consent flow first, and add in-app reporting if the feature generates content.

Step 6: Measure on real devices

Your test phone is not your user's phone. Mobile hardware varies far more than servers do, and sustained inference works the processor hard enough to drain the battery and heat the device. Test on the lowest-end device you support, not the newest one on your desk.

From day one, track time to first token, completion rate and cost per active user. Those three numbers tell you whether to keep a feature on the device, move it to the cloud or drop it.

Troubleshooting common problems

Once you've picked the first feature and its pattern, our generative AI engineers can build the backend proxy and model layer behind it while your mobile team owns the UI.

FAQ

Is React Native still relevant in 2026?

Yes. React Native shipped 6 minor releases between October 2025 and October 2026, and it now sits under the React Foundation with backers including Amazon, Meta, Microsoft and Expo. The npm registry recorded about 9 million weekly downloads in mid-October 2026.

Does React Native have a built-in AI module?

No. The framework doesn't ship an AI module of its own. You add AI through libraries such as the Vercel AI SDK for cloud models, Callstack's @react-native-ai packages for Apple's on-device models, or React Native ExecuTorch for open models.

Should I use Expo or the React Native CLI for an AI app?

Either works. Expo gives you API routes for a backend, expo/fetch for streaming and the Vercel AI SDK quickstart. On-device libraries such as React Native ExecuTorch need an Expo development build, because Expo Go doesn't include their native code.

Related reading

Databricks Cost Optimization: 10 Tips From a Partner's Playbook to Stop Burning DBUsOctober 20, 2026 · 8 min readBeyond the Add-to-Cart Button: A Builder's Guide to Commerce Agents on ClaudeOctober 12, 2026 · 8 min readWhy Enterprises Need Databricks Consulting Partners to Navigate the Agentic AI EraOctober 12, 2026 · 8 min read