Exact: Expo builds a framework for the agent first
TL;DR
Expo published Exact on November 9, 2026: a pre-alpha, MIT-licensed app runtime written in Rust. You write the interface once in Contract, a small typed language, and it runs as real DOM on the web, AppKit on macOS, UIKit on iOS and a GPU painter on Linux, with no webview and no React. Its agent driver has ten operations that work the same on every host, a clock the agent controls, and tests that run unchanged on each platform. Android and Windows are early, app code can't import npm packages, and nothing is stable.
Expo co-founder Charlie Cheever today shared a preview of Exact, which he calls an agent-native app framework written in Rust. The benchmark claims will get the attention, but the part I’d read first is the agent driver and the one-page rules/RULES.md. Together they are the most complete answer I’ve seen to a question every team running coding agents has: how do you let an agent verify its own work on a real device, fast, without the project drowning in what the agent produces?
Exact is not a new version of Expo or React Native. It is a separate, MIT-licensed runtime with its own language, its own layout kernel and its own hosts for the web, macOS, iOS and Linux. Expo calls it pre-alpha.
One Contract file becomes a plan that every host runs
An Exact app has two halves. The interface lives in app.contract: shapes, components, state, actions and a view, written in a small declarative language. The data lives in app.ts or a Rust crate, behind what the docs call the data seam. The Contract compiler turns the interface into a compact plan of tables and bytecode, and bakes constant data into it, so the first frame needs nothing else.
What happens to the plan depends on the host:
- Web. The plan compiles to one ES module over a runtime of about 20 KB that writes real DOM nodes. The browser does the layout, so the web build ships no layout engine.
- macOS and iOS. A Rust runner executes the plan, a Rust kernel computes every box with CSS rules through a patched Taffy, and AppKit or UIKit presents the result with native controls.
- Linux. The same runner and kernel, painted by the host itself with vello on the GPU or tiny-skia on the CPU, onto DRM/KMS or an offscreen buffer.
There is no webview and no JavaScript bridge in the UI. TypeScript data logic is compiled to Hermes bytecode at build time and loads after the first pixel. That is the main difference from React Native, where your JavaScript has to run before anything can appear, and from Flutter, which paints its own controls on every platform.
The design rule is “write the web, ship the platform.” You write CSS names and CSS layout, because that is what authors and models already know. Whatever you leave unsaid belongs to the platform: body text comes out at 17 points on an iPhone and 13 on a Mac, a button is the system’s button, and a pushed screen gets the system’s Back. Chrome is the parity oracle for layout, and the repo’s test for everything else is whether someone who knows the platform would notice.
Ten operations drive every host, and the agent owns the clock
The agent’s whole interface to a running app is one script, scripts/agent.mjs, with ten operations: tree, screenshot, tap, type, state, layout, logs, clock, prefer and perf. They behave the same on the web, macOS, the iOS Simulator, a physical iPhone and Linux. The README says the count is deliberate: an agent API grows one reasonable addition at a time until nobody can hold it in mind.
A drive is a list of quoted operations after the host name. From an app made by exact new, where exact.mjs wraps the same script:
bun exact.mjs agent ios tree "type new-todo Buy milk" "tap add" \
"clock settle" state "screenshot out.png"
The operation that matters most is clock. Between two operations nothing in the app moves. Animations, timers and transitions advance only when the agent says clock +60000 or clock settle. That removes the sleep-and-retry loop that makes UI automation flaky and slow, and it removes it on native hosts, not only in a browser.
Tests are scripts of the same operations. An app.test.contract file runs unchanged on any host:
test "adding an item updates the count"
expect text "count" == "0 left"
type "new-todo" "Buy milk"
tap "add"
expect text "count" == "1 left"
expect tree has "todo-1"
The rest of the toolchain is built for a machine reader as well. contract build --json returns diagnostics with stable ids and source ranges, up to twenty independent errors in one run, each saying what to write instead. A development source map leads from any node on screen back to the line that declared it. The driver refuses to drive a build that is older than its sources, and names the rebuild command. And screenshot out.png compare ref.png reports in text, node by node, where two screens differ, so the agent doesn’t have to look at either picture.
I’ve spent a good part of this year wiring agents to Android emulators, and almost all of that work is what Exact builds in here: a stable way to name a node, a way to know the screen has settled, and a test format that doesn’t fork per platform. Most frameworks leave that to a third-party tool reading the accessibility tree from outside. Exact makes it a property of the runtime.
Contract is small so an agent can’t write the bug
Contract describes what an app shows and how its state changes, and nothing else. A counter is the whole language in miniature:
component Counter
state count = 0
action add
count = count + 1
view
column gap=16 padding=16
text `${count} taps` testId="count"
button press=add testId="add"
text "Tap"
The interesting part is what it leaves out:
- No JavaScript in the view and no I/O. Expressions have no effects. State changes only inside an
action. - No loops in actions and no
await. A list is a keyedforin the view, a computation is aderive, and anything slow lives in a data source. - One seam for data. A view asks a source for a
resourceor sends it amutation. The runner checks every answer against the shape Contract declared, and grants decide whether the source may touch the network, files, SQLite or secrets. - No escape hatch. A platform widget comes in as a native module behind a hyphenated tag such as
exact-map, laid out by the kernel like any other box.
These limits are aimed at the mistakes agents make when nobody is watching. An agent can’t wire up a data race it has no syntax for. It can’t invent a size attribute either: the compiler refuses the alias and tells it the web’s spelling is font-size. Because every write is declared, every list is keyed and every value is typed, a refusal at compile time replaces a quiet misbehaviour at run time.
The docs follow the same thinking. An app’s AGENTS.md points the agent at one required guide, docs/start-here.md, and tells it not to read the long references front to back. Everything else is lookup: contract vocab <name> prints the answer for a tag, a keyword or one of 56 short recipes. That is context-window budgeting done by the framework instead of by you.
One more detail is new to me. The generated AGENTS.md asks the agent to record friction as it goes with feedback note "<what happened>": a wrong doc, a workaround, a command that took several tries. Notes stay in the app’s .exact/ folder and go to Expo only if the project says yes; the default is to ask, and EXACT_FEEDBACK=0 turns it off for a machine. A framework that collects bug reports from the agents using it is a sensible idea, and one to check your policy on before you run this at work.
Speed is a budget that is counted on every commit
Expo’s announcement leads with speed: 120 fps scrolling, near-instant startup and web performance it puts close to Astro. The repo turns that into budgets, tracked on every commit, where a regression is a P0 with a name on it.
Scroll horizontally if needed.
| Budget | Target |
|---|---|
| Cold start to interactive first frame | 100 ms p50 |
| Dev restart, edit to present | 100 ms p50 |
| App JavaScript executed before first pixel | none |
| Touch one line, rebuild that crate | 30 s |
| All blocking checks together | 65 s |
The way the startup budget is enforced is the clever part. A check called boot counts the module graph reachable before the first pixel and fails when it grows. A count can’t flake the way a timer does, so it can block a merge. Optional pieces such as the GPU canvas, the Markdown editor and browser SQLite are separate artifacts loaded on demand, never feature flags on a core crate.
The README gives two measurements. On the RealWorld “Conduit” benchmark, Exact’s web runtime was up about 300 ms before a React 19 SSR build had hydrated, with 26 KB of code against React’s 81 KB. On a fresh app, a saved Contract or TypeScript edit was rebuilt and in the page in 99 ms.
These are the project’s own numbers on its own benchmark app, and I haven’t reproduced them, so I read them as a direction. The loop is also not fast everywhere. A first native build takes ten to fifteen minutes on a laptop. In Expo’s own trial, a fresh agent took about 57 minutes to build a todo app and pass its tests on web, macOS and the iOS Simulator, and about 25 of those minutes were the first macOS and iOS builds.
RULES.md is the part I’d copy
Expo describes Contract as built by Cheever and agents, for agents. The size of the repo shows what that means. By my count on a clone of today’s commit, there are about 1.2 million lines of Rust outside vendor/, 340,000 lines of Swift and 59 apps, behind a public history of 13 commits. However much of that agents wrote, someone had to keep it shippable. rules/RULES.md is how, and it caps itself at 700 words.
The rules I’d take into any repo where agents do most of the typing:
- Budgets are trades, not limits. There are six blocking checks with 65 seconds between them. A seventh requires deleting one in the same PR. Source files stop at 1,500 lines and the working set of design documents at 15.
- Fail-fast is banned. Every check reports all its failures in one run, because a check that shows one defect per run turns N bugs into N runs. For an agent, each of those runs is a full turn.
- Nothing blocks on anything slower than 60 seconds. Slow verification runs asynchronously on separate hardware, per commit, and is attributed to the commit that broke it.
- Fix loops get three rounds. Then the agent stops and a human decides, or the target is descoped. Looping until the checks pass is ruled out by name.
- Agents remove apparatus freely and add none. An agent PR that adds a check, a script, a registry, a config file or a design doc needs explicit human approval. The stated reason: “agents produce governance faster than humans can read it.”
- A spec needs an implementer and a date, or it isn’t written.
The fleet rules are just as practical. Agents get warm, pre-provisioned worktrees, one task each, and never a fresh clone. git stash is forbidden because the stash stack is shared across worktrees and will apply one agent’s work into another’s. An agent may kill only the process IDs it recorded at launch, never by name or pattern. Anyone who has run several agents on one machine has learned at least one of these the hard way.
The asymmetry rule is the one I keep coming back to. Agents love to leave things behind: a helper script, a new lint, a markdown plan. Each one is reasonable, and together they become a repo nobody can read. Exact’s answer is to let agents delete freely and make every addition to the process a human decision. It is the same wall Omarchy hit in public last month: generation is cheap, and verification is the bottleneck.
It is pre-alpha, and the gaps are large
The README is blunt about it: the project changes daily, with no API stability, no backwards compatibility and no migration guide, by design. The list of what doesn’t work yet is long.
- No releases. There is no packaged CLI, no tags and no npm package. You work from a source checkout, and an app made by
exact newrefers to it by path. - Android is early. An app builds and runs on an emulator or a phone, and the agent driver works there, but you build the Hermes Android bundle yourself, and delivery and store packaging don’t exist.
- Windows is partial. Apps paint through Exact’s own painter. Parity with native Windows controls and delivery are unfinished.
- No npm code.
app.tsimports its own local files and only types from packages. There is no JSX or React tier, and nobody is building one. - No production code updates. Signed delivery covers plans and assets, not TypeScript or Rust modules.
- Left out of v1 on purpose. Camera access, a gesture arena, grid or masonry virtualization, a general webview and a devtools UI.
Two questions sit behind the list. Contract is a new language, so no model has seen it in training and no ecosystem exists around it. Exact’s bet is that a small language, one required guide and a compiler that says what to write instead are enough. Expo’s 57-minute run suggests that can work, but one todo app is thin evidence.
The other question is where this goes. Expo’s business is React Native tooling, and Exact has no React tier at all. Expo calls it a pre-alpha preview, shared to get users and feedback, and nothing in the repo or the announcement posts I could read says how it relates to the Expo SDK. I’d treat it as a research project from people with the credentials to run one, not as a roadmap.
Most of its ideas work without Exact
Four of them work in any stack:
- Give the agent the clock. Fake timers, disabled animations and an explicit “settle” step turn a flaky UI drive into a deterministic one. If your agent sleeps and retries, this is the first thing to fix.
- Keep the agent’s API small and the same everywhere. Ten operations and stable test ids beat a different tool per platform. The agent learns it once and the prompt stays short.
- Make checks fast, complete and countable. Report every failure in one run, keep the blocking set under about a minute, and prefer a count that can’t flake over a timer that can.
- Let agents delete, and make additions a human decision. One line in
AGENTS.mdcosts nothing and stops the slow pile-up of scripts, lints and plans.
The larger claim is harder to copy. Exact argues that the framework itself should change when the author is an agent: a smaller language, a compiler that refuses with instructions, docs sized for a context window and a runtime that can be driven and frozen. Until now, agent-native has mostly meant bolting an MCP server onto a framework designed for people. This is the first serious attempt I’ve seen to start from the other end.
Try it this week, but don’t ship on it
If you have a Mac with Xcode, Rust, Chrome and Bun 1.4.2 (the version the repo pins), try it, and let your agent do the work. The README opens with a prompt to paste into Claude Code: clone the repo, run setup once, build a todo app with exact new, write a test, and pass it on web, macOS and the iOS Simulator. Budget about an hour, most of it first builds, and watch what the agent does when the compiler refuses something.
For a look without an agent, the web loop is three commands:
git clone https://github.com/expo/exact.git && cd exact
bun scripts/exact.mjs setup
bun host/web/dev.mjs # Caltrain, at http://127.0.0.1:8765/
Edit apps/caltrain/app.contract, save, and the page reloads. Linux runs the web loop and the Linux host. For a starting point beyond todo, exact-templates has three whole apps: a chat, a port of Apple’s Landmarks sample and Softwear, a demo clothing store. Its index is candid about their state: the Landmarks port lists one of four tests passing.
Don’t put a product on it. Do read rules/RULES.md, which takes five minutes, and apps/shelf, the example the README recommends learning from. Exact may or may not become something people ship with. The rules it was built under are useful today.
FAQ
What is Expo Exact?
Exact is a cross-platform application runtime from Expo, published as a pre-alpha preview on November 9, 2026 under the MIT license. Interfaces are written in Contract, a small declarative language, and data logic in TypeScript or Rust. One source runs on the web, macOS, iOS and Linux.
Does Exact replace React Native or Expo?
No. Exact is a separate runtime with no JSX or React tier, and Expo has presented it as a preview for feedback, not as a successor to the Expo SDK. Existing Swift apps can embed Exact sessions through a package called ExactKit.
Does Exact support Android and Windows?
Partly. Android is early: apps build and run on an emulator or a phone and the agent driver works, but store packaging and delivery don't exist. On Windows, apps paint through Exact's own painter, and native control parity is unfinished.
What makes Exact agent-native?
An agent drives a running app through ten operations that are the same on every host, and it controls the app's clock, so nothing moves between operations. Tests are scripts of those operations, the compiler emits machine-readable diagnostics, and a new app's agent instructions point to a single required guide.
Can I use npm packages in an Exact app?
Not yet. An app's TypeScript can import its own local files, and only types from npm packages. Platform features come in through native modules written in Swift, Kotlin or Rust.