Agentic AI in Mobile Apps: UX Patterns

Key facts, with sources

• Gartner predicts over 40 percent of agentic AI projects will be canceled by the end of 2027 due to escalating costs, unclear business value, or inadequate risk controls. (Gartner)
• Gartner predicts 33 percent of enterprise software applications will include agentic AI by 2028, up from less than 1 percent in 2024. (Gartner)
• Gartner estimates only about 130 of the thousands of vendors claiming to sell agentic AI are real, with the rest engaged in agent washing of existing chatbots and RPA products. (MarTech)
• McKinsey's State of AI 2025 found 23 percent of organizations are scaling an agentic AI system somewhere in the enterprise and another 39 percent have begun experimenting with agents. (McKinsey)
• Gartner forecasts 40 percent of enterprise applications will embed task-specific AI agents by the end of 2026, up from under 5 percent in 2025. (Joget)

Run the agent server-side; the phone is a viewport

A mobile app cannot host an agent loop: iOS and Android will suspend your process the moment the user switches apps, and a multi-minute loop over a cellular connection will die mid-task. So the agent runs on your backend with its own lifecycle, and the app subscribes to its state — over SSE or a socket while foregrounded, with a state fetch on reconnect that renders wherever the run has gotten to.

That one decision drives the whole UX architecture. The run's state must be fully renderable from a server snapshot at any moment — not accumulated from a stream the app may have missed. In React Native I keep a single run object in state, hydrate it on mount and on app-foreground events, and treat streamed events purely as incremental updates to that snapshot.

Replace the spinner with a step timeline

A spinner labeled "thinking" is where user trust goes to die — thirty seconds of it feels broken even when the agent is working perfectly. The pattern that fixes this is a step timeline: each agent action renders as a row with a human-readable label ("Searching your invoices", "Drafting the email") and a state — running, done, failed, or awaiting approval. Users watch work happen, and long waits reframe as visible progress.

Keep labels at the level of user intent, not tool mechanics — "Checking flight prices," never the raw tool name and parameters. I map tool names to label templates in the client so the copy stays polished and localized independently of backend changes.

type AgentStep = {
  id: string;
  label: string; // user-intent copy, mapped from tool names client-side
  state: 'running' | 'done' | 'failed' | 'awaiting_approval';
};

export function AgentTimeline({
  steps,
  onApprove,
  onReject,
}: {
  steps: AgentStep[];
  onApprove: (id: string) => void;
  onReject: (id: string) => void;
}) {
  return (
    <View style={styles.timeline}>
      {steps.map(step => (
        <View key={step.id} style={styles.row}>
          <StatusDot state={step.state} />
          <Text style={styles.label}>{step.label}</Text>
          {step.state === 'awaiting_approval' && (
            <View style={styles.actions}>
              <Pressable onPress={() => onApprove(step.id)}>
                <Text style={styles.approve}>Approve</Text>
              </Pressable>
              <Pressable onPress={() => onReject(step.id)}>
                <Text style={styles.reject}>Reject</Text>
              </Pressable>
            </View>
          )}
        </View>
      ))}
    </View>
  );
}

Approvals deserve first-class UI

When the agent needs sign-off — send the message, place the order, delete the records — the approval must render the full consequence, not a summary of it: the actual email text, the actual amount, the actual list of what gets deleted. On mobile this deserves a dedicated card or sheet with the proposed action rendered natively, an approve action, a reject action, and ideally an edit path, because the most common user desire is "yes, but change one thing."

Approvals are also where sessions die: the user may not respond for hours. The agent has to park the run durably server-side and survive the wait, and the approval card must deep-link back into the exact run so a tap on the notification lands the user on the decision, not on your home screen.

Push notifications close the loop

Agent tasks outlive mobile sessions, so push notifications are load-bearing infrastructure here, not marketing. Three notifications matter: the task finished (with the outcome in the notification body, not just "done"), the task needs a decision, and the task failed in a way that needs the user. Each deep-links into the run timeline.

Restraint is part of the pattern: a notification per agent step trains users to disable notifications entirely, which kills the whole supervision model. I batch progress into the in-app timeline and reserve pushes for terminal states and blocking decisions. Getting this split right matters more for perceived quality than most model improvements.

Design for interruption, resume, and undo

Users change their minds mid-run, so agentic mobile UX needs a visible stop control that actually halts the server-side loop at the next safe boundary — and it needs to be honest about what already happened: "stopped; two drafts were created, nothing was sent." Silent partial state is how you lose trust permanently.

Undo completes the loop. Reversible actions the agent took should be listed with per-item undo, which is another argument for staging writes as pending drafts rather than immediate commits. My rule for mobile agents: every run ends with a receipt screen — what was done, what was skipped, what can be undone — because on a small screen, the summary is the product.

When to hire senior help

Senior help is most valuable at the architecture stage, deciding what to automate, where approval gates belong, and how business value will be measured, before any code is written. It is also worth bringing in when a stalled pilot needs risk controls and evaluation rigor to pass security and compliance review. If your stack includes React Native + Python + AI, a senior engineer who owns the full product beats coordinating multiple juniors.

Bottom line

Dhairya Senjaliya ships AI — Agentic AI Systems projects worldwide — book a scoping call to discuss your specific situation.

Common pitfalls to avoid

• ✕Buying agent-washed products, since Gartner estimates only around 130 of thousands of self-described agentic AI vendors are genuine rather than rebranded chatbots or RPA
• ✕Deploying autonomy before defining risk controls and human-approval gates, one of the three causes Gartner cites for the 40 percent of projects it expects to be canceled
• ✕Measuring activity like tasks attempted instead of business value, leaving the project unable to justify escalating costs at renewal time
• ✕Wrapping agents around existing processes instead of redesigning the workflow, when McKinsey finds workflow redesign is the single biggest driver of EBIT impact from gen AI

Frequently asked questions

Sources

• Gartner
• MarTech
• McKinsey
• Joget