How to run TypeSafe’s JevOn real android phone with mobilerun

Mobile Jev is an open-source agent that connects Jev, TypeSafe’s System One model, to real Android devices through mobilerun. Instead of writing text, Jev outputs typed actions (tap, type, scroll, open app) with a calibrated confidence score on each one, and mobilerun executes those actions on a live phone in the cloud. You give it a plain-language goal and it navigates the app for you.

Why does that matter? Most mobile agents today run on a general-purpose LLM, such as Anthropic’s Claude or OpenAI’s ChatGPT family of models. At every step the model writes a few sentences of reasoning, names an action, and your code parses that text and hopes the button it named actually exists. Each step takes seconds, actions get hallucinated, and you never know how confident the model really was. Jev was built to remove that loop.

What is Jev, and what is a System One model?

Jev is the first public model from TypeSafe AI and the first of what they call System One models: a class of models built to make fast, structured decisions that software can use directly, rather than to chat. Instead of generating text token by token, Jev looks at the current state and returns a typed answer from a fixed set of options, with a probability attached to each one. TypeSafe reports end-to-end decision times of roughly 70 to 500 ms, and the model is trained with a method called Reinforcement Learning for Calibrated Decisions, so the probabilities are meant to reflect real uncertainty rather than the overconfidence you get from an LLM.

With Mobile Jev, that decision-making capability is connected to a real Android device through mobilerun. This is also what makes Jev easier to trust than an LLM agent. An LLM explains itself in prose you cannot verify. Jev does not explain anything. It gives you the whole decision: the closed set of actions it could take on this screen and how confident it is in each one. You can log every step, set a confidence threshold below which the agent stops, and audit a run afterwards without reading a story about what the model was thinking.

How Jev works on an Android or iOS phone

Jev chooses actions such as OPEN_APP, TAP, TYPE_TEXT, scrolling, navigation, WAIT, DONE, or, stopping when a task is BLOCKED. It uses the device's installed-app list to find apps and checks that a target is still present before acting, preventing stale or incorrect actions.

Jev uses exact text from the user's goal rather than generating or inventing text. For example, from "Search for restaurants in New York", it can extract "New York" and enter it directly. You can also provide an exact value with --text "New York". This means a separate text-generation model isn't needed for basic text input.

After entering text, the system verifies that the expected value appears in the field. If it can't verify it, the run stops instead of blindly retrying. Similarly, device actions aren't automatically repeated when their result is uncertain.

Every decision comes with a confidence score, and you can set a threshold below which the agent stops and reports BLOCKED instead of guessing. One honest caveat: DONE is not proof that the task succeeded. Check the actual device state afterwards, especially for numbers, dates, and multi-step tasks.

Why pair Jev with mobilerun?

The two components have different jobs:

Jev = reasoning: It determines what action should happen next.

mobilerun = execution: It performs that action on the Android device.

Jev on its own only makes decisions. It needs something to observe the screen and carry out the action, and that is what mobilerun provides: real Android devices hosted in the cloud, not emulators, exposed through an API. mobilerun streams the screen and UI state to Jev, executes the tap or text input Jev chose, and returns the new state. Because the phone lives in the cloud, there is no USB cable and no ADB setup, and you can run the same agent against many devices in parallel or from a CI job.

Example

You can run a task from the command line:

1pnpm agent run "Turn on dark theme in Android Settings." 
2--execute
Copy

Here is what a run looks like step by step. mobilerun sends Jev the current screen and the list of installed apps. Jev returns OPEN_APP Settings with a confidence of, say, 0.94. mobilerun opens it and sends back the new screen. Jev picks TAP on the Display row, then TAP on the Dark theme toggle, checking before each tap that the target is still on screen. When the toggle reads as on, Jev returns DONE. Each decision takes well under a second, and every step is logged with the action, the target, and the confidence score, so you can replay exactly what happened.

What Can You Build With It?

A mobile agent like Jev can be useful for:

• Mobile QA:  navigate apps and verify UI states
• App exploration : perform tasks without hardcoded flows
• No-API workflows : interact directly with mobile apps
• Mobile research : search and collect information through apps
• Remote automation : control devices through mobilerun

Getting Started

Clone the repository and install the dependencies:

1git clone https://github.com/droidrun/mobile-jev.git
2cd mobile-jev
3pnpm install --frozen-lockfile
Copy

Add your mobilerun and TypeSafe API keys to .env.local, then run:

1pnpm doctor
2pnpm dev
Copy

The project also includes a local studio where you can see the device, enter natural-language goals, and inspect the agent's actions.

The bigger idea

Mobile Jev demonstrates what happens when you combine a decision-native model with a device execution platform.

Jev provides the intelligence and mobilerun provides the device.

The result is an agent that doesn't need to generate a long explanation before every tap. It can observe the phone, make a structured decision, execute it, and continue from the new state.