# Expo Exact: Agent-Native Cross-Platform UI With Contract

> Source: <https://explainx.ai/blog/expo-exact-contract-agent-native-cross-platform-runtime-2026?utm_source=rss&utm_medium=feed&utm_campaign=blog>
> Published: 2026-11-11 00:00:00+00:00

**Expo published [Exact](https://github.com/expo/exact?ref=explainx) as a cross-platform runtime built for coding agents, and developers on Hacker News put it above 130 points on November 10, 2026.** The repo gained more than **2,100 stars** within days of creation. Exact asks you to write **Contract** for interface structure, **TypeScript or Rust** for data, and one **`scripts/agent.mjs` driver** to build, run, screenshot, and test the same app on **web, macOS, iOS (Simulator or device), and Linux** without embedding the UI in a webview on Apple platforms.

This is not another React Native release. It is Expo experimenting with **agent-native developer experience**: deterministic clocks, contract tests that do not fork per platform, and compiler diagnostics aimed at machines first.

## TL;DR

| Question | Answer | 
|---|---|
| UI language | **Contract** (declarative; no arbitrary code in view files) | 
| Logic | **TypeScript** (Hermes bytecode on native) or**Rust** | 
| Web | ~ **20 KB** runtime ES module, real DOM | 
| Native hosts | Rust runner + **Taffy** CSS layout + AppKit/UIKit or Linux GPU painter | 
| Agent API | **10** operations: tree, screenshot, tap, type, state, layout, logs, clock, prefer, perf | 
| Status | **Pre-1.0** , no stability promise | 
| Stars (Nov 11) | **2,155+** on GitHub; HN thread id**50433541** | 

## Three design principles (from the README)

Expo documents Exact around **agent native**, **speed**, and **write the web, ship the platform**.

**Agent native** means the default customer is an autonomous coding agent, not only a human typing in an IDE. The README claims a predecessor agent API grew to eighty wire names; Exact intentionally keeps **ten**. Between operations **nothing animates** unless the agent advances a seekable clock (`clock +60000`, `clock settle`), which removes flaky `sleep()` in tests.

**Speed** targets include **100 ms** cold start to first frame (p50), **100 ms** dev reload after edits, and **no app JavaScript before first pixel** on native hosts because TypeScript compiles to Hermes bytecode at build time while the first frame comes from baked plan data.

**Write the web, ship the platform** means you author **CSS vocabulary and layout**, while controls, typography, motion, and accessibility come from each platform unless you override them. On layout disputes, **Chrome is the parity oracle** for native hosts.

For background on Expo's agent tooling elsewhere in the stack, see [Expo Skills for Claude Code and Codex](https://explainx.ai/blog/expo-skills-official-ai-agent-skills-expo-router-eas-claude-code-codex-install-guide-2026) and [Addy Osmani's agent skills production pack](https://explainx.ai/blog/addy-osmani-agent-skills-production-pack-github-trending-2026).

## How the architecture fits together

Exact splits responsibilities the way a browser does, but compiles ahead of time:

| Piece | Role | 
|---|---|
| `contract/` | Four-pass compiler: syntax, types, analysis, lowering to a **plan** | 
| `runner/` | VM executing the plan: keyed components, events, seekable timers | 
| `kernel/` | Columnar node arena + patched **Taffy** for CSS layout | 
| `host/web` | DOM glue (~20 KB runtime module) | 
| `host/apple` | AppKit/UIKit via static library C ABI | 
| `host/linux` | DRM/KMS or offscreen GPU painting | 

Data crosses a **single seam**: TypeScript on Hermes (native) or browser JS (web), Rust native modules or Wasm on iOS and web, with **grants** gating network, files, SQLite, and secrets. Optional GPU, Markdown, and SQLite pieces load as separate artifacts so unused features do not inflate core builds.

Rust toolchain and Contract compile path for Expo Exact native hosts and web DOM delivery

## Quick start (verified command paths)

The README documents macOS on Apple Silicon; Linux supports web and Linux host loops.

1. `git clone https://github.com/expo/exact.git`
2. `bun scripts/exact.mjs setup` once (Rust toolchains, pinned Hermes bundles, Binaryen, lockfile crates)
3. Web demo: `bun host/web/dev.mjs` serves Caltrain at`http://127.0.0.1:8765/`
4. Agent drive: `bun scripts/agent.mjs web tree "tap change-station" "type station-search Palo" state "screenshot out.png"`
5. New app: `bun scripts/exact.mjs new ../hello` then`bun exact.mjs web`

First native builds can take **10–15 minutes** on a laptop; incremental builds drop to **1–2 minutes**. The README records a **57-minute** end-to-end agent run (October 4, 2026) that passed tests on web, macOS, and iOS Simulator for a to-do app, with **~25 minutes** of that in first macOS and iOS compiles.

## Contract in one screen

Contract describes **what renders and which mutations exist**; it does not fetch or execute arbitrary code. Data sources answer network and persistence questions under capability grants.

The README ships a complete to-do example: keyed list state, `app.ts` data handlers, and `app.test.contract` exercising add, check, and delete flows. That trio is the mental model: **view file**, **logic file**, **agent test file**.

Compared with [Slint](https://github.com/slint-ui/slint?ref=explainx), which HN commenter **ogoffart** noted shares Rust plus declarative DSL DNA, Exact optimizes for **web-speed iteration** and **agent clocks**, not multi-year widget maturity.

## What works and what does not (November 2026)

**Works (per README):** web, macOS, iOS Simulator or device via Xcode **27.1+**, Linux console or headless builds, parallel agent testing, Hermes offline installs via Ibex bundles, feedback diary opt-in to Expo.

**Gaps (per README and HN):** **Windows** and **Android** hosts are roadmap items; **no releases** tag yet; **no backwards compatibility** promise; documentation tone is explicitly **agent-first**, which frustrated some human readers on HN.

Agent-driven UI verification workflow for Expo Exact Contract test files

## What developers are saying on Hacker News

The thread at [HN item 50433541](https://news.ycombinator.com/item?id=50433541&ref=explainx) mixed excitement with skepticism:

- **doodlesdev** ([50434172](https://news.ycombinator.com/item?id=50434172&ref=explainx) ) called Exact "absolutely huge" if Expo proves agent-driven native UI, but warned of gritty layout and interactivity details ahead.
- **henry-hong** ([50438064](https://news.ycombinator.com/item?id=50438064&ref=explainx) ) praised agents that**look at screenshots** across platforms; Exact's driver is built for that loop.
- **ogoffart** ([50436561](https://news.ycombinator.com/item?id=50436561&ref=explainx) ) compared the design to**Slint** , noting Slint's maturity versus Exact's agent-first tooling.
- **jdthedisciple** ([50436854](https://news.ycombinator.com/item?id=50436854&ref=explainx) ) argued cross-platform claims ring hollow without**Windows** , a recurring theme when enterprise buyers evaluate agent UI stacks.
- **mrbombastic** ([50434617](https://news.ycombinator.com/item?id=50434617&ref=explainx) ) joked about "agent-first DX" pushing humans aside; Exact's README embraces that positioning openly.

Treat star counts and HN points as **attention**, not maturity proofs.

## How Exact compares to Electron and React Native paths

| Approach | UI fidelity | Agent testability | Maturity (Nov 2026) | 
|---|---|---|---|
| Electron / web shell | Web tech everywhere | Playwright-style, one DOM | Production proven | 
| React Native + Expo | Native components via bridge | Detox, Maestro, custom | Production proven | 
| **Exact** | Native draw per platform, shared Contract | Built-in `agent.mjs` + contract tests | Pre-alpha experiment | 

Exact bets that **agents close the last mile** on three native hosts while humans keep CSS mental models. If you only ship a marketing site, that is overkill. If you want agents to **prove** multi-host widgets nightly, the integrated driver is the differentiator.

## Risks and licensing notes

- **Churn:**`rules/DEFERRED.md` states features may disappear without migration paths.
- **Rebuild lineage:** README calls this repo**exact2** , a rebuild of earlier Exact work; research imports under`llp/research/` are not authoritative specs.
- **Feedback telemetry:**`bun exact.mjs feedback` can send friction notes to Expo's worker endpoint when projects opt in;`EXACT_FEEDBACK=0` disables sends.
- **Agent hype backlash:** Teams allergic to "Claude-speak" README prose should still read`docs/start-here.md` , which the repo marks as the single required agent onboarding doc.

## Toolchain and dependency pins (what agents must install)

The README is explicit about versions because agent-driven setups fail silently on drift:

| Tool | Requirement | 
|---|---|
| Rust | `rust-toolchain.toml` stable pin; first`cargo` run bootstraps it | 
| Bun | **1.4.2** per`package.json` ; README documents isolated`~/.bun-1.4.2` install | 
| Chrome | Headless driver for web agent ops; override with `CHROME` env | 
| Xcode | **27.1+** for Apple hosts;`exact setup --check` validates | 
| Hermes | Ibex **260318099.0.4** bundles for host and iOS targets via installer crate | 

`bun scripts/exact.mjs setup` also pulls wasm-bindgen, Binaryen, nightly Rust components for game web bakes, and offline crate caches for Exact and bundled game SDK locks. Agents should treat a failed setup as **blocking** before writing Contract: partial installs produce confusing compiler errors that burn context windows.

Hermes installs land under `~/.cargo/hermes-lean-sys/` with attestation verification. The README stresses ordinary builds stay offline once bundles exist, important for air-gapped CI trying to replicate agent success stories.

## Contract compiler affordances for agents

Humans benefit from the same JSON diagnostics agents consume:

- `contract build --json` returns stable error ids and source ranges suitable for fix loops.
- `contract symbols` supports navigation queries so agents do not grep blindly through generated artifacts.
- Development source maps tie on-screen nodes back to Contract source lines.

Those interfaces mirror why [Janestreet's agent skills](https://explainx.ai/blog/janestreet-agent-skills-socratic-tutor-github-2026) and [Vercel's agent-browser CLI](https://explainx.ai/blog/vercel-labs-agent-browser-rust-cli-snapshot-refs-accessibility-tree-github-trending-guide-2026) emphasize **machine-readable errors**: without them, autonomous retries oscillate.

## Example apps and templates in the monorepo

Beyond Caltrain, the repository ships runnable references agents can copy:

- **`examples/calendar`** and other` apps/` targets for host integration patterns.
- **`exact-templates`** marketing mentions**Softwear** , a generated apparel storefront demo (not a real merchant).
- Markdown viewer tooling via `exact run markdown README.md` for dogfooding docs inside Exact hosts.

When evaluating Exact, start from `exact new` scaffolding (Contract + `app.ts` + `app.test.contract`) rather than porting a mature React Native screen one-to-one. The runtime assumes you accept Contract's refusal-oriented semantics: invalid writes should **fail loudly** with remediation text, a style closer to Rust than to permissive JSX.

## Performance claims and how to verify them

README cites internal LLP notes for web benchmarks (for example Conduit vs React SSR hydration time and bundle size comparisons). Treat them as **vendor engineering notes**, not independent benchmarks, until Expo publishes reproducible scripts.

Your team can still partially verify locally:

1. Run `bun host/web/dev.mjs` and measure reload time after a one-line Contract edit (README reports ~99 ms on a fresh app).
2. Capture `bun scripts/agent.mjs web perf` outputs after setup (operation exists in the ten-op API).
3. Compare cold-start video captures across hosts with the agent screenshot film syntax documented in Quick start.

Document hardware whenever you post results; Mac Studio versus laptop thermals change compile timelines dramatically.

## When to try Exact this week

| You should experiment if… | Wait if… | 
|---|---|
| You run agents that break UI on iOS vs web | You need Windows or Android today | 
| You want contract tests without per-platform forks | You require stable semver APIs | 
| You already use Bun + Rust + Xcode in CI | You cannot absorb 15-minute first native builds | 

Pair a spike with [loop engineering for coding agents](https://explainx.ai/blog/loop-engineering-coding-agents-claude-code-guide-2026) so agent retries do not burn unbounded compile minutes.

## Related reading on explainx.ai

*Repository layout, star count, and platform support reflect the [expo/exact README](https://github.com/expo/exact?ref=explainx) as read on November 11, 2026.*