Does Agent-Native Support iOS and Android? Complete Cross-Platform Guide

Yes, Agent-Native fully supports both iOS and Android through a dedicated mobile-app package built with Expo and React Native that compiles to native binaries for each platform.

BuilderIO/agent-native extends beyond web browsers to mobile devices through a complete mobile-app package located in packages/mobile-app/. This Expo-based project enables you to ship production-ready iOS and Android applications using the same agent-native runtime, actions, and state synchronization as the desktop and web versions.

How Agent-Native Delivers iOS and Android Support

The Expo-Based Mobile Architecture

Agent-Native's mobile implementation is configured as a standard Expo project using React Native. According to packages/mobile-app/package.json, the app declares standard Expo dependencies and uses Metro as the JavaScript bundler via packages/mobile-app/metro.config.js. This architecture allows the same codebase to target multiple native platforms without platform-specific branching.

Native Compilation Targets

The mobile package compiles to true native binaries rather than hybrid wrappers:

• iOS: Generates an .ipa bundle ready for Apple certificates and App Store distribution
• Android: Produces .apk or .aab files via Gradle builds for Google Play submission

Both targets share the screen hierarchy located in packages/mobile-app/app/, which includes routes like (tabs)/chat.tsx and (tabs)/calendar.tsx. All screens use the shared useActionQuery and useActionMutation hooks, ensuring agent-native actions execute identically across platforms.

Running the Mobile App Locally

To start development on physical devices or emulators, use the Expo CLI from the mobile package directory:

# Install dependencies from repository root

pnpm install

# Start the web dev server (required for the mobile WebView)

pnpm dev

# In a separate terminal, launch the mobile app

cd packages/mobile-app
pnpm start  # Equivalent to expo start

From the Expo developer menu, scan the QR code with the Expo Go app on your physical device, or press i to launch the iOS simulator and a for the Android emulator.

Building Production Apps for iOS and Android

When ready to ship production binaries, Expo's build commands create signed native applications:

# Build for iOS (requires Apple Developer account)

cd packages/mobile-app
expo build:ios

# Build for Android (requires keystore or Google Play credentials)

expo build:android

The resulting binaries embed the shared agent-native runtime from packages/core and include all actions, skills, and SQL-backed state synchronization available in the web version.

Mobile-Specific Features and Native APIs

Push Notification Registration

The mobile app includes native push notification support through the useRemotePushRegistration hook. Found in packages/mobile-app/lib/use-remote-push-registration.ts, this abstraction handles iOS/Android permission requests and forwards device tokens to the backend via the remote-sessions-api endpoint.

import { useRemotePushRegistration } from '@/mobile-app/lib/use-remote-push-registration';

function PushSetup() {
  const { register, status } = useRemotePushRegistration();

  useEffect(() => {
    if (status === 'granted') register();
  }, [status]);

  return null;
}

WebView Integration for Shared UI

Rather than duplicating UI code, the mobile app loads the web interface inside a native WebView component. The AppWebView component in packages/mobile-app/components/AppWebView.tsx uses the getAppUrl utility to resolve the correct endpoint and renders the same Agent-Native web app inside native shells.

import { WebView } from 'react-native-webview';
import { getAppUrl } from '@/mobile-app/lib/get-app-url';

export default function AppWebView() {
  const url = getAppUrl(); // Returns http://localhost:3000 (dev) or production URL
  return <WebView source={{ uri: url }} />;
}

This approach ensures that components using useActionQuery and useActionMutation hooks call agent-native actions identically to the web version, maintaining complete feature parity across platforms while supporting native navigation components like SafeAreaView.

Key Source Files in the Mobile Package

Understanding the mobile architecture requires familiarity with these specific files:

• packages/mobile-app/package.json – Declares Expo dependencies and build scripts
• packages/mobile-app/metro.config.js – Metro bundler configuration for React Native
• packages/mobile-app/app/ – Screen hierarchy and navigation tabs including (tabs)/chat.tsx
• packages/mobile-app/lib/use-remote-push-registration.ts – Push notification abstraction for iOS/Android
• packages/mobile-app/components/AppWebView.tsx – WebView wrapper that loads the shared web UI
• packages/mobile-app/CHANGELOG.md – Release history and platform-specific notes

Summary

• Agent-Native supports both iOS and Android through the packages/mobile-app Expo project
• Single codebase compiles to native .ipa and .apk/.aab binaries using Expo's build pipeline
• Shared runtime with packages/core ensures actions, skills, and state sync work identically across web and mobile
• Native features like push notifications are available via the useRemotePushRegistration hook
• WebView integration allows the mobile app to reuse the web UI while maintaining native shell capabilities and navigation

Frequently Asked Questions

Does Agent-Native require separate codebases for mobile and web?

No. Agent-Native uses a unified architecture where the packages/core runtime is shared between all platforms. The mobile app in packages/mobile-app consumes the same actions and state logic as the web version, loading the UI through a WebView component while adding native-only features like push notifications through platform-specific hooks.

Can I use native iOS/Android features like push notifications?

Yes. The mobile package includes the useRemotePushRegistration hook in packages/mobile-app/lib/use-remote-push-registration.ts, which abstracts platform-specific permission dialogs and device token registration for both iOS and Android. This allows you to implement push notifications without writing separate native code for each platform.

Is the mobile app just a wrapper around the web UI?

Partially. The AppWebView component in packages/mobile-app/components/AppWebView.tsx loads the web interface inside a native WebView, ensuring immediate feature parity with the web version. However, the output is a true native binary with access to device APIs, native navigation components, and platform-specific optimizations compiled via Expo's build pipeline.

What build tools are required to compile for iOS and Android?

You need the Expo CLI and platform-specific credentials. For iOS, an Apple Developer account is required to sign .ipa files. For Android, you need a keystore or Google Play credentials to generate .aab or .apk files. The build commands expo build:ios and expo build:android in packages/mobile-app/ handle the native compilation automatically through Expo's cloud build service or local Gradle/Xcode toolchains.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}