Dev48
Language
  • About
  • Services
  • Industries
  • Technologies
  • Articles
  • Contacts
Book a call
    Home/Articles/Agentic workflows with expo simulators
Dev48
info@dev48.org+375 29 320-40-96WhatsApp@isky_by

© 2026 · All rights reserved.

Agentic Workflows with Expo Simulators

Source: Expo Blog•November 19, 2026 at 06:06 PM

Agentic Workflows with Expo Simulators

Three agentic workflows with Expo Simulators: event triggers, a pull request assistant, and QA swarms, each with evidence your team can review.

Mobile development teams on the cutting edge are turning to cloud simulators and emulators to validate their AI-generated code and move faster. Much faster, actually. So how do they keep humans in the loop?

AI agents have improved a lot in the last six months. As a Field Engineer at Expo, I have had the privilege of talking with many enterprise mobile teams and seeing this firsthand. Every one of them has agents writing more, if not all, of their code. Fewer of them have a good way for agents to thoroughly test what they're writing.

An agent can write a feature, but without a device to run it on, it cannot verify it. Open source tools like agent-device and Argent let an agent drive a simulator, and coding agents are getting better at this on their own as well. What they still need is the device. Local simulators are great, but they do not get you to the desired end goal on their own. They live on one developer's machine, so an agent running in CI or kicked off by an event has nothing to drive. Run more than a couple at once and your laptop runs out of CPU and memory fast. And when the agent is done, nobody else on the team can see what it did. Pair those tools with cloud simulators and the loop closes: an agent installs your app on an iOS simulator or Android emulator in the cloud, taps through it, and is able to report back what it found to you and your entire team.

Expo Simulators provides both simulators and emulators in the cloud that help open up a plethora of agentic workflow possibilities. This post covers the three I like to showcase most: event triggers, a pull request assistant, and QA swarms. All three flows are set up in a public demo repo, todo-app.

All of these agentic workflows depend heavily on providing an evidence layer after the simulator session is complete. When an agent works on a cloud simulator, you and your team need to see what it did, not just read what it says it did. This can be achieved by collecting screenshots, taps, recordings, performance metrics, and much more. The more work agents take on, the more evidence you need before you can confidently ship.

Event Triggers

Event triggers start agent work without a developer needing to be in the loop. A tester submits feedback, or an observability tool fires off an alert, and a Workflow immediately picks it up. The issue gets filed, reproduced on an Expo Simulator, and fixed while the team is heads down, focused on other work. Once a team member can get to it, there is a decision to make instead of a bug to chase.

In the demo repo, the example event trigger is TestFlight feedback. Here is how it runs.

Step 1: The tester reports. A screenshot and a sentence is all you need. Once the TestFlight feedback is submitted, App Store Connect fires a Workflow directly.

TestFlight feedback is one of several App Store Connect events that can start a Workflow. You can also trigger on crash reports, build uploads, app version review states, and external beta approvals. The docs list every event you can hook into.

Step 2: An agent files the issue. It reads the comment and screenshots, decides whether it is a bug or a feature request, writes a title and reproduction steps, and checks the open issues for any duplicates. Then it opens the GitHub issue.

Step 3: An agent reproduces it. The newly filed GitHub issue fires off a second Workflow. An agent follows the reproduction steps on an Expo Simulator and posts a verdict on the issue with an evidence page. For a bug, the verdict is REPLICATED or NOT-REPLICATED. For a feature request, it is CONFIRMED, which means the agent went to the screen where the feature would live and screenshotted it without the feature. That screenshot becomes the before evidence for the implementation PR.

Step 4: An agent fixes it. A pull request with the fix or enhancement is created based off the GitHub issue. Then it is verified on an Expo Simulator. The evidence lands on the PR, and you decide whether to merge it or not.

TestFlight feedback is just one trigger example. The same pipeline can run for an observability alert. When Observe, Sentry, or your tool of choice flags an error or a performance regression, point its alert webhook at the Workflows REST API. An agent reads the alert and the stack trace, pinpoints the screen involved, and files the issue. Everything after that is identical. The same endpoint lets any internal system hand a bug or feature request to this flow:

You can also run it manually via the CLI:

This is the loop you will see in every workflow in this post. An agent does the work, checks it on an Expo Simulator, and the evidence lands where a human can review it.

The evidence site is its own problem to solve, so I built a package for it. eas-simulator-evidence is an out-of-the-box solution that pulls the screenshots and other data related to the Expo Simulator session and creates a static site for you.

Pull Request Assistant

For most, checking a change on a device is the slowest part of the mobile code review process. The pull request assistant moves that step to an agent on an Expo Simulator and posts the result right on the PR, where the reviewer already is. You still make the final call on what merges. Here is how it runs.

Step 1: A reviewer tags the bot. Comment @expo-bot on any pull request and it does one of three things:

  • @expo-bot reviews the current diff and verifies the change on an Expo Simulator.
  • @expo-bot <instruction> has an agent make the change, push it to the branch, and then review and verify the result on an Expo Simulator.
  • @expo-bot preview <device> for 15 boots up the device of your choice with the PR's app and posts a live preview link for 15 minutes. No agent involved. Anyone, technical or not, can then tap through the change in the preview-only view and verify it.

The comment-driven flows are the ones I demo because they show the range of possibilities. Most teams I work with want the review to run on its own, so opening a pull request also triggers the review mode automatically (expo-bot-pr-opened.yml). Draft PRs wait until they are marked ready. A label trigger works the same way if you would rather opt PRs in one at a time.

A small GitHub Action, expo-bot-bridge.yml, reads the comments on new issues and PRs and acts on any aimed at @expo-bot. There is no bot account to install. The handle is a botHandle value in package.json, so you can name it whatever you want. The Action parses the mention, picks a mode, and kicks off the matching Workflow. Since it is a public repo, there is also a built-in author check, so not just anyone with the ability to comment can run agents against your repo and burn your tokens!

