JUWEL Architecture · Browser-as-OS · v0.1
The product architecture

The browser that becomes your computer.

JUWEL ships as a Chromium fork. It installs like any browser, imports your Chrome data, runs every extension, then quietly takes over as the surface you live in: a full agentic OS where JUWEL and her Hive do the work. A second build, JUWEL Cursor, extends that reach from the browser to the whole machine.

Browser-as-OS is the product. Install like Chrome. Live in a shell with dock, apps, command bar, and an agent that drives real logged-in sessions. The OS is the spine. Quiet signed receipts sit underneath, so you can check an action if you care to.

Open JUWEL OS Pricing
01

The browser is becoming the OS

The thesis is no longer fringe: the browser is turning into the operating system where AI works alongside you. In 2025 to 2026 the whole field moved at once, and the most credible builds are Chromium forks, not extensions, because only a fork can rewrite the new-tab, the omnibox, permissions, and the agent's reach into the page.

BrowserOSOSS Chromium fork · agents native
Perplexity Cometagentic browser
OpenAI AtlasChatGPT-in-browser
The Browser Co · DiaAI-first browser
Opera Neonagentic
Brave / Chromeforks + native auto-browse

JUWEL's bet is the same shape, and the structure is proven: a browser half (the Chromium fork) and an agent half (the platform that drives it). Together they become the OS you live in.

02

What the agentic OS actually is

Handing an autonomous agent your logged-in sessions is the whole value of this category. JUWEL is built so that value is usable day one: real sessions, a real shell, a real agent loop, not a chat pane bolted onto someone else's browser.

Chat bolted on a browser

  • The agent lives in a side panel. The rest of the browser is still the host product's world.
  • New-tab, omnibox, and chrome stay foreign. No dock, no apps, no takeover surface.
  • Reach stops where the host browser throttles extensions and permissions.

JUWEL OS

  • A Chromium fork so the shell is the home: new-tab, omnibox, dock, apps, approvals.
  • Agents drive your real logged-in sessions through CDP at the engine level.
  • Install like a browser. Full-screen and it feels like your computer, no VM per seat.
03

How it's built

Three product layers you live in, plus the Chromium engine underneath. Intent at the top, shell as home, agent platform driving real pages, fork as the substrate.

Who's driving
You + JUWEL + the Hive
Plain-language intent. Humans never have to click. JUWEL and her specialists do the operating; you approve what matters.
Layer 1 · Surface
JUWEL Shell, the OS that replaces new-tab
The dock, apps, command bar, approvals. This is the prototype already built. In the fork it is the home, the new-tab, the default surface.
new-tab overrideomnibox → command bardock / appsapproval cards
Layer 2 · Action
Agent platform
The agent loop + the Hive of specialists, driving real pages through the engine. Tools exposed over MCP so any model can operate the browser.
agent loopMCP serverCDP controllerlogged-in sessions
Layer 3 · Engine
Chromium fork (+ patches)
A maintained fork, not an extension. Patches rewrite new-tab, omnibox, and permissions. Imports Chrome profile; all extensions run.
chromium_patchesprofile importextension compatauto-update channel
04

Quiet proof

Not the pitch. A footnote that ships with the OS: every consequential action can leave a signed trail you check yourself.

STOA · optional audit trail

When an action commits, JUWEL can intercept, describe, and sign it (ECDSA-P256 + Merkle chain). The open verifier is not us: npx @vextlabs/stoa-verifier ./receipt.json. Flip one character, watch it fail. Already real in the prototype; demoted here so the architecture stays about the OS.

05

Installs like a browser. Takes over like an OS.

No migration, no leap of faith. The first run is indistinguishable from switching browsers. The takeover is gradual and reversible. That's exactly why people will actually cross over.

STEP 01

Download JUWEL

One installer, Mac/Win/Linux. It's a real browser. Nothing exotic to learn.

STEP 02

It's Chromium

Imports your Chrome profile: tabs, passwords, extensions. Everything you had still works on day one.

STEP 03

JUWEL takes the home

New-tab and the omnibox become the JUWEL shell: the dock, the apps, the agent. The OS, inside the browser you already trust.

STEP 04

Full-screen = your OS

Set default + run standalone/kiosk and the browser chrome disappears. Now it's just JUWEL, per-customer, no VM per seat.

06

Two builds, one brain

The same agent, two radii of reach. Most work lives in the browser; the rest needs the whole machine.

SKU 1 · ships first

JUWEL OS, the browser

The Chromium fork. Agents run locally, inside your real, logged-in sessions, so they can actually do the work that remote computer-use agents can't: your email, your dashboards, your company tools.

Reach: anything on the web. This is the product. Install it and you're in.

SKU 2 · the extension of reach

JUWEL Cursor, the computer

Computer-use beyond the page. When a task escapes the browser, whether a native app, the file system, or the desktop, JUWEL Cursor drives the machine itself under the same approval gate.

Reach: the whole OS. The browser is the front door; Cursor is the rest of the house.

07

Why a fork, and not an extension

Reach

An extension is sandboxed and can be throttled by the host browser at any update. A fork lets the agent see and drive the page through CDP at the engine level: no permission theater, no surprise breakage.

The surface

Only a fork can replace the new-tab and omnibox with the JUWEL shell, and restyle the whole chrome. The OS feeling, dock, apps, takeover, is impossible from inside an extension's box.

Control

Permissions, auto-update channel, and action hooks live where the engine commits work. You own the substrate, so the agent and the shell stay one product.

It's more work than an extension and that's the moat: the credible builds in this category are forks for exactly these reasons. We inherit a proven structure and ship the full OS on top.

08

The build, in phases

Already real in the prototype
Native engineering to build
P0Weeks

Fork boots, shell is home

Stand up the Chromium fork with auto-update; patch new-tab + omnibox to load the JUWEL shell. Profile import. The OS we've designed renders as the browser's home surface.

fork · patches shell exists
P1The product

Agent drives pages in the shell

Wire the agent loop to CDP; expose tools over MCP. Navigate, click, type, submit against real logged-in sessions. Quiet proof optional on each action. This is the shippable product.

CDP · MCP agent loop exists shell exists
P2Reach

JUWEL Cursor, computer use

Desktop build that drives native apps and the file system under the same approval model. Browser stays the front door; Cursor handles what escapes it.

computer-use approval shared
P3Network

Agent store + shared runs

Publish/extend specialists in the Hive; share a run as a bundle anyone can inspect. The OS becomes a distribution surface for agents.

marketplace Hive exists
09

What's honest to say today

Real, now

The shell, the dock and apps, the Hive, and the product design of the browser-OS, all live in the prototype. Quiet proof (signed receipts + offline verifier) is already real too; it is not the headline.

Native build, next

The Chromium fork itself, the CDP/MCP agent bindings, and computer-use are C++/systems engineering, not yet built. This document is the blueprint that scopes them. We claim the OS design; we don't yet claim the fork.

A browser that becomes your computer.

Open JUWEL OS Pricing
JUWEL by Vext Labs · Browser-as-OS architecture · v0.1 The product is the OS. Proof stays quiet.