Spokes.wiki Search About

web-browsers-wiki

log

Synthesis — Web Browsers

The evolving thesis. Spun out 2026-07-04 from the hub consumer-ai-assistants cluster — the browser-wars roundup that completed it, plus Gemini-in-Chrome. Founding corpus is small; the domain is large and volatile.

Current thesis — the browser’s job is changing

For two decades a browser mattered because it was the on-ramp to search — the default search box was the prize, and “browser wars” meant fighting over that entry point. browser-wars-2026 argues that era is closing: as answers move to AI and tasks move to agents, the browser is becoming the surface where an AI acts on your behalf, and the contest is over whose AI that is. This is the browser-side face of the demand shift ../search-marketing-wiki tracks as ai-search-shift (discovery moving from links to model answers) — same tectonic move, seen from the client instead of the search-results page.

The axes the field sorts on

  • Assistant ↔ agent (the central axis, via ai-browser). How much the built-in AI does unattended. The assistant pole reads, summarizes, drafts, and answers across tabs but gates before consequential action — Gemini in Chrome is the canonical case (confirm-before-sensitive-action, prompt-injection protections). The agentic pole acts autonomously to finish a task — Comet, OpenAI Atlas (agent mode), Opera Neon. A product slides along this axis over time; how it guards the irreversible actions autonomy invites is the thing to watch (a live seam to agentic-tooling-wiki’s agent-guardrails discipline — reversibility as the bright line).
  • Incumbent-adds-AI vs AI-first. AI bolted into a dominant browser (Gemini-in-Chrome; Edge/Copilot) vs AI-first browsers built from the tab up (Comet, Dia, Atlas, Neon). Distribution vs clean-sheet design — the classic disruption setup, now over the assistant/agent rather than the search box.
  • Consumer feature vs developer platform (via chrome-built-in-ai). AI reaches the browser two ways: as an end-user assistant (gemini-in-chrome) and as a developer platform — Chrome’s built-in AI exposes on-device models (Gemini Nano) as web-platform APIs (Prompt, Summarizer, Translator, Writer…), so any web app can be AI-powered, not just the browser’s own panel. The incumbent’s play is two-layered. Most consequential: the platform layer is on-device — local, offline, no per-call cost, data stays put — which collapses the AI-vs-privacy opposition: an on-device model puts AI on the same footing as the privacy current (Brave/DuckDuckGo/Ladybird). So “AI browser” and “privacy browser” aren’t necessarily opposite corners once the model is local. (Cross-spoke: on-device Nano execution is llm-inference-wiki’s local-llm-stack territory; the browser API is here.)
  • Three currents, not one race (browser-wars-2026). The alternatives don’t all chase AI. Alongside the AI/agentic corner sit a privacy-first current (Brave, DuckDuckGo, Vivaldi, and the from-scratch Ladybird engine) and a productivity/niche current (Opera Air’s mindfulness, SigmaOS’s tabs-as-to-dos, Zen’s “calmer internet”). So “the browser wars” are really several simultaneous contests on different value props — AI agency, privacy, and calm/focus.
  • Business model. The AI browsers surface a pricing spread the search-funded incumbents didn’t need: Comet‘s $200/mo Max tier, Neon $19.90/mo, SigmaOS $20–30/mo, Jatter‘s optional $10/mo — subscription for the agent, versus Chrome/Safari’s ad/search-funded free model. But the roster shows a wider spread of who-pays: Atlas gives the assistant free and gates only agent mode; Brave runs a crypto-attention (BAT) model; Aside is bring-your-own model key; Ladybird takes non-profit donations (no monetization at all); Air/Zen are simply free. So “who pays for the browser” has at least six answers, not one.

The roster, populated

