This post originally appeared on the Muvon blog. I'm cross-posting it here because the dev.to crowd is exactly who I built this for.

Every browser suddenly has AI in it. And every one of them did it the same way: take Chrome, bolt a chat panel onto the side, call it an AI browser. The browser doesn't know the agent exists. The agent can't touch the browser. Two strangers sharing a window.

I spent this year building agents — a runtime, memory, code search, a filesystem layer — and at some point the question became unavoidable: what would a browser look like if it were designed for AI from the first commit? Not AI added. AI as a citizen — in both directions. The agent lives in the browser and can see what you see. And the browser is a tool the agent can pick up and use.

So I built it. Octoweb is a WebKit browser written in Rust — no Electron, no Chromium, about 25,000 lines — made for two overlapping audiences: people who live on the keyboard, and people who work with agents all day. I'm both, and five months later it's the browser I start every morning in: reading docs, debugging my own web apps, handing the boring browser chores to Octomind while I keep reading.

It just hit 0.10.0, and I figured the dev.to crowd would care about the engineering decisions more than the product announcement. So here's the build story.

First, the geek part: no mouse required

Before the AI does anything, Octoweb has to earn its place as a browser for people who think in keystrokes. The design rule was simple: every action has a shortcut, nothing requires a click.

The center of it is the command palette (⌘⇧P) — type a URL, a search query, or any fragment of a page you've visited, and it fuzzy-matches across open tabs and history, ranked by match quality and visit frequency. One more keystroke opens, switches, or searches. And because muscle memory is sacred, the palette speaks readline: ⌃A/⌃E to jump, ⌃K/⌃U to kill, ⌃N/⌃P to move. If your fingers know Emacs or a shell, they already know Octoweb.

The rest of the vocabulary:

• Fast-access slots — ⌘⇧1–⌘⇧0 pins the current page to a numbered slot; ⌘1–⌘0 jumps back from anywhere. Ten pages, one keystroke each, persisted across restarts. It's the browser equivalent of Vim marks. New in 0.10.0: ⌘⇧N pins the current page to the first free slot — and unpins it if it's already there.
• MRU tab cycling — ⌃N/⌃P walks tabs in most-recently-used order, the way you actually switch between two pages, not the order they happen to sit in the tab bar.
• Vim-style scrolling — ⌃D/⌃U for half pages, ⌃T/⌃B for top and bottom.
• Screenshots to clipboard — ⌘S viewport, ⌘⇧S full page. No save dialog, no file to clean up later.
• ⌃R in the AI prompt box — reverse incremental search through your prompt history. Yes: I put readline's history search in the browser's AI input, because once you've had it in a shell you want it everywhere.

Global shortcuts run through CGEventTap, macOS-native and configurable. And here's why Octoweb is macOS-only for now — it leans on the platform (WKWebView, AppKit, CGEventTap) instead of shipping a second operating system in a zip file. That's also why the whole browser is a single lean binary instead of a 300 MB Electron app.

The agent in the sidebar — running on Octomind

Press ⌘⇧A and an agent slides in over the page. Not an iframe with a chat website in it — a real agent process, running locally, connected over the Agent Client Protocol.

The agent is Octomind, my plug-and-play agent runtime — the same one that powers my terminal sessions and CI reviews. And here's the part you don't do: start it. Octoweb launches octomind acp octoweb:assistant itself — a sandboxed subprocess per session, restarted if it dies, resumed with your conversation intact on the next launch. Install Octomind once, and the sidebar takes it from there.

That octoweb:assistant tag is a manifest from the community tap registry: model, system prompt, and tools, fetched and assembled automatically. Zero config files written by hand. From then on you can ask about the page you're reading, get code on it explained, or summarize a thread you don't have time for — with responses streaming in, sessions that persist and resume, and slash commands with rich output cards.

And because it's a real agent, the sidebar isn't a chat box with opinions — it works. Swap the tag to developer:rust and you can code from the browser: the agent edits files in its sandboxed workspace, tool calls show up as clickable rows with live status, and when it wants to show you something richer than prose — a form, a table, a small interactive UI — it renders an A2UI surface right in the sidebar. I've fixed bugs in Octoweb, from Octoweb, while the failing page sat in the next tab.

Three details I sweated:

• The agent tag is editable. The sidebar header shows octoweb:assistant by default, but type any tag your Octomind knows — developer:rust, your own custom agent — and the sidebar reconnects to it on the spot. The browser doesn't care which brain it's talking to.
• The browser never calls an AI provider. Every model call is made by Octomind, outside the browser process, with the agent's filesystem access sandboxed to its workspace. No data leaves your machine unless your agent sends it somewhere — and which agent that is, with which provider, is entirely your call.
• The session is a two-way street. Since 0.10.0, messages injected by the Octomind runtime — a specialist replying from the tap, a scheduled job finishing, a webhook firing — arrive in the sidebar as their own labeled bubbles, mid-conversation. Your browser becomes the place where your agents report back.

There's also a smaller door: select text on any page, press ⌘⇧E, and an inline edit modal transforms the selection — rewrite, summarize, translate. It runs its own dedicated agent from the same tap — octoweb:editor — with its own prompt history, ⌃R and all.

The browser as a tool: MCP from the inside

This is the direction nobody else builds, and it's my favorite part. Octoweb runs an MCP server inside the browser — localhost:3434/mcp. Any MCP client — Claude Desktop, an Octomind session, your own script — can connect and drive it: twenty-six tools covering navigation, tabs, clicking, typing, scrolling, screenshots, content extraction, console output, and network activity.

You've seen browser automation before. The difference here is that the agent isn't driving a headless Chromium in a datacenter with no cookies and a bot-detection target on its back. It's driving your browser — your sessions, your logins, your tabs — while you watch. And the tool design takes "while you watch" seriously:

