UNIV Deploy

Most “deploy anywhere” products ask you to trust the promise. UNIV Deploy lets a browser agent challenge the promise before it deploys anything.

It is for platform, release, and security teams that want agents to move reviewed software across runtimes without handing those agents a shell, upload endpoint, or arbitrary code execution. The agent discovers five typed WebMCP tools and works through a visible, stateful deployment contract.

First, UNIV compiles one closed deployment intent against machine-readable target passports. The result is a finite portability frontier, a compatibility certificate for each target, and a distinct execution capsule for every compatible target. A separate deterministic verifier rechecks each certificate and capsule. Only verified, digest-bound capsules can enter the five-minute handoff.

The demo starts adversarially. The agent asks UNIV to compile network-bound-release-v1. Both registered targets forbid guest networking, so the compiler returns an empty frontier, emits no capsules, names guest-network as the counterexample, and makes handoff impossible. The agent then chooses portable-release-v1. That intent compiles into two verified capsules and executes on two deliberately different real targets: browser-wasi in the browser main thread and sites-edge-wasi on the OpenAI Sites / Cloudflare Workers edge.

UNIV still does not call the workload portable merely because both capsules exist. It waits for both executions, compares the declared observation contract, and returns a runtime portability witness only when both target receipts report the same manifest, component, status, workload ID, and output digest.

WebMCP is essential because this is a consequential multi-step operation with opaque proof artifacts. Without WebMCP, an agent would scrape controls and manually shuttle IDs and digests between screens. Here, it can discover the closed contract, compile an intent, carry the exact handoff ID and digest into deployment, and retrieve evidence by ID. The person watching sees the same compiler result, capsules, receipts, refusal, and activity. The timeline says via WebMCP only when a registered page tool actually ran; human controls remain via human.

The public interface accepts no uploaded components, arbitrary bytes, paths, URLs, shell commands, native executables, container images, host settings, or free-form guest arguments. The manifest, source component, and generated core modules are SHA-256 pinned. Browser module hashes are observed before compilation. The edge receives statically imported modules pinned by manifest and CI; because Workers do not expose those module bytes for runtime re-hashing, the receipt labels that fact build-pinned rather than observed.

In the verified public run on September 3, a ChatGPT in-app browser agent first produced the empty-frontier counterexample, then compiled and deployed the permitted intent, retrieved evidence 7cc5409e-d9d1-4cb4-b3a4-2bbbec6b15e4, and received univ.deployment-receipt/v2 with source: WebMCP. Both actual targets terminated and returned output SHA-256 a928646501fcc69ed8af413859d43d4b887f3be150c452696700e393d8e338f5. The runtime witness reported equivalence over the declared observations.

UNIV existed before the challenge as a broader Rust portability project. During the submission period I created this clean WebMCP product surface and, for v2, turned the theoretical proof-carrying deployment idea into a running compiler, independent verifier, target passports, execution capsules, bounded witness, public CI gate, production deployment, and reproducible evidence. The inherited daemon, worker, native, OCI, upload, shell, QEMU, and unrelated role-adaptive-agent files are not included or exposed.

UNIV Deploy does not claim universal execution over arbitrary software or hosts. Its claim is deliberately falsifiable: one closed intent is portable across the registered passports only when every compile-time proof passes and every executed target agrees over the named runtime observations. It is not independent attestation or a production cloud orchestrator. It is a working demonstration of agents and people replacing a vague portability promise with a proof-carrying deployment and a reviewable receipt.

Built With

• cloudflare-workers
• github-actions
• openai-codex
• openai-sites
• react
• rust
• typescript
• wasi-preview-2
• webassembly
• webmcp