Ingesting the full browser-wars-2026 roster (11 browsers) sharpens four things the founding thesis only sketched:

  • The three currents blur — pure poles are rare. The cleanest signal is that AI, privacy, and productivity keep showing up together: Jatter and Aside are AI × local privacy; Brave pairs privacy with an AI assistant (Leo); Neon bundles agents with ad-block/VPN; SigmaOS folds an AI assistant (Airis) into a productivity browser. The “AI vs privacy” opposition that on-device AI began to dissolve keeps dissolving across the roster — Aside is the extreme case (a local-first, human-gated, benchmarked agent).
  • The anti-AI position is real, not just absence. Vivaldi has committed to keeping generative AI out on principle — a deliberate third stance beyond assistant and agent (the browser as a tool, not an actor). It anchors a non-AI pole with ladybird and zen.
  • Engine diversity is the fight under the fight. Almost every entrant — AI or privacy — is Chromium (Brave, Vivaldi, and most AI browsers) or WebKit (SigmaOS); only Ladybird (its own from-scratch engine) and Zen (Gecko) break the duopoly. So the loud AI contest sits on top of a quiet monoculture, and whether the boom funds independent engines (Ladybird’s bet) or deepens Chromium’s lock is the structural open question. The from-scratch impulse has a grassroots layer too (2026-08-05): Falco is a ~36k-line hobby engine in Rust — HTML/CSS/JS/layout all rebuilt from nothing, no product and no business model. It is not a browser anyone will use, but it is evidence that engine-from-scratch is not only one funded non-profit; it is also a craft/learning movement, coalescing on Rust (Ladybird’s second language too). The impulse persists without AI money or a market behind it, which is a small data point against the reading that only a funding boom can produce a non-Chromium engine. The incumbent case landed 2026-08-09 with firefox and gecko. It cuts against the framing above in a useful way: engine independence at full scale already exists and has for two decades, and it commands 3.34% of measured browsing (statcounter-browser-share, July 2026) against roughly 77% for Chromium across Chrome, Edge, Opera and Samsung Internet. So the diversity question is not “can an independent engine be built” — Gecko answers that, complete with site isolation (Fission) and its own JS engine — but “can one be paid for without the dominant vendor’s money.” That is now growth edge 5’s successor, and the spoke has no source on it.
  • Someone is finally trying to measure it. Aside‘s claim of #1 on three browser-agent benchmarks (over OpenAI/Anthropic/Browser Use) is the roster’s only attempt to quantify agentic-browser quality — self-reported, but the first crack at the evidence the field otherwise lacks (everything else here is marketing framing).

Open questions

  • Does the agentic pole actually win, or stall on trust? Autonomous “act on your behalf” browsing is the loud pitch, but Gemini’s deliberately-gated assistant framing bets the opposite. Which pole users adopt — and whether prompt-injection / sensitive-action risk caps how agentic a browser can safely be — is unresolved. (Needs sources beyond a launch roundup.) Narrowed 2026-07-28: chrome-built-in-ai-dos-donts rules out one hoped-for escape. Running the model on-device, first-party doesn’t defuse injection — Chrome’s own docs treat that output as untrusted and warn that streaming lets a payload span chunk boundaries. Locality answers the privacy objection, not the safety one, so the trust ceiling on agentic browsing has to be paid for somewhere else (gating, sandboxing, human confirmation).
  • Engine diversity. browser-wars-2026 notes Ladybird building a new engine from scratch; nearly everything else is Chromium (or WebKit on iOS). Does an AI-browser boom entrench the Chromium monoculture (fastest way to ship a browser) or fund independent engines? Two from-scratch engines now on record (ladybird funded/serious, Falco hobby/educational), both in Rust — but still no source on the economics: whether either reaches standards-conformant, daily-drivable state, and what that costs. The question is now “can a from-scratch engine become usable,” not “does anyone try.” Answered from an unexpected direction, 2026-08-07. kitesurf is a shipped non-Chromium engine funded by an infrastructure company, and the money did not come from browsing — Chromium is simply the wrong cost structure for serving agents per request. Two qualifications keep this from closing the question. It is an assembly of existing Rust components (Blitz, Stylo, Boa) rather than a from-scratch build, which is a cheaper and probably more repeatable route than either Ladybird’s or Falco’s. And its bar is lower: TodoMVC, Wikipedia and Hacker News rendering for a screenshot API, with a vendor-reported “215,000+ Web Platform Tests” that has no denominator attached. Diversity in the agent tier is now real; whether it reaches the human tier is untouched.
  • The incumbents’ real response. The roundup is alternatives-focused; Chrome (Gemini) and Safari/Edge responses are only partly here. How Google/Apple/Microsoft wield distribution is the other half of the story.

Growth edges

