Morph

Morph is an AI accessibility compiler that turns complex websites into adaptive interfaces, then safely operates and verifies the original site.

Comment

Morph

Recompile the live web around the goal you have right now.

Morph is an installable personal web-experience compiler. It observes the live page a person is already using, accepts a natural-language goal, and compiles a materially different, task-focused interface while keeping the original website authoritative.

Inspiration

Websites are designed once for an imagined average user, but a person's goal, context, language, attention, and accessibility needs constantly change.

Chat assistants usually answer beside the page without changing the experience. Browser agents can act on the page, but their authority and success can be difficult to inspect. We wanted a third model:

Generate a better experience from the live web while keeping source truth, user authority, and verified actions separate from model generation.

Accessibility was our first proof cohort because interface mismatch is especially costly there, but Morph is designed for anyone who needs the current web to become a better interface for the task in front of them.

What it does

The user invokes Morph on the current Chrome tab and describes the experience they need.

Morph then:

  1. Observes semantic structure, text, repeated groups, values, controls, status regions, provenance, privacy, volatility, and unsupported surfaces into a bounded, revisioned WebIR.
  2. Selects only bounded, task-relevant public evidence.
  3. Uses GPT-5.6 to compile a strict, source-grounded ExperienceSpec.
  4. Validates every generated source reference against the current observation.
  5. Projects a focused comparison, learning, reading, or task experience.
  6. Keeps generated presentation visibly separate from source truth.
  7. Requires explicit confirmation before any allowed source mutation.
  8. Re-observes the live page before execution and binds only when exactly one valid control remains.
  9. Re-observes again after execution and reports success only when the expected semantic effect is verified.
  10. Lets the user reveal any result back on the original source.

The model has no browser tools or action authority. An accepted ExperienceSpec cannot contain JavaScript, selectors, URLs, browser commands, credentials, forms, or executable instructions. Invalid output is rejected before projection or execution.

Submission demo

The final demo begins on the public Wikipedia Main Page with this Korean goal:

현재 공개 백과사전에서 검색창에 generative interface accessibility 값을 입력해 검색하고, 검색 후 새로 관찰한 결과를 관련도 순으로 최대 다섯 개 보여줘. 검색 실행 전에 입력할 값과 누를 control을 보여주고, 문서 생성·수정·로그인은 하지 마.

Morph observes the current page and proposes:

  • Value: generative interface accessibility
  • Input: Search Wikipedia
  • Control: Search
  • Risk: low-risk public search
  • Explicit exclusions: document creation, editing, login, account, purchase, and subscription actions

Nothing happens until the user confirms.

After confirmation, the trusted runtime performs a fresh preflight, binds exactly one live input and one live button, executes the search on the original page, waits for the result collection to settle, verifies the semantic change, renders at most five current results in source-provided order, and reveals one exact result back on the source page.

The final acceptance evidence contains three consecutive isolated packaged-Chromium runs using the real GPT-5.6 provider. Compile-to-ready timing was:

  • Run 1: 19.055 seconds
  • Run 2: 18.796 seconds
  • Run 3: 16.672 seconds

Every run produced five current source-bound results, fresh post-action verification, and exactly one successful source-reveal candidate.

The video is explicitly edited for clarity rather than presented as uninterrupted real-time playback. Actual receipt timings remain visible on-screen.

How we built it

Packaged Chrome extension

Morph is a TypeScript Manifest V3 extension using explicit activeTab admission. The extension owns current-tab observation, the packaged opaque renderer, and execution of runtime-authorized browser commands.

Trusted runtime

A Node.js runtime is the sole owner of:

  • Session and page identity
  • Observation revisions
  • Provider lifecycle
  • Source-action lifecycle
  • Fresh binding and preflight
  • Re-observation
  • Expected-effect verification
  • Machine-readable outcome receipts

The UI can display runtime truth, but it cannot independently claim that an action succeeded.

Model boundary

GPT-5.6 is a load-bearing runtime component rather than decorative copy generation. Comparison, learning, reading, task, and selected-source aids are implemented and exercised by deterministic gates.

