Browser AI From First Principles — AI Experiences

This collection grows with the book. A chapter receives a Run with Browser AI action only after its corresponding experience exists here.

Run Chapter 22: Personal Browser Policy Engine

This laboratory applies a user-owned policy to a contained sample feed. It extracts content units, excludes sensitive regions, normalizes evidence from interchangeable providers, compiles deterministic rules and changes presentation locally.

Every hide, blur, label and prominence change is reversible. No decision alters source content, leaves the page or claims to determine whether content was generated by AI; that specific evidence problem begins in Chapter 23.

Run Chapter 21: Human Authority Boundary

This laboratory converts a model proposal into a normalized effect the user can inspect. Approval is short-lived, bound to the proposal digest, origin, tool identity and policy version, and consumed once.

All execution is a labelled in-page simulation. The authorization machinery is real; email, publication, file, clipboard and network effects are deliberately absent.

Run Chapter 20: Prompt-Injection Containment Laboratory

This laboratory deliberately places hostile page text, tool metadata and tool results beside executable capability proposals. It reports model-layer compromise and system-layer containment as different outcomes.

No consequential tool can execute here. Read-only book operations use a fixed in-page index; export, publication and wider-site operations are denied or withheld pending the explicit human authority boundary built in Chapter 21.

Run Chapter 19: Tool Choice Behavioral Evaluator

This evaluator turns tool choice into six observable stages. It includes positive, negative, refusal, clarification, no-tool and empty-result fixtures alongside controlled competitors and optional catalog pressure.

The live path supplies the catalog to Chrome’s Prompt API as experimental context; it does not claim automatic WebMCP discovery. Deterministic specimens remain runnable when the Prompt API is absent, and every tool implementation is an in-page read with no network or external effect.

Run Chapter 18: WebMCP search_book Laboratory

This laboratory exposes the Chapter 17 search_book contract through the browser’s imperative WebMCP surface when the current context supports it. Registration, replacement, removal and callback invocation receive distinct trace events and correlation IDs.

The deterministic simulator is a separate button and a separate evidence source. It can test the contract on any browser, but it never claims that Chrome registered or exposed the tool.

Run Chapter 17: Capability Contract Workbench

This workbench compares two interfaces to the same page: ambiguous controls intended for people and an explicit capability intended for software. It records the complete lifecycle of a bounded, read-only search_book invocation.

The capability is an application-provided specimen, not a live WebMCP registration. Chapter 18 will connect the same contract to the browser API. DOM-derived and visual routes remain inspectable here, but the laboratory never actuates them.

Run Chapter 16: Structured Output Firewall Laboratory

This laboratory puts a deterministic firewall between model-produced JSON and the Chapter 15 job contract. Run live constrained or unconstrained Prompt API generation when supported, or load a specimen that isolates one failure stage.

Nothing here executes an external job. A candidate can reach only an in-memory dry-run preview after it passes every deterministic gate and you explicitly authorize its exact fingerprint.

Run Chapter 15: Fallback Router and Local Worker Coordinator