Ranked; each names the kind of source that would close it (see ../QUALITY.md → Growth edges).

  1. The economics of a from-scratch engine. Two independent engines are now on record (ladybird funded, Falco hobby), both Rust, and the question has sharpened from “does anyone try” to “can one become daily-drivable, and at what cost.” — needs: a funding or engineering report with headcount/timeline, or a standards-conformance measurement (T1/T2).
  2. Adoption evidence for either pole. Assistant-vs-agent is the spoke’s organizing axis and it rests on launch coverage and pricing, not on usage. — needs: a T1/T2 usage or retention measurement for an AI browsing feature — anything beyond a vendor announcement.
  3. Whether the trust ceiling is payable. chrome-built-in-ai-dos-donts rules out on-device locality as the escape from prompt injection, so the cost has to be paid in gating, sandboxing or confirmation — and nothing here measures what that costs in usefulness. — needs: a T1/T2 evaluation of an agentic browser under adversarial pages.
  4. The incumbents’ real response. Google’s, Apple’s and Microsoft’s distribution moves are half the story and only partly sourced. — needs: first-party platform documentation or announcements (T3 acceptable — these are first-party facts).

Coverage edges (added 2026-08-08, at the curator’s request for a wider backlog). These widen what the spoke covers instead of answering an open question above; one ordinary solid source closes any.

  1. Firefox and Gecko. CLOSED 2026-08-09 (research pass) — gecko from Mozilla’s platform docs (T1) and statcounter-browser-share (T3) for the position it is in; firefox and mozilla written. Successor, narrower and unmet: who pays for the independent engine. Gecko’s development has been funded largely by a search deal with the company shipping the dominant engine, and this spoke holds nothing on it. — needs: Mozilla’s financial statements, or reporting on the Google agreement’s current terms (T1/T2).
  2. The incumbents as browsers, not as AI features. Chrome appears only through chrome-built-in-ai and gemini-in-chrome; Safari and Edge have no page at all. The “incumbents’ real response” question cannot be answered against products the wiki does not hold. — needs: one page each, from release notes and platform documentation.
  3. Extensions as the contested surface. Ad blocking, agent add-ons and Manifest V3 all live in the extension layer, and no page names it. — needs: the WebExtensions/MV3 specification plus one write-up of what the migration cost blockers.
  4. A conformance scoreboard with a denominator. CLOSED 2026-08-11. interop-2026 (T1, the project’s own README) and wpt-overview-bocoup (T2) supply both halves: the denominator is 56,552 tests / 1.8M subtests, so kitesurf‘s “215,000+” is about an eighth of the subtests and the page now says so. The method matters more than the number — Interop scores only tests that pass in every browser, so a single vendor cannot move it. Successor, unmet: nobody’s engine but the incumbents’ is on the board. Interop scores Chrome, Edge, Firefox and Safari desktop runs; ladybird and Falco appear nowhere in it, and each publishes its own progress in its own units. — needs: a WPT pass rate for an independent engine measured on the same runs, or the project’s stated reason for excluding one.

The platform layer says the quiet parts

chrome-built-in-ai-dos-donts is the incumbent writing down the failure modes of in-browser AI as engineering requirements, and it lands on two of this spoke’s open threads.

On-device does not buy trust. The strongest line in the doc is Chrome telling developers to “treat all LLM output as untrusted content” and to sanitize the full combined output, not just chunks, because “malicious code could be split across updates.” This is a first-party model running on the user’s own hardware, and it is still handled as an injection source — with streaming making it worse, since a payload split across chunk boundaries defeats a per-chunk filter. So the locality-equals-safety intuition that chrome-built-in-ai contributed to the privacy current has a hard limit: local execution protects your data from the server, and does nothing about the model’s output attacking your page. That’s directly relevant to the standing question of whether prompt-injection risk caps how agentic a browser can safely be — the answer isn’t “run it locally.”

Chrome is consistent across both layers. The UX rules — never replace UI without warning, never overwrite a draft without revert or compare, ship a stepper/history, “make the user the final editor,” don’t “force an AI-generated result as the only option” — are the assistant pole restated as build requirements. The same vendor markets the same restraint in gemini-in-chrome. Whatever one makes of the strategy, it isn’t only positioning: it’s written into the developer contract too.

One recommendation doesn’t fit. The doc suggests “an artificial delay of one or two seconds if a response is nearly instant”, because perceived effort reads as trustworthiness. On-device inference removes the round-trip and the advice is to restore some of it as theatre. It’s minor and openly reasoned, but it’s guidance to misrepresent work done in order to buy confidence, sitting beside rules about keeping the user in control. Recorded, not smoothed over.

A third role: the browser as trust intermediary

The spoke has sorted the field on assistant ↔ agent — does the browser answer you or act for you. email-verification-protocol doesn’t fit either end, and reading it back against chrome-built-in-ai shows the earlier source didn’t quite either. Both are the browser holding something and brokering with it: the model in one case, your first-party session with your email provider in the other. Paged as browser-as-trust-intermediary.