The final real-provider submission proof is deliberately narrower: three isolated executions of the public-search task hero.

Generated reading HTML and CSS are treated as untrusted presentation data. They are schema-validated, sanitized, and rendered inside an opaque, networkless sandbox without forms, scripts, navigation, popups, downloads, or same-origin access.

Codex contribution

Codex was the primary implementation collaborator throughout Build Week. It helped translate owner-approved product and security contracts into strict TypeScript owners, establish real-browser RED gates, implement the extension/runtime/provider bridge, reproduce race conditions, red-team refusal behavior, build packaged and metamorphic tests, and collect executable evidence.

Human product and risk decisions remained with Hee, including the product thesis, authority boundaries, allowed presentation plane, action policy, and final submission hero.

Challenges

The hardest problems were not visual generation.

They were:

  • Observing useful semantic structure without production branches for specific websites
  • Keeping provider evidence bounded and source-grounded
  • Preventing generated presentation from becoming an execution or exfiltration surface
  • Rebinding controls after live navigation without selecting the first plausible candidate
  • Handling Manifest V3 worker lifecycle and current-tab admission races
  • Distinguishing a browser acknowledgement from a verified user-visible result
  • Preserving provenance when returning from the generated experience to the original source

Morph fails closed when a control is missing, ambiguous, stale, unsupported, or unverifiable.

Accomplishments

  • Built one reusable observer/compiler/runtime pipeline without target-specific production selectors
  • Delivered a real public set_text → activate → re-observe → verify flow
  • Verified the submission hero in three consecutive isolated real-provider runs
  • Rendered five current source-bound results and exact source reveal
  • Added schema, sanitizer, stale-state, ambiguity, verification-mismatch, and provider refusal paths
  • Passed 132 unit tests, 16 architectural boundary tests, 10 browser E2E tests, packaged MV3 tests, accessibility automation, and a five-case metamorphic corpus
  • Scanned production files for target/domain/selector hardcoding with zero violations
  • Produced machine-readable receipts that bind the video, source fingerprint, and final browser evidence

What we learned

Generative UI is an authority problem before it is a rendering problem.

A useful experience compiler needs a trusted control plane around the model:

  • Which observation is current?
  • Which facts came from the source?
  • Which text was generated?
  • Which exact action did the user approve?
  • Does exactly one live target still match?
  • Did the original page actually change as expected?

Honest incompleteness is more useful than plausible fabrication. If Morph cannot observe or verify something, it should expose that limitation instead of inventing success.

What's next

  • Reduce model compilation latency
  • Expand semantic coverage for dialogs, disclosures, forms, and dynamic SPAs
  • Run user studies measuring task time, error rate, fatigue, comprehension, and source-return success
  • Add manual assistive-technology and lived-experience review
  • Broaden reversible actions only after each policy and verification slice is independently approved
  • Develop an account-free hosted interactive provider path for easier judging and distribution

Try it

Account-free verified demo:
https://hee55e.github.io/morph-build-week-test-build/

Verified Windows judge build:
https://github.com/hee55e/morph-build-week-test-build/releases/download/v2026.07.22/Morph-Build-Week-Test-Build.zip

The account-free page is an evidence viewer, not a simulated live provider. Optional interactive compilation requires Windows, Chrome, the packaged extension, and the judge's own ChatGPT account for the official Codex device-login flow.

Honest limitations

Morph is a bounded working prototype, not a universal-site, release-readiness, multi-browser, or WCAG/ADA compliance claim.

The final real-provider submission proof covers one public Wikipedia task journey. Other experience families have deterministic evidence but are not represented as additional real-provider submission claims.

CAPTCHA, DRM, inaccessible canvas, cross-origin frames, private or sensitive pages, truncated observations, ambiguous controls, stale state, and unverifiable effects can stop an experience explicitly.

Browser TTS playback is not claimed: the current environment reports platform synthesis-failed, which Morph surfaces as TTS_ERROR instead of faking success.

Built With

Share this project:

Updates