Step 2: The PR's code lands on an Expo Simulator. The verify workflow, expo-bot-verify.yml, gets there in three steps using four pre-packaged jobs:

  • fingerprint hashes the native code on the PR branch.
  • get-build looks for an existing simulator build with that same fingerprint.
  • One of two jobs runs next, depending on what get-build found:No match: build kicks off a new simulator build. Native code changed, so a fresh build is required.Match: repack takes the existing build and swaps in the PR's JavaScript bundle, skipping the build process.
  • No match: build kicks off a new simulator build. Native code changed, so a fresh build is required.
  • Match: repack takes the existing build and swaps in the PR's JavaScript bundle, skipping the build process.

Most PRs only touch JavaScript, so most runs skip the build and go straight to repack. That is what keeps this flow fast.

Once there is a build, one command puts it on an Expo Simulator:

--build-id installs and launches the app before the session is ready, so the agent lands on a running app. --max-duration-minutes helps keep costs low by stopping the simulator session if the agent is taking longer than you would expect to complete the work. You can also pass --max-idle-time-minutes to stop a session after a set amount of inactivity, which is a nice safety net.

Expo Simulators is not just for React Native apps. You can install any iOS Simulator build or Android APK onto it. Swift, Kotlin, Flutter, and Unity apps all work. Learn more here. To prove it, I built todo-app-native, a fully native Swift version of the demo app that runs every agentic workflow in this post.

Step 3: An agent taps through the change. verify-on-simulator.sh confirms the app rendered, then hands the device to a headless coding agent. The demo uses Claude Code, but you can easily swap in whatever coding agent you prefer.

The agent reads the diff, decides what is worth checking, and taps through those checks on the device, taking screenshots as it goes. When it is done, it hands back a verdict, PASS or FAIL, along with a short blurb of what it did and what it saw.

Step 4: The evidence lands on the PR. The simulator session is stopped and collects the data. All of that is packaged into an evidence page and posted onto the PR as a comment with the verdict, a row of screenshot thumbnails, and a link to the full page. Here is an example of what that page looks like.

QA Swarm

Having simulators in the cloud unlocks the ability to run many at the same time. At will, you could spin up 5, 10, 50, or even hundreds of Expo Simulators at once without being restricted by the resources on your local machine. That makes a QA swarm possible: one agent per Expo Simulator, each assigned a core flow in your app, all running at the same time.

In the demo repo, the swarm is kicked off from the CLI with a PR number:

Step 1: The app lands on Expo Simulators. qa-swarm.yml runs the same fingerprint, get-build, build, and repack jobs from the pull request assistant flow.

Step 2: Five agents run at the same time. The workflow boots five Expo Simulators, three iOS and two Android. Each one gets its own session and one short flow to check. A lane can run an existing Appium suite, Maestro flows, or TesterArmy's e2e framework. For simplicity, the demo uses plain markdown files that tell an agent what to test and do.

Step 3: Each lane reports its own verdict. A lane passes or fails on its own, and each lane gets its own evidence page.

Step 4: The swarm gets summarized. A final job collects the five verdicts, the evidence links, and the timing, and posts it all as one comment on the PR. The parallelization is the part that gets people's attention. A full pass takes as long as the slowest lane instead of five flows run back to back.

Adding coverage is as simple as adding another lane. Drop a new flow file in the folder and add a job for it.

This ability to unlock resources in the cloud can also come in handy for developers I classify as mobile power users. You can easily run several coding agents across separate git worktrees, all getting their own device for maximum efficiency.

Wrapping up

I have had a blast playing around with Expo Simulators these past couple months and cannot wait to see what you build with it. Expo provides agentic mobile infrastructure to hundreds of thousands of customers today. Cloud simulators are the next building block on that journey.

Expo Simulators is now generally available. Read the docs and clone the demo repo to get started on any of these workflows yourself. Not a React Native shop? The native Swift version has the same workflows ready to go. If you are on an enterprise team and want help setting them up for your app, reach out!

Happy building!

← All articles

What this article says

More in Software Development

All →
Agent Memory Architecture: Centralized vs. Federated Memory for AI Agents
Couchbase

Agent Memory Architecture: Centralized vs. Federated Memory for AI Agents

Delphi language support is now built into SonarQube
SonarSource

Delphi language support is now built into SonarQube

Braze named a Leader in the Forrester Wave™: Cross-Channel Marketing Hubs, Q4 2026
Braze

Braze named a Leader in the Forrester Wave™: Cross-Channel Marketing Hubs, Q4 2026

The 2027 Amazon Playbook: What Matters, What's Noise and What Brands Should Own
Cart Com

The 2027 Amazon Playbook: What Matters, What's Noise and What Brands Should Own

Where apps come to life: The story behind Netlify’s new brand
Netlify

Where apps come to life: The story behind Netlify’s new brand

You don’t have to wait to measure AI shopping
Fabric

You don’t have to wait to measure AI shopping

More from Expo

How to set up agentic workflows on Expo
Expo

How to set up agentic workflows on Expo

Introducing Expo Simulators: cloud simulators built for agents
Expo

Introducing Expo Simulators: cloud simulators built for agents

How five web developers built an iOS keyboard extension with Expo
Expo

How five web developers built an iOS keyboard extension with Expo

How to iterate faster with Expo, Supabase, and AI
Expo

How to iterate faster with Expo, Supabase, and AI

How many engineers does it take to build a social network?
Expo

How many engineers does it take to build a social network?

Inside the new JNI layer in Expo Modules 2.0
Expo

Inside the new JNI layer in Expo Modules 2.0