EVP verifies you own an address by having Chrome ask accounts.google.com with an ephemeral key and your existing cookies, then hand the site a signed token on form submit. The issuer never learns which site asked. The site learns nothing until submission. No code, no magic link, no round trip out of the flow.

Why this is a third role and not a variation. Assistant and agent features are sold to the user — perplexity-comet at $200/mo, opera-neon at $19.90. Intermediary features are given to the web, and the return is dependency: a site that retires its OTP flow needs a browser that implements EVP and a user whose provider participates. It’s also the one capability a website can’t route around by shipping better JavaScript, because the value is precisely that the browser sees both sides and the site sees one.

It complicates the privacy current. Privacy has been the challengers’ differentiator here — brave‘s blocking, vivaldi‘s refusal of generative AI, ladybird‘s refusal of money. EVP’s privacy properties are cryptographic rather than policy commitments, and they ship in Chrome. The current needs restating: what separates the privacy-first browsers is not that they alone provide privacy guarantees, but what they are willing to give up to provide them.

And it concentrates. The spec is open — WICG, an IETF draft, DNS-based issuer delegation so any provider can join. At launch Google is the browser, the email provider and the issuer, and Gmail addresses work with no configuration. “Open standard, one implementer” holds only as long as the implementer wants it to. Same shape as chrome-built-in-ai: a genuinely useful capability that also deepens the platform gravity this spoke tracks. Watch for a second issuer, or a non-Chromium engine shipping it.

The browser nobody opens

The spoke’s thesis has been that the browser is becoming the surface where an AI acts on your behalf, and its axis measures how much the AI does unattended. kitesurf takes the premise one step further than the axis can express: Cloudflare shipped a browser with no user interface at all — no tabs, no chrome, no window — running on Workers, invoked per request through Browser Run, and tuned for context windows and token costs because a model reads its output.

Paged as agent-first-browser, a category beside the assistant↔agent axis rather than a point on it. What it changes in the thesis is the location of the acting: some of it happens in browsers nobody opens, bought by the request, where the buyer is a developer and the metrics are cost per page and throughput rather than trust and interface.

Two threads it touches without settling. Engine diversity gains its first corporately funded non-Chromium engine, for reasons that have nothing to do with winning users (see the open question above). And prompt injection is untouched: removing the human removes the last party who might have noticed a page instructing the agent reading it, which sharpens rather than eases the trust ceiling chrome-built-in-ai-dos-donts established.

Evidential standing: T3. A vendor announcement relayed by TechCrunch. The 3–7× efficiency claim is Cloudflare’s, on Cloudflare’s chosen workloads (screenshots and HTML extraction — the two tasks that most favour a cut-down engine), with no methodology published.

The one number in this domain that isn’t self-reported

Nearly every figure this spoke holds was produced by the party it flatters. Cloudflare measured kitesurf. Google measured chrome-built-in-ai. Opera priced opera-neon. StatCounter’s share figures ship with no methodology at all. The wiki has been recording that caveat page by page without having anything to contrast it against.

interop-2026 and wpt-overview-bocoup are the contrast. Apple, Google, Microsoft, Mozilla, Igalia and Bocoup run a shared test suite — 56,552 tests, 1.8 million subtests — in CI every few hours, with tests flowing both ways between the suite and each engine, and they score it on the tests that pass in every browser. A vendor cannot improve that number by shipping something first. The rule was chosen deliberately so that “everyone wins as interoperability increases” and the press cannot build a league table out of it.

Two things follow for this spoke. Conformance claims now have a denominator, which retroactively sizes kitesurf‘s “215,000+ tests” at roughly an eighth of the subtests. And the engine-diversity question gets a harder edge: the 2026 focus list is twenty ordinary platform features — dialogs, IndexedDB, scroll snap, WebRTC — on the list precisely because four mature, funded engines still disagree about them. ladybird and Falco are writing engines against that target, and neither appears on the board that measures it.

Worth noting what the shared metric costs: a score designed so that nobody loses cannot tell you which browser is better. It answers a question about the platform, not about the products this spoke spends most of its pages comparing.