This experience separates product fallback from experimental job routing. The first half chooses a route without silently moving protected content across a network. The second half demonstrates the validated contract a localhost coordinator can share between POST /v1/jobs and an atomic inbox/*.json directory workflow.

The worker pool and queue are an in-page simulation. The page neither watches an arbitrary directory nor contacts a remote AI service. Its output is the versioned job, routing and lease evidence needed to build that local service honestly.

Run Chapter 14: Feature Evaluation and Release Gate

This laboratory turns the book’s seven Browser AI interfaces into one canonical smoke suite. It keeps raw repetitions, joins operational and behavioral evidence by run ID, compares every current outcome with a deterministic non-AI baseline, reports slice results and computes a small risk-based release gate.

Human rubrics remain pending until a reviewer decides them. A high aggregate score cannot hide a new authority or permission failure.

Run Chapter 13: Validation Pipeline Laboratory

This laboratory makes success layered and visible. Run one live Prompt API candidate or load a clearly labelled deterministic specimen, then inspect parsing, schema checks, protected semantic invariants, human review, the feature decision and the final authority boundary.

Generated text and later judgments remain separate records. A completed prompt can therefore be rejected, abstained from or accepted without rewriting the original evidence.

Run Chapter 12: Model Contract Compatibility Laboratory

This laboratory runs a fixed feature contract through several explicitly versioned Prompt API option profiles. It records availability, creation, progress callbacks, prompt behavior and destruction separately, because a browser-managed runtime can accept one boundary and reject the next.

The deliberately non-deterministic profile is never included in the compatible suite. It runs only through its own explicit probe and preserves the current browser’s exact acceptance or rejection rather than treating a historical error as a permanent universal rule.

Run Chapter 11: Latency Decomposition Laboratory

This laboratory decomposes browser AI latency instead of reporting one stopwatch value. Label the operating condition, create a measured session, run the first fixture, repeat the identical fixture while warm, and test cancellation separately.

The reviewed replay contributes session creation and progress-callback evidence only. Its missing first-chunk, completion and validation values remain missing.

Run Chapter 10: Context Budget Laboratory

This laboratory makes context pressure visible before failure. It measures or estimates the next input, preserves an output reserve, runs a bounded sequence of deterministic turns, and stops when application policy says the next operation is unsafe.

Compaction creates an inspectable checkpoint and a separately identified replacement session. The reviewed replay proves only an initial quota of 9,216 with zero usage; it contains no prompt delta, overflow or compaction evidence.

Run Chapter 09: Session Lineage Laboratory

This laboratory exposes a Prompt API session as an owned resource with identity, history, finite context, lineage and an explicit end. Establish one shared fact, clone the resulting session, then apply different interventions to the original and clone.

The reviewed replay proves that one Chrome 152 run created a clone-capable, destroy-capable session with a reported quota of 9,216. It contains no completed prompt, clone or destruction event, so those states remain unobserved until a live run produces them.

Run Chapter 08: Language Routing Laboratory

This laboratory composes two browser-managed capabilities without collapsing them into one magic “translate” button. Detect a ranked candidate list, inspect confidence and margin, apply an explicit selection policy, and only then inspect the exact Translator pair.

The reviewed replay contains Prompt API session evidence only. It remains available as historical evidence and is never presented as a Language Detector or Translator run.

Run Chapter 07: Text Authority Laboratory

This laboratory runs the three canonical Observatory fixtures for Writer, Rewriter and Proofreader. Select an operation to see its authority level, options, source/request distinction and evaluation contract before creating a browser-managed instance.

The replay trace contains none of these task APIs. It remains available as earlier Prompt API evidence and is never presented as a Writer, Rewriter or Proofreader result.

Run Chapter 06: Summarization Contract Lab

This laboratory runs the canonical Chapter 06 fixture through the browser’s Summarizer interface. Change the summary type, format, length or preference, then create a session and compare structural checks with the unresolved human rubric.

The reviewed replay predates a successful Summarizer run and contains Prompt API session evidence only. It remains available for provenance, but it is not presented as summarization evidence.

Run Chapter 05: Browser AI Switchboard

This experience inspects the Prompt, Summarizer, Writer, Rewriter, Proofreader, Translator and Language Detector interfaces in the current browser. Each availability call receives the options declared for that particular API.

The matrix reports exposure and operational availability separately. It does not infer that the interfaces share one downloaded model or that one available API implies the others are available.

Run Chapter 04: Instrument the Application

This experience exercises the contract that turns an extension-owned prompt console into an application-aware debugger. Emit a metrics-only application event through window.postMessage, watch the local contract validator accept it, and try a malformed envelope to see it rejected.

When the Browser AI Observatory extension is loaded and instrumentation is enabled for this origin, the same valid event can continue through the installed bridge into the DevTools panel. The page deliberately cannot claim that the extension received it; confirmation belongs in DevTools.

Run Chapter 03: Browser AI Observatory

This chapter experience is the web-page counterpart of the DevTools extension built in Chapter 03. It runs the same inspect → create → prompt → trace workflow and summarizes the measurements produced by the event stream.

The page observes only work that it initiates. It does not claim access to private Prompt API calls made by other applications. The complete extension source is in the Browser AI Observatory directory.

Run Chapter 02 with Browser AI

This experience turns Chapter 02’s availability model into an observable state machine. Inspect the current browser, explicitly prepare a session, run a chapter-grounded prompt and see each state supported by the events the page actually receives.

If live Prompt API execution is unavailable, replay the reviewed Chrome trace. Replay is visibly labelled and never presented as evidence from the current browser.

Run Chapter 01 with Browser AI

This is the first chapter-specific Browser AI experience. It checks the capability boundary in the page’s real top-level context, prepares a local session only after an explicit click and records metrics-only evidence.

If the Prompt API is unavailable, replay the captured Chrome trace and continue through the same explanatory interface.