We at TrueTech develop AI assistants for navigation in mobile applications. Complex mobile apps — banks, ERPs, medical platforms — lose users not because of missing features, but because finding the right feature is too difficult. The traditional answer — onboarding tours and help pages — works poorly: users go through the tour on first login and forget it a day later. An AI Copilot for navigation is an assistant that understands natural language requests and guides the user where they need to go. We guarantee that users will not get lost in the menu even in an app with 100+ screens.
What the Navigation Copilot Can Do
Not a 'chat', not an FAQ-bot. Three specific scenarios:
-
Deep link navigation. User writes 'I want to transfer money to a card' — the assistant opens the correct screen. Technically: NLU model classifies the intent, maps it to a deep link, app performs navigation programmatically.
-
Contextual hints. User lingers on a screen for three minutes without performing an action — Copilot offers help. Not a generic 'Need help?', but contextual: 'You are on the payment screen. Would you like me to explain the difference between transfer by phone number and by bank details?'
-
Guided task execution. Multi-step tasks: 'apply for a mortgage' — 12 steps spread across three sections. Copilot guides step by step, tracks progress, and explains each screen.
How the AI-Copilot Understands User Intent
The most challenging part is mapping the user request to a specific action in the app. Two approaches:
-
Classifier-based. Predefine a set of intents (50–200 for a typical app), train a classifier. Fast, predictable, cheap at runtime. Fails on non-standard phrasing.
-
LLM + function calling. Describe all screens and actions as a set of functions. The LLM selects the appropriate function based on the user request:
// iOS — description of navigation functions for LLM let navigationTools: [ChatCompletionTool] = [ ChatCompletionTool( type: .function, function: ChatCompletionToolFunction( name: "navigate_to_screen", description: "Opens an app screen by its identifier", parameters: NavigationParameters.schema // {screen_id: string, params: object} ) ), ChatCompletionTool( type: .function, function: ChatCompletionToolFunction( name: "highlight_element", description: "Highlights a UI element on the current screen with an explanation", parameters: HighlightParameters.schema ) ), ChatCompletionTool( type: .function, function: ChatCompletionToolFunction( name: "start_guided_flow", description: "Starts a step-by-step guide for a multi-step task", parameters: FlowParameters.schema ) ) ] // Request with function calling let request = ChatCompletionRequest( model: "gpt-4o-mini", messages: [systemMessage, userMessage], tools: navigationTools, toolChoice: .auto ) The LLM returns tool_calls with function name and parameters; the app executes navigation.
| Criterion | Classifier-based | LLM + function calling |
|---|---|---|
| Accuracy on standard queries | 95%+ | 98%+ |
| Accuracy on non-standard phrases | ~70% | 95%+ |
| Response speed | <50 ms | 300-600 ms |
| Flexibility of extension | Needs retraining | Add function to prompt |
How Guided Task Execution Works
The Copilot remembers the sequence of steps required to complete a task. It doesn't just open a screen; it guides the user through each step, checks completion, and returns to previous steps if needed. We describe in the system prompt the structure of each step: current screen, expected action, possible errors. For example, for a mortgage application: step 1 — select program, step 2 — upload documents, step 3 — confirm status. The Copilot tracks progress via session context.
Programmatic Navigation in iOS and Android
On iOS (SwiftUI) — via NavigationPath or custom Router:
class AppRouter: ObservableObject { @Published var path = NavigationPath() func navigate(to screen: AppScreen, params: [String: Any] = [:]) { switch screen { case .transfer: path.append(TransferRoute(params: params)) case .loanApplication: path.append(LoanApplicationRoute(params: params)) // ... } } // Called from AI Copilot func executeNavigationAction(_ action: NavigationAction) { DispatchQueue.main.async { self.navigate(to: action.screen, params: action.params) } } } On Android (Compose) — via NavController:
fun handleCopilotAction(action: NavigationAction, navController: NavController) { when (action.screenId) { "transfer" -> navController.navigate( "transfer?amount=${action.params["amount"] ?: ""}" ) "loan_application" -> navController.navigate("loan/application") // ... } } UI Element Highlighting
Guided mode with element highlighting is technically more complex than navigation. You need an element identification system independent of screen position. On iOS: a tagging system via accessibilityIdentifier. The Copilot knows element names; an overlay layer draws a highlight with animation over the required element. On Android: similarly via contentDescription or custom tags + ViewTreeObserver to get element coordinates at runtime.
Contextual Awareness
The Copilot must know where the user is right now. Current screen, steps already completed, unfilled fields — this context is injected into the system prompt:
func buildCopilotContext(currentScreen: AppScreen, formState: FormState?) -> String { var context = "Current screen: \(currentScreen.name).\n" if let form = formState { context += "Completed fields: \(form.completedFields.joined(separator: ", ")).\n" context += "Missing required fields: \(form.missingRequired.joined(separator: ", ")).\n" } return context } Typical Implementation Mistakes
Main: Copilot performs destructive actions without confirmation. Rule — navigation is executed immediately, any data changes (form submission, payment creation) require explicit user confirm, regardless of what Copilot said.
Second: describing all 80 screens in the system prompt. This bloats the prompt to several thousand tokens. Solution — vector search over the screen catalog before the LLM request: only 5–10 most relevant screens end up in the prompt.
Step-by-Step Implementation Guide for AI Copilot
- Screen inventory — describe all screens and actions in the app, create an intent-to-deep-link mapping.
- Select approach — we recommend LLM + function calling for flexibility.
- Integrate with LLM — add API calls to the chosen model (GPT-4o, Claude, etc.).
-
Implement programmatic navigation — define routes via
NavigationPath(iOS) orNavController(Android). - UI overlay — add a highlight layer for guided mode.
- Testing — run an A/B test with task completion rate metrics.
- Iteration — analyze logs and refine prompts.
Our Process
Screen and action inventory → intent schema design → NLU implementation (classifier or LLM function calling) → programmatic navigation system → UI overlay for element highlighting → guided flow engine → A/B test with task completion rate metrics.
Deliverables
- Intent schema and screen mapping
- LLM integration with function calling (Swift/Kotlin)
- Programmatic navigation for iOS and Android
- UI overlay container with element highlighting
- Guided flow engine
- Documentation for extension and maintenance
- Team training
Our Expertise and Experience
We are a team of certified Apple and Google engineers. 5+ years in mobile development, 30+ successful projects in FinTech, HealthTech, and Retail. We provide quality guarantees at every stage — each Copilot module undergoes load testing and code review.
Timeline Estimates
MVP with LLM function calling and basic navigation — 2–3 weeks. Full system with guided flows, element highlighting, and contextual hints — 3–5 weeks. Iterative refinement based on analytics — ongoing.
We will assess your project for free — contact us to discuss details. Get a consultation today.