Some AI belongs on the device and some belongs in the cloud, and getting that call wrong is expensive either way. We build both, and we decide which is which. On-device inference with Apple's Foundation Models and Gemini Nano, hybrid routing when you need the bigger models, and EU AI Act obligations handled from sprint one.
Most "AI app development" means one thing in practice: your app sends text to somebody's API and waits. That works, and sometimes it's the right answer. But it also means every feature costs money per call, breaks without a connection, adds a network round trip to every interaction, and sends your users' data somewhere else.
We build the other kind too. Models that run on the device itself, where inference costs nothing after the download, the feature keeps working with no signal, and the user's data never leaves the handset.
Knowing which of those two a given feature needs is most of the job. Get it wrong and you either burn money on API calls for something the phone could do locally, or you promise offline intelligence that the hardware can't deliver. We've written more broadly about how AI has changed the way mobile apps are built.
Both platforms now ship a real on-device model, and the gap between them has closed.
On iOS, Apple's Foundation Models framework has been open to third-party developers since iOS 26 in September 2025. It gives you the same roughly 3-billion-parameter model that powers Apple Intelligence, through one Swift API, with no API key and no per-token cost. The context window is 8,192 tokens. That's small, and it shapes what you can sensibly ask the model to do. The model also ships with the operating system, so it adds nothing to your app bundle and there's no first-run download. Note that Core ML is no longer the answer for this work. Apple now positions Core AI as the framework for neural networks and keeps Core ML for classic non-neural models.
iOS 27, due around mid-September 2026, adds image input to that on-device model, along with Vision-backed OCR and barcode tools and a Spotlight-powered search tool that gives you genuinely local retrieval-augmented generation. For work the small model can't do, Private Cloud Compute offers a 32,000-token context with reasoning, and Apple has made it free to developers under two million first-time downloads. A new LanguageModel protocol lets you back the same session with Claude or Gemini instead.
On Android, Gemini Nano runs inside AICore, an operating system service, so the model isn't in your APK either. ML Kit's GenAI APIs cover summarisation, proofreading, rewriting and image description. Every one of those APIs is still Beta, and speech recognition is Alpha. Plenty of agency pages imply otherwise. They work well, we ship with them, and you should budget for API changes before they stabilise. If you need open weights instead, Gemma 4 arrived in April 2026 under Apache 2.0 and the small variants run offline on phones.
Every benchmark you'll read quotes peak throughput. Peak throughput is a state the phone holds for a few seconds.
Sustained-load testing published in June 2026 ran a 4-bit quantised 1.5B model on flagship hardware. An iPhone 16 Pro started at 23.67 tokens per second and lost around 40% of that within three consecutive iterations. A Galaxy S24 Ultra settled at 10.38 tokens per second after the thermal governor dropped the GPU from 680 MHz to 231 MHz once it hit 78.3°C. Twenty iterations cost 5 to 7% of battery.
This is what clients discover in week six, after the demo went well. On-device AI is also a device-tier feature: plenty of handsets your users own can't run it at all, and those need a real fallback rather than an error state. We design for the twentieth inference on a mid-range Android, not the first one on a review unit. That difference is usually why a feature ships instead of getting pulled.
We've been shipping on-device inference since well before it was a category, and the decision usually comes down to four questions.
Does it need to work offline? If yes, it runs on the device. There's no clever architecture that gets you around this one.
How often does it run? A feature that fires on every keystroke is ruinous as a cloud call and nearly free locally. A feature someone triggers twice a week is fine in the cloud.
How sensitive is the data? Health data, financial records, anything covered by a client's own compliance regime. Keeping it on the handset removes an entire category of problem rather than mitigating it.
How hard is the reasoning? On-device models are small. They summarise, classify, extract and rewrite very well. They don't do deep multi-step reasoning over long documents. That's what the bigger cloud models are for. Pretending otherwise gets you a demo that goes well and a product that people give up on.
Most real apps end up hybrid, and most of the engineering effort goes into deciding which way each request should go. We've set out the wider trade-offs in the pros and cons of AI in mobile app development.
We build a lot in Flutter, and there's a gap worth knowing about before you commit to it. No official Apple or Google Flutter plugin exists for on-device generative AI. Everything available is community-maintained and pre-1.0, and Firebase's hybrid on-device-with-cloud-fallback pattern is documented for iOS, Android and Web but not for Flutter.
So on-device AI in a Flutter app means either a small community package or platform channels written directly against FoundationModels and ML Kit. We write the channels. It's more work than the plugin ecosystem suggests, and it's better to price that in now than to find it in sprint three.
Vaxtor builds automatic number plate recognition. We built their Android app and SDK in Kotlin with a C++/NDK core, running plate recognition on the phone's own camera feed in real time. Cloud inference was never an option: the whole point is a parking attendant scanning plates in a car park with bad signal. That project is also where we learned how much device selection matters. Camera hardware and processing headroom vary enormously, and we had to work out which handsets could actually sustain the frame rate. The app is on Google Play and the SDK ships to Vaxtor's customers.
SeeChange, an Arm subsidiary, runs machine learning over smart camera feeds for retail loss prevention and safety. We built their Insights configuration platform in Flutter, covering mobile and web from one codebase.
Rio Sustainability used our Flutter work for the companion app to their AI sustainability platform, used by NHS Scotland, JD Sports, the Ministry of Justice and others.
We maintain flutter_markdown_plus, which does around 499,000 downloads a month and holds a perfect 160 out of 160 pub points. Its LaTeX companion adds another 25,000.
That matters here for a specific reason. When a model explains something, it emits Markdown: tables, code blocks, lists, equations. Something has to render all that on a phone, and a good deal of the Flutter ecosystem renders it with our package.
So when we tell you what a Flutter app can render from a model's output, we're telling you from the maintainer's side of it.
Bolting a chat window onto an app isn't AI-native development. It's a chat window. The more interesting pattern is intelligence that shapes what the interface actually shows, which is what Google's A2UI protocol enables with Flutter.
This raises the question every CISO asks first: if a model can drive the interface, what stops a user talking it into something malicious? Our answer is a component registry. The model sends a JSON payload describing what to display, and the app decides how to render it against a fixed catalogue of pre-approved widgets. Ask for a component that isn't in the registry and nothing happens. The model can't invent functionality or inject code, because it was never rendering code in the first place.
We've also prototyped using haptics to cover model latency, replacing a spinner with a low-intensity pulse while the model works. We like it, and we've built it, but we haven't yet run it in production long enough to claim numbers for it.
This changed twice in 2026, and most agency pages you'll read are still citing February 2025.
The Digital Omnibus on AI (Regulation (EU) 2026/1744) came into force on 27 July 2026 and moved several deadlines. High-risk obligations under Annex III went from August 2026 out to 2 December 2027, and Annex I systems embedded in regulated products to 2 August 2028. If you were racing a high-risk classification deadline, you have more time than you think.
What did not move is the part that catches ordinary apps. Article 50 transparency obligations have applied since 2 August 2026 to any system launched from that date. If your app generates content or talks to users as an AI, disclosure is a live obligation now, not a future one. And if your app was already on the market before that date, the marking requirements for AI-generated content bite on 2 December 2026.
That's the deadline most teams we speak to haven't clocked. It's three months out.
Prohibited practices and AI literacy duties have applied since February 2025 and were never deferred. Our fuller breakdown is in The EU AI Act: what app developers actually need to know.
The stores have their own view. Apple's guideline 5.1.2(i) requires you to disclose where personal data is shared with third parties, including third-party AI, and to get explicit permission first. If your app sends user content to OpenAI, Anthropic or Google, that needs a consent step naming the provider and the data. Google Play runs a separate AI-Generated Content policy, though it's narrower than most people assume: it covers chatbots as a central feature and generative image, voice and video, and it explicitly excludes productivity apps that use AI to improve an existing feature. Adding summarisation to something you already ship usually doesn't pull you into that regime.
AI Act readiness review. A prohibited-practice scan, an Article 50 transparency assessment against what's in force now, and a high-risk classification for the 2027 dates. Aimed at UK and US firms selling into the EU.
Edge AI optimisation. Moving high-frequency work such as summarisation, proofreading and classification off cloud APIs and onto Gemini Nano or Apple's on-device model, with a designed fallback for devices that can't run it. For high-volume consumer apps this is usually where the cloud bill goes.
AI-native transformation. Re-architecting an existing app to support agentic workflows and generative interfaces without a rebuild from scratch. If you arrived here from an AI-generated prototype, we've written about what separates AI-generated apps from production apps.
AI projects fail when teams commit to implementation before answering the basics. What runs on-device and what doesn't. What happens on hardware that can't run the model. What the inference bill looks like at ten times current volume. Which AI Act duties actually apply to you, and when.
The App Gameplan answers those in four weeks for a fixed £3,500. You get an AI capability assessment, an architecture blueprint, a compliance gap analysis and a fixed-price development quote. The fee is credited against development if you go ahead.
For AI work specifically, we'd push you to start there rather than skip it.
Written by Gareth Reese, Founder and CTO of Foresight Mobile. Gareth leads Foresight's AI practice, including maintainership of the flutter_markdown_plus open-source package.
An actionable four-week plan with clear deliverables and an unbeatable £3,500 price point, credited against your first development sprint.
Total client time commitment: 5-7 hours across 4 weeks
We meet with your key stakeholders to understand your business goals, user needs, and technical constraints. You'll share any existing research, designs, or documentation you have.
Our engineering team assesses the technical feasibility, identifies integration points with your existing systems, and evaluates architecture options.
We determine whether Flutter, native development, or another approach makes the most sense for your specific requirements.
We create clickable prototypes so you can experience your app before it's built. You'll test navigation flows, validate the user experience, and gather feedback from stakeholders.
Alongside this, we prioritise features based on business value and technical complexity, mapping out a phased delivery plan with a detailed cost estimate.
You receive your complete Gameplan pack, plus a presentation walkthrough with Q&A. Your team walks away with everything needed to make a confident decision.
Why UK businesses choose Foresight Mobile for AI app development
Complex AI outputs render correctly in your app, from financial tables to LaTeX equations, because we maintain the open-source package that powers it. As maintainers of flutter_markdown_plus, we understand the deep technical requirements of displaying AI-generated content in mobile apps.
Open Source Leadership • Streaming Content • Reduced Latency • User Engagement
You'll work with AI developers in your timezone who can meet face-to-face when needed, and who understand UK and EU regulatory requirements first-hand. No timezone delays when you're debugging model behaviour or adjusting AI responses.
Our team has implemented GenUI with Flutter since the A2UI standard launched. We've shipped edge AI features using Gemini Nano. We've studied the EU AI Act requirements in depth.
Manchester HQ • Same Timezone • Regulatory Knowledge • Proven AI Experience
Prompt injection can't be weaponised against your app because the architecture rules it out from the start. The AI sends declarative data (JSON), not executable code. Your app maintains a component registry of pre-approved widgets. If the AI requests something not in the registry, it's ignored.
CISOs can approve AI features knowing they cannot be weaponised. The AI rearranges your Lego blocks. It cannot create new ones.
Component Registry • No Code Execution • Prompt Injection Protection • CISO-Approved
AI operational costs drop 30-50% when each task is routed to the right model automatically. Simple tasks run on Gemini Nano on-device; complex reasoning goes to Gemini Pro in the cloud. This "Hybrid Grid" keeps sensitive data private while matching each request to the most cost-effective model.
Intelligent Routing | 30-50% Cost Reduction | Gemini Nano | Gemini Pro
EU AI Act compliance is built into the architecture from day one, not bolted on as a legal afterthought. We implement Article 10 data governance, Article 12 compliance logging, and Article 50 transparency markers from the start. Bias audits on training data. Inference logs capturing timestamps and inputs. Clear AI disclosure to users.
For US and UK companies entering EU markets, we provide gap analysis and remediation roadmaps to bring existing AI features into compliance.
Article 10 Data Governance • Article 12 Logging • Bias Audits • Transparency
Patient data, financial transactions, and field service records never touch a cloud server. Google's Gemini Nano, accessed via ML Kit's GenAI APIs built on Android's AICore system service, processes information locally on the device's neural processing unit. Healthcare apps analyse biometrics privately. Finance apps handle transactions without cloud exposure. Field service apps work completely offline.
The result: instant responses with zero latency, no per-inference cloud costs, and inherent GDPR compliance through data minimisation.
Gemini Nano • ML Kit GenAI APIs • Offline Capability • Zero Latency
.webp)
Instead of navigating static screens, users interact with forms, cards, and controls that appear dynamically based on what they need. Using Google's A2UI protocol, the AI decides what to show and Flutter renders it instantly with your design system. Google's A2UI protocol is at v0.9, heading toward a v1.0 spec; Flutter's GenUI SDK is Google's own official implementation of it, currently labelled alpha as the ecosystem matures fast.
A2UI Protocol | Flutter GenUI SDK | Native Widgets | Brand Consistency
We use Client Sovereignty: the AI sends declarative JSON, not code, and your app maintains a Component Registry of approved widgets. If the AI is tricked into requesting a malicious element, the app simply ignores it because it's not in the registry.
The AI can rearrange your approved "Lego blocks," but it can never manufacture a dangerous one. CISOs can approve AI features knowing they cannot be weaponised.
flutter_markdown_plus renders complex AI outputs (tables, LaTeX equations, formatted code blocks) that standard text widgets break. AI models communicate primarily in text and Markdown. If your app handles financial reports, code snippets, or academic data, standard rendering fails.
As the maintainers, we ensure your app can display rich AI-generated content flawlessly. You benefit from our direct expertise in the core library that powers rich text display in Flutter.
A2UI's headless architecture separates AI logic from display, enabling your app's intelligence to project onto glasses, wearables, or IoT displays without code changes. We engineer for 2026 and beyond.
By using the A2UI standard, our interfaces are "headless," meaning the AI logic is separated from the screen. This prepares your application for the era of Ambient Computing and Multi-Agent Systems, where your app's intelligence might need to render on smart glasses, wearables, or IoT displays, not just phone screens. Worth flagging: A2UI itself is still at v0.9 heading toward a v1.0 spec, and Flutter's GenUI SDK, our concrete implementation of it, is officially labelled alpha while the ecosystem matures at this pace.
Our Flutter-native A2UI stack renders 100% native widgets with 60fps performance, unlike Vercel AI SDK and MCP which rely on webviews or HTML rendering. For React-based web applications, those tools work well. For mobile, they result in sub-par performance.
We use Google's A2UI and Flutter GenUI. This is the "mobile-native" equivalent of Server-Driven UI. Our stack ensures perfect accessibility support and deeper integration with device hardware like the Taptic Engine for Neuro-Haptic Feedback.
Healthcare: On-device processing for patient data privacy, AI-assisted diagnostics with compliance logging, field tools that work offline. Finance: Private transaction analysis, fraud detection at the edge, regulatory-compliant AI decisioning. Education: Personalised learning experiences, accessibility features, classroom tools meeting EU AI Act requirements.
Retail and hospitality: GenUI for booking and purchasing workflows, personalised recommendations. Field service: Offline-capable AI assistants, real-time decision support. Any industry with complex workflows, privacy requirements, or EU market exposure benefits from AI-native architecture.
Yes. For existing AI applications we provide a prohibited-practice scan covering the features that became illegal in February 2025, an Article 50 transparency assessment against the obligations that came into force on 2 August 2026, and a high-risk classification report.
The timings changed this year, and it is worth knowing which way. The Digital Omnibus on AI, Regulation (EU) 2026/1744, came into force on 27 July 2026 and moved Annex III high-risk obligations out to 2 December 2027, and Annex I systems embedded in regulated products to 2 August 2028. What did not move is Article 50. If your app was already on the market before 2 August 2026, the marking requirements for AI-generated content apply from 2 December 2026.
For new development we build compliance in from sprint one: Article 10 data governance, Article 12 logging, and Article 50 disclosure and content marking where they apply.
On-device models like Gemini Nano are smaller than large cloud models such as GPT-class models or Gemini Pro. They excel at specific tasks: grammar correction, smart reply generation, local document summarisation, intent classification, and UI component selection. They're not suited for complex multi-step reasoning or tasks requiring broad world knowledge.
This is why we architect hybrid systems. Simple, frequent tasks route to the device for speed and privacy. Complex reasoning routes to the cloud. The user experience combines the strengths of both without managing the complexity.
Chatbots are text-in, text-out interfaces. Users type questions, the AI responds with paragraphs. This works for simple queries but fails for complex tasks. You cannot efficiently book flights, configure dashboards, or compare products through conversation. Users experience "chat fatigue" and abandon the interaction.
AI-native apps use GenUI to generate appropriate interfaces for each task. Booking a table? The AI generates a date picker and time selector. Comparing laptops? A comparison table appears. The AI chooses the best UI pattern for the task. Users interact through taps, swipes, and familiar controls rather than typing.
AI projects require longer discovery phases than traditional app development. Architecture decisions around AI routing, on-device capabilities, model selection, and compliance requirements must be resolved before code is written. Retrofitting these decisions is expensive. From our experience delivering AI-integrated apps across healthcare, fintech, and enterprise sectors, underestimating this discovery phase is the most common planning mistake.
After a 4-week App Gameplan, typical timelines are: GenUI feature integration 12-16 weeks, edge AI implementation 14-20 weeks, comprehensive AI-native application with compliance 6-12 months. Complex enterprise integrations with multiple AI agents can extend beyond 12 months.
AI app development costs vary with how much of the app the AI actually touches. Adding AI features to an app you already have usually runs £20,000-40,000. A greenfield AI-native application with on-device inference, hybrid cloud routing and EU AI Act compliance typically ranges from £40,000-80,000.
The variables are the number of AI use cases, the on-device versus cloud split, your regulatory classification, and whether you are building new or integrating with systems you already run. Where the work lands also changes your running costs: once a model is on the handset there is no per-token charge, while cloud inference is billed per call. The App Gameplan gives you a detailed quote after 4 weeks of discovery for £3,500.
The EU AI Act regulates AI systems offered in European markets, including apps from US and UK companies sold through European app stores. It sorts systems by risk level and attaches obligations to each level.
Certain practices have been prohibited since February 2025, among them manipulative algorithms, workplace emotion recognition and biometric categorisation. The rest of the Act applied from 2 August 2026, which brought Article 50 transparency duties into force: users have to be told when they are dealing with an AI. Apps already on the market before that date have until 2 December 2026 to meet the marking requirements for AI-generated content.
High-risk obligations moved. Regulation (EU) 2026/1744 pushed Annex III systems to 2 December 2027 and Annex I to 2 August 2028, so if you were working to an August 2026 high-risk deadline you have more time than you think. Our EU AI Act Guide for App Developers covers the details.
On-device AI runs machine learning models directly on the smartphone's neural processing unit (NPU) rather than sending requests to cloud servers. Google's Gemini Nano, accessed via ML Kit's GenAI APIs (built on Android's AICore system service), enables this for Android devices (current AICore-capable flagships such as the Pixel 10 series, Samsung Galaxy S26, and OnePlus 15, with more devices qualifying each generation).
On-device processing solves three problems: latency (no network round trip), cost (no per-inference cloud charges), and privacy (sensitive data never leaves the device). Apps can function offline, process health or financial data privately, and respond instantly to user actions.
A2UI (Agent-to-User Interface) is Google's open standard for enabling AI agents to generate user interfaces. Instead of outputting text or attempting to generate code, AI agents send structured JSON payloads describing component trees. The client application interprets these payloads and renders native UI elements.
The protocol enforces a strict separation of concerns: the AI agent determines what to show based on user intent; the client application determines how it's rendered. Flutter's GenUI SDK provides the concrete implementation, making it straightforward to add GenUI capabilities to Flutter apps. The standard itself is currently at v0.9, heading toward a v1.0 spec, and Flutter's GenUI SDK is officially labelled alpha as Google's implementation keeps pace with it.
Generative UI is an architecture where AI generates user interface components dynamically rather than displaying pre-built static screens. The AI sends a declarative payload describing what to show (a carousel of restaurant cards, a booking form, a comparison table). The app renders these using native widgets from a pre-approved component registry.
GenUI eliminates the "chat disappointment" where users tire of reading long text responses. It also provides security: since the AI sends data, not code, prompt injection attacks cannot generate malicious interfaces. The app retains control over what can be rendered.
AI-native development means AI shapes the entire user experience, not just a chat interface bolted onto an existing app. The AI determines what UI components to display based on user intent. Instead of typing messages back and forth, users interact with forms, cards, sliders, and controls that appear dynamically.
This approach uses technologies like Google's A2UI protocol with Flutter. When someone asks to book a flight, the app generates a booking form with native date pickers and seat selectors. The AI decides the structure. Flutter renders it instantly. User frustration with "walls of text" disappears.
Most AI app projects wrap a call to the OpenAI API and call it done. You end up with a chatbot bolted onto an existing product, high inference costs, data privacy risks, and no competitive differentiation.
We build differently. Our AI apps use on-device inference, Gemini Nano on Android, Core ML and Apple's Foundation Models framework on iOS, LiteRT for cross-platform models, so AI features work offline, run faster, and don't send user data to external servers. Where cloud inference is needed, we build hybrid routing that moves queries on-device first and escalates only when necessary.
We've shipped on-device AI features in five client apps to date using Gemini Nano and Core ML.
We assess whether on-device inference (Gemini Nano, Core ML, Apple's Foundation Models framework, LiteRT) is viable for your use case, or whether a cloud-hybrid architecture is more appropriate. We audit your data quality, labelling maturity, and privacy obligations under GDPR and the EU AI Act. This prevents two common and expensive mistakes: building on data that can't support the feature, and deploying a model that turns out to be High-Risk under Article 6 of the EU AI Act.
We design the AI architecture around your constraints. For on-device inference, we select and quantise models for the target hardware, typically INT8 or INT4 via LiteRT. For generative UI features, we implement Google's A2UI protocol with Flutter GenUI and a Component Registry that prevents prompt injection by design. If your app needs EU AI Act compliance from sprint one, we map Article 10, 12, and 50 obligations into the architecture before a line of code is written.
We integrate the model using the appropriate platform SDK: Google AI Edge SDK for Android, Core ML framework for iOS. We test across real device tiers, not just flagship hardware, because quantised model performance drops sharply on mid-range chipsets. Our test suite covers inference latency, memory footprint, thermal throttling behaviour, and failure modes when the model returns unexpected outputs.
We instrument your AI features with production monitoring: inference latency percentiles, model fallback rates, on-device versus cloud routing splits, and error classification. For apps using Gemini Nano or Core ML, model updates follow a staged rollout via Firebase Remote Config rather than forcing an app store update. You get dashboards that tell you whether your AI features are performing against their design targets, and alerts when they're not.
Your app, your way. Here's how we make it happen
Fixed price agreed upfront, with cloud inference cost projections for your expected usage volume documented before sprint one. AI app budgets blow up when nobody scopes the inference bill. We do that scoping in the Gameplan so you don't get a surprise £40k OpenAI invoice in month three. No scope creep, no shock invoices.
AI features don't stand still: Gemini Nano models update with each Android release, OpenAI deprecates older API versions, and on-device capabilities expand with iOS and Android majors. We offer App Care retainers from £675/month with model deprecation tracking and staged Firebase Remote Config rollouts, so your AI features keep working as the underlying tech moves.
Real users from your target audience test AI features throughout development. In our experience, AI that isn't tested with real usage patterns tends to behave perfectly in demos and poorly in production.
You know what problem you're trying to solve. We know which AI approach fits it (on-device inference, cloud API, fine-tuned model, or retrieval-augmented generation), and which ones will create compliance or cost problems further down the line.
We've implemented AI features using Gemini Nano (on-device), Google Gemini API, and OpenAI. In our experience, on-device inference is the right choice for privacy-sensitive applications; cloud APIs are right for capability and scale. We've also built EU AI Act compliance documentation for clients in regulated sectors. Our Flutter-Google partnership keeps us close to the latest on-device model releases.
We're based in Manchester with offices in London and Birmingham. We think face-to-face time makes better products. Drop in whenever you like.