Contradictions / tensions

  • Our own record on falco-browser-engine, five days apart (2026-08-10). The 2026-08-05 ingest recorded 124★/15 forks and a repository created 2026-07-31. Re-read today, the same URL reports created 2026-08-07 — two days after that ingest — with 23★/1 fork and a single push. Both readings are kept on the page. The likely cause is a delete-and-recreate, which resets the timestamp and zeroes the counts while the code continues; the code did continue, roughly doubling to ~73k lines. Recorded as inference, not as a project statement.

    The wider point is about measurement, not this project. Nearly every page in this spoke carries a star count as its only adoption signal, and this one fell 124 → 23 without anyone losing interest. The number tracks a repository object, and a repository object is not durable. On the engine-diversity thread the substantive finding survives intact and is arguably stronger: the grassroots from-scratch impulse falco-browser-engine evidences kept building through whatever happened to the repo, and the engine gained a JIT and a WebAssembly interpreter in the interval. What did not survive is the metric.

  • Assistant vs agent framing. gemini-in-chrome (the incumbent) markets restraint — an assistant that asks before acting — while the AI-first challengers (browser-wars-2026: Atlas/Neon/ Comet) market autonomy. Not a fact conflict; a genuine product-strategy fork (trust/safety vs capability) worth tracking as more sources land.

Cross-spoke adjacency

Index — Web Browsers Wiki

Catalog of every page, grouped by schema.org @type. Spine: synthesis (thesis), log.md (history), this file (catalog). Spun out of the hub consumer-ai-assistants cluster on 2026-07-04. Read synthesis first for the thesis (search→agency; the assistant↔agent axis; three currents — AI/agentic, privacy, productivity — that increasingly blur).

DefinedTerm (concepts)

  • ai-browser — a browser whose defining feature is an integrated LLM that reads/reasons/acts on web content; the founding category, split on the assistant ↔ agent axis · url
  • agent-first-browser — a browser whose only user is software: no tabs, chrome or window; page rendering sold as an API call, judged on cost per page and the DOM a model gets back rather than on trust and interface. Beside the assistant↔agent axis, not on it · category
  • browser-as-trust-intermediary — the third role beside assistant and agent: the browser holds what neither side will hand the other (the model, your first-party session) and brokers with it; sold to the web rather than the user, and paid for in dependency · role

SoftwareApplication (browsers)

Agent-first

  • kitesurf — Cloudflare‘s stateless Rust browser for agents, running entirely on Workers (Blitz rendering + Stylo CSS + Boa JS), invoked with browser=kitesurf on Browser Run. Claimed 3–7× less CPU/memory than Chromium on screenshots and HTML extraction, “215,000+ Web Platform Tests” passed with no denominator; free in beta. The spoke’s first non-Chromium engine funded by an infrastructure company rather than a browser business · source · T3 · techcrunch.com

AI / agentic

  • perplexity-comet — Perplexity’s “personal AI assistant” browser; the agentic pole made concrete (delegate inboxes/shopping/finance); $200/mo Max, cross-platform, Pause control · source · T3 · perplexity.ai
  • openai-atlas — OpenAI’s ChatGPT browser; page-aware sidecar + agent mode (gated to paid); free assistant tier; macOS-first (Oct 2025) · source · T3 · techcrunch.com
  • opera-neon — Opera’s “built to act” agentic browser; multiple task agents + MCP/CLI integration + ad-block/VPN; ~$19.90/mo · source · T3 · operaneon.com
  • aside-browser — YC-backed agentic browser; cross-site Browser Agent, local-first + human-in-the-loop, BYO model key; claims #1 on 3 browser-agent benchmarks · source · T3 · aside.com
  • jatter — privacy-first AI assistant browser; learns from your sites locally, no ad/training; freemium ($10/mo) · source · T3 · jatter.ai

Privacy-first

  • brave — Chromium privacy browser; ad/tracker blocking, BAT crypto-rewards model, Brave Search + Leo AI · source · T3 · brave.com
  • ladybird — independent from-scratch engine (not a fork), 501(c)(3) non-profit, no monetization; alpha 2026; the engine-diversity counter-note · source · T2 · ladybird.org
  • vivaldi — Chromium power-user browser (ex-Opera founder); deep customization + privacy; committed to keeping generative AI out — the anti-AI pole · source · T3 · vivaldi.com

Productivity / niche

  • sigmaos — macOS workspace browser; tabs-as-tasks, WebKit, Airis AI assistant; Pro $20/Max $30 · source · T3 · sigmaos.com
  • opera-air — Opera’s wellbeing browser; blocks distractions, Boosts/Breaks (focus/binaural); free · source · T3 · opera.com
  • zen — open-source Gecko “calmer internet” browser; split-view, community mods · source · T3 · zen-browser.app

Incumbent

  • firefox — Mozilla’s browser and the only mainstream non-Chromium, non-WebKit one left: gecko engine, SpiderMonkey JS, per-site process isolation (Fission, 2021). 3.34% worldwide, July 2026 — the control case for every engine-diversity argument here · thing