• Navigation never steals focus. browser_navigate always opens in the background. Exactly one tool — browser_switch_tab — is allowed to change what you're looking at. An agent can research in ten tabs behind your back without ever yanking the page out from under your cursor. It browses beside you, not instead of you.
• Clicks that don't lie. browser_click retries until the element is present, stable, and unobstructed — and if something is covering it, the error says what. browser_snapshot returns a map of interactive elements with stable @N refs that pierces iframes, shadow DOM, and listener-only clickables. browser_wait knows about SPA readiness, not just page load.
• Eyes included. browser_console_messages and browser_network_requests give the agent the page's console errors and fetch/XHR activity with statuses and timings — the two things you'd open DevTools for, as tools.
• Guard rails at the boundary. Text that flows out through snapshots and page content passes a sanitizer — card numbers get redacted before they ever reach a prompt.
• Tokens are the budget. Every tool answer is shaped for a model, not for a debugger: browser_snapshot returns a compact element map instead of raw HTML (I deleted the get_html tool on purpose), console and network logs come capped and filterable, and @N refs mean the agent never burns half a context window guessing CSS selectors. An agent's turn is priced in tokens; the browser respects that.

And if your agent runtime is Octomind, wiring it up is one line inside a session:

/mcp add octoweb http://localhost:3434/mcp

The agent you were already talking to can now open docs, read them, fill forms, and check what a page's console is screaming about — mid-conversation, no restart. This is how browser chores leave my to-do list: the agent reproduces a bug in a background tab, reads the console, and comes back with the failing request; it walks an admin panel I didn't feel like clicking through; it checks that a deploy actually rendered — in my logged-in browser, with my sessions, while I keep reading in the foreground tab.

The browser that learns with you

One more experiment: proactive learning. On an interval — 30 minutes by default — Octoweb wakes a second, fully independent agent, the octoweb:learning tag, which looks at your open tabs and recent history and distills what you're working on into Octomind's memory. Next session, the sidebar assistant already knows the docs you've been circling for three days.

It's on by default — one toggle in Settings turns it off — it's local, the interval is yours to set, and the two agents are fully independent: run either without the other. I think ambient memory is where browser AI actually gets interesting, and I'd rather ship the honest v1 of it than a demo.

Yes, it's also just a good browser

None of this matters if the browsing is worse than what you left. The fundamentals are there, and a few are better than there:

• Smart tab hibernation — background tabs freeze under memory pressure, with RAM-aware thresholds. Fifty tabs is a lifestyle, not a leak. And since 0.10.0 there's a cap on open tabs (500 by default, configurable) that quietly closes the least-recently-used ones past it — an airbag for tab hoarders.
• Content blocking built in — trackers and ads via WebKit's native content rule lists, no extension needed.
• Cold starts stay cold — favicons are cached as data-URIs, so launching the browser makes zero network requests until you do.
• Session restore, WebAuthn passkeys, PDF and DOCX viewing, find-in-page on the CSS Custom Highlight API, native fullscreen, proper popup-window handling.

What about extensions? Honest status: the Safari Web Extensions integration (for 1Password, Bitwarden, and friends) is fully implemented in the code — and blocked on Apple's com.apple.developer.web-browser entitlement, an approval only Apple can grant. Until it lands, content scripts don't inject. I'd rather tell you that than pretend extensions are a roadmap item.

Five months, 0.1.0 to 0.10.0

Octoweb started in late March as an experiment: could a keyboard browser with an ACP sidebar be usable in a week? By 0.6.0 it had tab hibernation and the first MCP automation tools. 0.7.0 brought persistent chat sessions, passkeys, and slash commands. 0.8.0 was the big one — the actionability harness, the e2e suite that tests the browser through its own MCP server, agent sandboxing, configurable keybindings, A2UI surfaces. 0.9.0, cut in late July, moved to ACP v1.2.0 with account authentication and a long tail of stability work. And today's 0.10.0 is what daily use does to a roadmap: pinned tabs, the open-tab cap, account quota status that refreshes itself, specialist messages landing in the sidebar — plus fixes for a memory leak and orphaned agent processes, the kind of thing you only find by leaving it running for weeks.

What started as an experiment is now the browser I actually live in. It won't replace my main browser this year — it might become the one I reach for when I want to think.

Get it

One line on any Mac, Apple Silicon or Intel:

brew install --cask muvon/tap/octoweb

Or grab a prebuilt archive from GitHub Releases, or build from source with a Rust toolchain:

git clone https://github.com/muvon/octoweb
cd octoweb
./build.sh --dev        # ad-hoc signed, no cert needed
open dist/Octoweb.app

For the sidebar, install Octomind and sign in:

curl -fsSL https://raw.githubusercontent.com/muvon/octomind/master/install.sh | bash
octomind login

octomind login is a device-code sign-in to Octomind Cloud — the subscription includes model access, so there's nothing else to configure, and the sidebar shows your account and quota status. Prefer your own keys? Skip the login and export any provider key instead (OPENROUTER_API_KEY, ANTHROPIC_API_KEY, …) — BYOK is a first-class path. Either way, that's the whole setup: launch Octoweb, press ⌘⇧A, and say hello — the browser starts and manages the agent process itself. Config is one TOML file at ~/Library/Application Support/octoweb/config.toml; Settings is ⌘,.

Octoweb is on GitHub under Apache-2.0, like everything else I ship. If you live on the keyboard, or your agents deserve a real browser instead of a headless one — try it, and tell me what's missing. The features requested by early users are the reason 0.10.0 looks nothing like 0.1.0.

— Don

(Octoweb is open source under Apache-2.0, developed by Muvon Un Limited. It runs on Octomind, my plug-and-play AI agent runtime.)