Agent‑native UI compiler

Intent goes in.
Interface comes out.

ViewSpec is the compiler between your agents and your UI. Agents commit to meaning — nodes, bindings, motifs. ViewSpec owns the renderer output: deterministic, with no model call at render. HTML and React compile locally; the hosted API adds SwiftUI and Flutter.

$ python -m pip install --pre viewspec see it compile ↓
viewspec.intent.json

        
compile
rendered · html_tailwind
Monthly recurring▲ 8.2%
$48,210
Active seats1,284
Net retention112%
Churn0.9%
/ the model

Agents shouldn’t write markup. They should commit to meaning.

An IntentBundle is a semantic contract, not a template. The compiler turns it into an interface the same way every time — and can prove what it did.

Deterministic

Same intent, same bytes, same hash — on every machine, every run. No model in the render path, so output never drifts.

Portable

One bundle emits html‑tailwind and React locally; the paid API delivers four targets with hashes, provenance, and diagnostics.

Provable

Every element carries its lineage. Trace any pixel to the binding and raw data — and prove the artifact phones home to nobody.

/ one intent, every shape

The data doesn’t change. The motif does.

An agent describes a group of things. You decide whether it’s a table, a dashboard, or a gallery. Flip it — same four bindings, three renderings.

group: capabilities · motif: table · ordered 4 bindings · exactly‑once
/ style derivation

Style is a token, not a task.

Pick an aesthetic profile. The compiler re‑derives density, emphasis, rhythm, and grid from a single token — a lookup, not a redesign. This whole page re‑themes with it.

density regular · emphasis medium · columns 3
aesthetic.calm_ops · 0 hand‑written rules · Same graph, new projection from the same semantic graph
/ now look under the hood

Everything above is compiled output. Here’s the receipt.

Turn on Inspect (top‑right, or press i) and every element on the page shows the IR address it came from. Click, tap, or hover a chip below to trace one all the way back to the data.

compiled artifact · real IR ids · click/tap/hover a node
compiled artifact · aesthetic.calm_ops · scroll & hover

Agent-native app compiler

Intent goes in. Interface comes out.

Agents commit to meaning — nodes, bindings, motifs. ViewSpec compiles the UI, the state reducer, replay checks, and shell proof. Deterministic, and no runtime LLM.

replay
state replay passed
reducer
reducer generated
manifest
manifest checked
shell
shell hash matched
runtime
No runtime LLM
browser corpus
10/10 conformant
viewports
mobile · tablet · desktop
product quality
10/10 first-compile passes · 0 critical issues
semantic corrections
10/10 verified previews · 10 applied receipts
refinement gates
8/8 passed
1 · intent
Agent writes IntentBundle JSON.
2 · compile
CompositionIR to UI and reducer, no LLM.
3 · proof
Provenance, replay, and shell hash attached.
State IRinteractive_state_v0 writes state_reducer.ts and reduceViewSpecState.
Aesthetic ProfilesEight compiled projections from one semantic graph.
Proof Pipelinestate_replay_assertions plus viewspec prove-app --with-shell.
Semantic CorrectionSource-bound previews and applied receipts keep changes traceable.
Portable Surfaceshtml-tailwind and React locally; four integrity-checked targets through the paid API.
describeAuthor IntentBundle or AppBundle JSON.
validateviewspec validate-intent fails closed on drift.
proveviewspec prove --intent compiles, checks, and renders the exact artifact.
FreeLocal SDK. Unlimited compiles, proofs, and surfaces.
Pro149/mo. Hosted compiler API, 10k calls per day.
EnterpriseCustom volume, organization sharing, and support.
provenance
Every element traces to its address.
determinism
Same source, design, and compiler version; same bytes and hash.
the entire homepage artifact, embedded live · open it full-page ↗
DOM → binding → address → data
/ trust, but verify

Then verify again, and get the same answer.

Two claims most tools ask you to take on faith. Here they’re computed on the page you’re reading.

Deterministic provenance

The provenance hash is sha256 over the canonical IntentBundle. Recompute it — identical bytes, identical digest, every time.

sha256 = computing…
match — deterministic
Provably no‑network

ViewSpec’s check gate certifies an artifact makes zero cross‑origin requests before it ships. This page holds itself to the same bar — measured live:

0cross‑origin requests

Checked core workflow · 10/10 conformant

All 10 fixed cases passed product quality on first compile with 0 critical issues, rendered at mobile, tablet, and desktop with accessibility, DOM, log, and screenshot evidence, and completed 10/10 verified semantic corrections with 10 applied receipts. Eight-gate result · Scorecard · Correction proof. Fixed-corpus evidence is not certification of arbitrary briefs or host apps.

/ exact-versioned proof integrations

Freerange and Pretext, bounded on purpose.

Two opt-in integrations by chenglou add independently reported evidence to generated react-tailwind-app proofs.

Freerange numeric proof

@chenglou/freerange@0.0.1 checks only the manifest-described generated numeric kernel and its recorded call-site hashes.

viewspec prove-app --app viewspec.app.json --target react-tailwind-app --install --freerange --json

Requires a user-installed stable Bun 1.x on PATH. ViewSpec never installs Bun.

It does not analyze CSS, prove rendered geometry, certify arbitrary math, or certify arbitrary host apps.

Pretext text proof

@chenglou/pretext@0.0.8 preserves native DOM semantics and checks only native-DOM versus Pretext line count and overflow with named Arial, sans-serif.

viewspec prove-app --app viewspec.app.json --target react-tailwind-app --install --pretext --json

Runs at 390×844, 768×1024, and 1440×1000 in Chromium. No Bun required.

It is not general typography proof, canvas-rendering proof, pixel-perfect visual regression, accessibility certification, or arbitrary-host certification.

Compose, don’t expand: viewspec prove-app --app viewspec.app.json --target react-tailwind-app --install --freerange --pretext --json runs both independently reported analyses; it does not broaden either guarantee. Dedicated hosted E2E is configured for relevant pushes and pull requests, a weekly schedule, and manual dispatch; this does not claim that a hosted run has completed.

/ pricing

Start local. Add the hosted compiler when teams need it.

The free SDK stays offline and deterministic. Hosted plans add shared compilation capacity, organization controls, and support around the same proof pipeline.

Free

Free local SDK

$0 / forever

Build, compile, and prove ViewSpec artifacts locally without an account.

  • Unlimited local compile runs
  • HTML and React emitters
  • Proof bundle and shell checks
  • 500 hosted compile calls/day trial
Enterprise

Enterprise support

Custom

Scale ViewSpec across internal agent products with support and controls.

  • Custom compile volume
  • Organization sharing and policy gates
  • Private deployment support
  • Launch and migration help

Pricing is intentionally simple: the compiler remains useful locally, while hosted capacity adds API volume, richer derivation, custom motifs, portable artifacts, receipts, and support.

Compile your first interface in a minute.

No account, no network, no LLM key. Install the SDK, write intent, prove the output.

$ viewspec prove --intent viewspec.intent.json --target react-tailwind-tsx --install read the docs → Try the one-minute proof →
Get ProTalk to us
inspecting