Engine (shipping)

  • gecko — Mozilla’s engine: DOM/WebIDL → style (Stylo) → layout → graphics, SpiderMonkey for both page scripts and Firefox’s own UI; Fission gives each content process a single site. The independent engine that already ships at scale, unlike ladybird/falco-browser-engine · source · T1 · firefox-source-docs.mozilla.org

Engine (from-scratch; not a browser product)

  • falco-browser-engine — poxk, MIT: a from-scratch browser engine in Rust, ~73k lines as of 2026-08-10 (HTML tokenizer, CSS cascade + Selectors 4, custom JS VM with an x86-64 baseline JIT, a WASM interpreter, flex/grid/table layout, font rasterizer, PNG encoder); renders to PNG or a live window. The grassroots end of the engine-diversity thread, sibling to ladybird. Re-read 2026-08-10: the repo’s creation date is now two days after the 2026-08-05 ingest, and 124★/15 forks became 23★/1 fork — apparently deleted and re-created, so no metric on the page is durable. Homonym: not the CNCF security Falco. · source · T2 · github.com

Organization (makers)

  • techcrunch — NewsMediaOrganization: the spoke’s most-used publisher (the browser-wars roundup, the kitesurf launch); its launch coverage relays vendor figures, hence T3 on those pages · publisher
  • perplexity — AI answer-engine company; maker of Comet (an AI-search firm building the browser)
  • opera — ~30-yr browser vendor; ships both Neon (agentic) and Air (calm)
  • mozilla — maker of firefox and the gecko platform; publishes its engine’s engineering docs openly, which is why this spoke can describe one engine first-hand. Thin by design — no sourced claims yet on funding or structure

Dataset (sources)

  • statcounter-browser-share — worldwide browser share, July 2026: Chrome 68.22 / Safari 16.47 / Edge 5.37 / Firefox 3.34 / Samsung 2.06 / Opera 1.88. Vendor’s own measurement, no methodology published — ordering solid, decimals approximate · source · T3 · gs.statcounter.com

NewsArticle (sources)

  • browser-wars-2026 — TechCrunch: the browser wars “aren’t about search anymore” — whose AI acts for you inside the browser; maps ~13 alternatives into AI/agentic, privacy, and productivity currents · source · T3 · techcrunch.com

TechArticle (sources)

  • chrome-built-in-ai — Chrome first-party docs: built-in AI — on-device Gemini Nano exposed as web-platform APIs (Prompt, Summarizer, Translator, Writer, Rewriter, Proofreader); the developer-platform + on-device/privacy substrate (origin trials) · source · T1 · developer.chrome.com
  • email-verification-protocol — Chrome origin trial (2026-07-08): verify email ownership with no code and no magic link — DNS issuer delegation, ephemeral key, SD-JWT bound to origin+nonce, signed token on form submit; issuer never learns which site asked. Open spec (WICG + IETF), Google as browser, provider and issuer at launch; verifies ownership, not deliverability · source · T1 · developer.chrome.com
  • chrome-built-in-ai-dos-donts — Chrome first-party docs: production practice for built-in AI — session lifecycle/memory (clone()/destroy()), input stripping, JSON-schema output, and the two that matter: “treat all LLM output as untrusted content” (sanitize the combined stream — payloads span chunks) and a recommended artificial 1–2s delay so results feel trustworthy · source · T1 · developer.chrome.com

Report (sources)

  • interop-2026 — the vendors’ own annual interoperability agreement (Apple, Bocoup, Google, Igalia, Microsoft, Mozilla): 20 focus areas + 4 investigations, scored on tests that pass in every browser so no vendor can win alone; only already-standardized technology qualifies, and only what runs automated on wpt.fyi · source · T1 · github.com/web-platform-tests

BlogPosting (sources)

  • gemini-in-chrome — Google: Gemini in Chrome, the in-browser AI assistant (cross-tab summarization, app integrations, “Personal Intelligence”); the incumbent + the assistant-pole anchor · source · T3 · blog.google
  • wpt-overview-bocoup — Boaz Sender (Bocoup, 2024-12-02): web-platform-tests at 56,552 tests / 1.8M subtests, the denominator kitesurf‘s “215,000+” was missing; WPT’s history (2010, renamed 2013), the vendor two-way sync, and why an interop metric is computed instead of per-browser pass rates · source · T2 · bocoup.com

Synthesis

  • synthesis — the evolving thesis (open questions + flagged contradictions)