Octoweb — the keyboard-first AI browser for macOS

The browser you reach for when you want to think. macOS only, by design.

Built on WebKit and Rust. No Electron. No Chrome. No mouse required.

🏠 Website · Releases · Changelog

• Why Octoweb?
• Features
• AI Assistant
• MCP server (AI browser control)
• Keyboard shortcuts
• Install
• Configuration
• What it is (and isn't)
• Tech stack

Most browsers are built around the mouse. Octoweb is built around the keyboard — and around the idea that your browser should amplify your thinking, not interrupt it. Every action has a shortcut. The AI assistant lives in a sidebar, not a tab. And your AI tools can drive the browser directly via MCP. No extensions. No config. Just open it and go.

Three things it does differently:

1. Keyboard-first navigation — Every action has a shortcut. Nothing requires a click. The command palette (⌘⇧P) fuzzy-searches tabs and history. Pin any page to a fast-access slot with ⌘⇧1–⌘⇧0 and jump back with ⌘1–⌘9 from anywhere.

2. AI assistant built in — Not an extension, not a tab. A sidebar overlay powered by a local octomind agent via ACP. Ask questions about the current page, get code explanations, summarize content — all without leaving the browser.

3. MCP server inside the browser — Your AI tools can actually drive the browser. Octoweb runs an MCP server on localhost:3434/mcp that exposes 31 tools for navigation, tab management, page interaction, and content extraction. Point Claude Desktop or any MCP client at it and watch it browse.

• Command palette (⌘⇧P) — Fuzzy search across tabs and history. Type a URL, search query, or page fragment.
• Page memory (/ in the palette) — Search the text of pages you have visited, not just titles. "Where did I see that pricing table" is one keystroke away; the agent gets the same search as an MCP tool. Private tabs are never indexed.
• Copy for sharing (⌘⇧C) — Copies the URL, or the selection with the URL under it, as plain text. ⌥⌘C copies markdown instead: a quote with its source link, or the whole page as clean markdown when nothing is selected. ⌥-click the address bar's copy button for a [title](url) link.
• Save for later (⌘⇧L) — A reading queue that decays instead of a bookmark shelf: saved pages sit on top of the palette and the new-tab page, opening one removes it, and after later_days they drop out while their text stays searchable. The digest-later workflow turns whatever you never opened into three lines each.
• Ask about selection (⌘⇧K) — Select text on any page and ask the sidebar to explain it, with the page as context. No selection asks about the page.
• Private tabs (⌘⇧↵ in the palette) — Open any result in an isolated tab with in-memory cookies and storage. Nothing is written to history, the session file, or the favicon cache; closing the tab discards everything.
• Fast-access slots (⌘1–⌘0) — Pin up to 10 pages for instant access, one set per workspace. Footer bar shows all slots.
• Tab pinning (⌘⇧N) — Pin the current tab to the fast-access bar with one keystroke.
• Workspaces (⌘⇧O) — Isolated browser profiles: each workspace has its own tabs, history, AI sessions, and a dedicated WebKit data store, so cookies, localStorage, and cache never leak between them. Switch with ⌘1–⌘0 while the popover is open.
• Configurable keybindings — Remap any shortcut in Settings (⌘,). Changes apply on the next keystroke, no restart.
• AI sidebar (⌘⇧A) — Chat with a local AI agent about the current page. Streaming responses, code blocks with copy.
• Inline AI edit (⌘⇧E) — Select text on any page, transform it with AI. Rewrite, summarize, translate.
• Proactive learning — Background agent periodically analyzes your browsing and memorizes patterns. Off by default — it reads your tabs, history and page text, so you turn it on deliberately in Settings (⌘,).
• MCP server — 31 tools for AI clients to control the browser. Navigate, click, type, screenshot, extract content.
• Find-in-page (⌘F) — Full-text search with highlighting.
• Page zoom — +/- to zoom, ⌘0 to reset.
• Screenshots — ⌘S for viewport, ⌘⇧S for full page. Copied to clipboard.
• PDF & DOCX viewer — Open documents directly in the browser.
• Session restore — Tabs and history persist across restarts.
• Favicon caching — No network requests on startup. Icons stored as base64.
• Content blocking — Built-in tracker and ad blocker via WKContentRuleList.
• Smart tab hibernation — Background tabs under memory pressure are frozen.

Press ⌘⇧A to open the sidebar. It connects to a local AI agent running under octomind using the Agent Client Protocol (ACP). Responses stream in as they arrive.

octoweb sidebar  ──ACP/JSON-RPC──▶  octomind acp octoweb:assistant
                                         │
                                    specialist agent config
                                    from the tap registry
                                         │
                                    your chosen AI provider
                                    (OpenAI, Anthropic, etc.)

octomind is a plug-and-play AI agent runtime. You install it once, point it at an API key, and get a fully configured specialist agent — model, system prompt, tools, and all — with zero manual setup. The octoweb:assistant tag fetches that agent's configuration from the community tap registry automatically.

1. Install octomind:

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

2. Set an API key (any supported provider):

export OPENROUTER_API_KEY="your_key"   # easiest — covers all providers
# or: OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.

3. Start octomind in ACP mode (octoweb connects to this):

octomind acp octoweb:assistant

octomind fetches the octoweb:assistant agent manifest from the tap, installs any required tools, and starts listening for ACP connections. octoweb's sidebar connects automatically.

4. Open the sidebar in octoweb: ⌘⇧A

The agent tag in the sidebar header defaults to octoweb:assistant. You can type any tag your octomind instance knows about — developer:rust, assistant, your own custom agents — the new-session picker autocompletes as you type, and the sidebar reconnects to that agent immediately.

Shipped tags include octoweb:assistant (sidebar chat), octoweb:editor (inline text transformation, used by ⌘⇧E), octoweb:learning (background learning), and octoweb:trend (live social trend research) — see the tap registry.

No data leaves your machine unless your agent sends it somewhere. The AI provider call is made by octomind, not by the browser.

Agents can do more than reply with text: via the render_ui tool they can draw interactive surfaces — forms, buttons, live views — inline in the sidebar chat. Buttons can open URLs in a new tab or resolve back to the agent.

Octoweb speaks A2UI v1.0 and renders the full basic catalog (Card, Row/Column/List, Text, Image, Icon, Video, AudioPlayer, Button, TextField, CheckBox, ChoicePicker, Slider, DateTimeInput, Tabs, Modal, Divider), including data-model binding, ${…} string interpolation, list templates, validation checks, accessibility attributes, and agent-issued callRendererFunction. Envelopes are validated before they render, so a malformed surface comes back to the agent as a precise error instead of a blank card.

Octoweb runs a background agent that periodically analyzes your browsing patterns and memorizes insights. It is off by default — it reads your open tabs, history and the active page's text, which is a thing to opt into rather than discover. Turn it on in Settings (⌘,).

How it works:

1. Every learning_interval_min (default: 30), the background agent wakes up
2. It collects: open tabs, recent history, and the active page's text content
3. The agent calls remember to check existing memories, then memorize for new insights
4. Insights are stored locally in octomind's memory system

Configuration:

proactive_learning    = false   # enable background learning (default: off)
learning_interval_min = 30     # minutes between runs (floored to 5 on load)

The learning agent runs as a separate octomind acp octoweb:learning process. It's completely independent from the sidebar assistant — you can use one without the other.

octoweb runs an MCP server on localhost:3434/mcp. Any MCP-compatible AI client — Claude Desktop, octomind itself, your own scripts — can use it to control the browser directly.

Claude Desktop / octomind / any MCP client
        │
        │  HTTP JSON-RPC
        ▼
  localhost:3434/mcp  (inside octoweb)
        │
        ▼
  WebKit WebView — navigate, click, type, read, run JS

Available tools:

Workspace routing: one server serves every workspace. A request's X-Octoweb-Workspace token says which workspace it acts on; callers that send no token fall through to the first workspace. The sidebar's agent sessions carry their token automatically, so an agent driving tabs in a background workspace never disturbs the one you're looking at.

Point Claude Desktop at http://localhost:3434/mcp and it can browse, read, fill forms, and navigate — all while you watch.

Safety. The endpoint validates the Origin header, so a page you happen to be visiting cannot fetch() it and drive your logged-in browser; command-line clients, which send no Origin, are unaffected. Read tools carry readOnlyHint so a host can auto-approve them instead of prompting on every page read. Everything a page authored — browser_get_page_content, browser_snapshot, browser_console_messages, browser_network_requests — comes back inside an <untrusted> fence, because an agent that can click and type should know which bytes are the page's. Set OCTOWEB_MCP_PORT / OCTOWEB_CONFIG_DIR to run an isolated second instance (e.g. for the e2e suite: python3 test_mcp.py --mcp-url http://127.0.0.1:3435/mcp).

Because octomind has a built-in mcp tool that can register external servers at runtime, you can give any running octomind agent live browser access in one step:

# inside an octomind session
/mcp add octoweb http://localhost:3434/mcp

The agent can now navigate pages, extract content, and interact with the browser as part of its normal tool use — no restart, no config change.

Every shortcut is configurable in Settings (⌘,) — remaps persist to ~/.config/octoweb/keybindings.json and apply on the very next keystroke, no restart. The ⌘+digit slot keys are positional and not remappable.

Pin any page to a numbered slot and jump back to it instantly — one keystroke from anywhere. Slots are shown in a footer bar at the bottom of the window and on the new-tab page.

• ⌘⇧1–⌘⇧9 / ⌘⇧0 — save the current page to slot 1–9 / 10
• ⌘1–⌘9 — navigate to the saved URL in that slot

Slots persist across restarts and are scoped per workspace — pinning in one workspace never touches another's. An empty slot does nothing.

⌘0 defaults to zoom reset and wins over slot 10 — rebind zoom reset in Settings if you want ⌘0 to open slot 10. ⌘⇧0 still saves to slot 10.

The switcher popover lists every workspace with its tab count; the one you are in is highlighted.

⌘⇧M opens the same popover to pick a destination for the current tab. Selecting one moves the tab there and reloads it — workspaces have separate cookie and storage stores, so nothing of the live page carries across. If it was the workspace's last tab, a fresh one takes its place.

Reaching content inside a page without a mouse. Press ⌘⇧F and every clickable thing in the viewport — links, buttons, form fields, ARIA controls — gets a short home-row label. Type the label to activate it.

Labels are one character for up to 9 targets and two beyond that. Only what is on screen is labelled — scroll and press again. Elements hidden behind a modal or cookie banner are skipped, since a click would not reach them either. Same-origin iframes are included; cross-origin ones cannot be reached.

The main interface. Type a URL, a search query, or any fragment of a page title or URL you've visited — it fuzzy-matches across open tabs and history instantly, ranked by match quality and visit frequency.

When a query is entered, three action rows appear at the bottom: Search Google, Open URL, and Ask AI. Select one and press Enter, or use the dedicated shortcuts below.

⌘⇧↵ opens whatever is selected — an open tab, a history entry, a typed URL, or a search — in a private tab. It gets its own in-memory WebKit data store, so cookies, localStorage, and cache are separate from the workspace and vanish when the tab closes. Private tabs never write to history, the session file, the favicon cache, or the ⌘⇧T reopen list, and popups they open stay private. They show a Private pill in the palette and are not restored on restart.

Pages saved with ⌘⇧L show first, with a Later pill, when the query is empty; opening one removes it from the queue. Start the query with / to search page text instead of titles and URLs: every word must match as a prefix, results are most recent first, and each shows the passage that matched. The index keeps the first few kilobytes of text of the last 2000 pages in page_index.json. Open tabs also show their WebContent memory in megabytes next to the pill, so the tab eating your RAM is one glance away.

The sidebar overlays the page on the right — the page content underneath is not resized.

Prompt history:

• Ctrl+P / Ctrl+N — Navigate older/newer prompts (MRU order)
• Ctrl+R — Reverse incremental search through history
• Ctrl+E — Accept ghost text autocomplete
• Ctrl+U — Clear input to cursor start

History persists across sessions (ai_prompt_history.json).

Repeatable tasks. The bundled tap ships browser workflows — watch a page for changes, compare open tabs, cancel a subscription, fill a form from memory, summarize a thread, digest what you saved for later. Type /workflow and pick one from the dropdown, then give it its input. The assistant can launch them itself through the tap tool, so a recurring job is /schedule add when=... every=... message="<workflow and input in plain words>": when the message fires, the assistant runs the workflow in the background and relays its result. Pending routines show as a ⏱ chip in the header (click it to list them). Routines fire only while Octoweb is running, since the assistant session is the scheduler.

Select text on any page and press ⌘⇧E to open the inline edit modal. The AI can rewrite, summarize, translate, or transform the selected text.

Prompt history works the same as the sidebar (Ctrl+P/N/R/E/U).

Full-text search with highlighting. Uses CSS Custom Highlight API for fast, native rendering.

Homebrew (recommended):

brew install --cask muvon/tap/octoweb

Direct download: grab the archive for your Mac — Apple Silicon or Intel — from GitHub Releases, unpack it, and drop Octoweb.app into /Applications.

Build from source (requires Rust toolchain and Xcode Command Line Tools):

git clone https://github.com/muvon/octoweb
cd octoweb

# Dev build (ad-hoc signed, no cert needed)
./build.sh --dev

# Release build (requires Developer ID cert)
./build.sh

# Run
open dist/Octoweb.app

Or install to Applications:

cp -r dist/Octoweb.app /Applications/

Config lives at ~/Library/Application Support/octoweb/config.toml. Created on first launch with defaults.

Open Settings with ⌘, to configure visually, or edit the file directly:

home_page                = "https://www.google.com"
search_engine            = "https://www.google.com/search?q={}"
max_history              = 1000
window_width             = 1280
window_height            = 800
ai_edit_auto_hide        = false      # auto-hide inline edit after submit
max_prompt_history       = 50         # editor prompt history size
max_ai_prompt_history    = 50         # sidebar prompt history size
max_acp_session_messages = 500        # chat messages retained per AI session (FIFO)
proactive_learning       = false      # enable background learning agent (default: off)
learning_interval_min    = 30         # minutes between learning runs (floored to 5 on load)
aggressive_hibernation   = false      # aggressive tab-hibernation curve for tight-RAM machines
max_tabs                 = 500        # max open tabs (0 = no limit)
later_days               = 14         # days a "save for later" page stays queued (0 = forever)

Persistence:

• Session — Open tabs and active tab restored on next launch
• History — Browsing history up to max_history entries
• Favicons — Cached as base64 data-URIs, no network on startup
• Prompt history — Separate histories for inline edit and sidebar

octoweb is an experiment. It's a real, usable browser — WebKit rendering, proper tab management, session restore, back/forward gestures, progress bar, error pages — but it's also a playground for the idea that a browser can be a first-class AI client, not just a container for AI extensions.

It's macOS only. It will stay that way for now — the whole thing leans on macOS-native APIs (CGEventTap for global hotkeys, WKWebView via wry, AppKit for the dock icon and menus).

It won't replace your main browser. It might become the browser you reach for when you want to think.

• wry — WebView (WKWebView on macOS)
• tao — windowing + event loop
• octomind — plug-and-play AI agent runtime powering the sidebar
• agent-client-protocol — ACP for browser ↔ agent communication
• rmcp — MCP server (AI browser control)
• CGEventTap — system-wide keyboard shortcuts without rdev
• Rust, release profile: LTO + codegen-units=1 + stripped binary

Apache 2.0