AI as a browser capability. A working sketch of what user-controlled AI on the open web could look like.

Note: Harbor + Web Agents is an invitation to explore what user-controlled AI on the web could look like. This is meant to start a conversation — not announce a product. Nothing here is a commitment that these ideas will appear in Firefox or any Mozilla product. But if we're going to shape how AI works on the web, it helps to have something concrete to talk about.

This repository contains two browser extensions plus a small native bridge that, together, implement the Web Agent API specification:

• Harbor — Infrastructure extension that provides LLM connections (Ollama, OpenAI, Anthropic), hosts MCP servers, and manages the native bridge.
• Web Agents API — Implements the Web Agent API specification, exposing window.ai, window.agent, and navigator.modelContext (W3C WebMCP) to web pages. Requires Harbor for LLM/MCP infrastructure.

The problem (May 2026 edition): AI is everywhere in the browser, and somehow you have less choice than a year ago.

• Vendor agent browsers (ChatGPT Atlas, Comet, Gemini in Chrome, Copilot Mode in Edge, Dia) ask you to pick a side. Each replaces your browser with their agent and routes your context to one company.
• Sidebar AI assistants (Brave Leo, Mozilla's AI Window) let you bring your own model, but only to chat with yourself. Websites can't program against them.
• Standards like W3C WebMCP (April 2026) and Chrome's Prompt API solve slices — page-side tools, one on-device model — but neither answers the central question: how does an arbitrary website call the user's chosen AI, with the user's chosen tools, on whatever browser the user happens to be on?

The vision: treat AI like fetch(). The browser holds your model connections, your credentials, and your tools. Websites declare what they need through standard APIs (window.ai, window.agent, navigator.modelContext). Permissions are per-origin and revocable. The agent doesn't free-roam the DOM — websites delegate via a scoped API, which keeps the prompt-injection surface manageable.

// Any website can use AI — no API keys, no backend, no vendor lock-in
const session = await window.ai.createTextSession();
const response = await session.prompt("Summarize this page");

With the Web Agent API:

• Users control their own AI — run local models, choose providers, manage permissions per-origin.
• Websites get AI capabilities without managing infrastructure, holding credentials, or picking a vendor.
• Privacy is preserved because the data path is the user's choice (local models never leave the machine).

→ Read the full explainer · The 2026 landscape and where Harbor fits · Public site (whitepaper/)

Get Harbor running in 10 minutes.

git clone --recurse-submodules https://github.com/r/harbor.git
cd harbor

# If you already cloned without --recurse-submodules:
git submodule update --init --recursive

# Build the Harbor extension
cd extension && npm install && npm run build && cd ..

# Build the Web Agents API extension
cd web-agents-api && npm install && npm run build && cd ..

# Build and install the native bridge
cd bridge-rs && cargo build --release && ./install.sh && cd ..

ollama serve &
ollama pull llama3.2

The system requires two extensions working together:

• Harbor — Infrastructure layer (LLM provider connections, MCP server hosting, native bridge, chat sidebar)
• Web Agents API — Web Agent API implementation (injects window.ai / window.agent into web pages, delegates to Harbor for LLM/MCP)

Firefox:

1. Go to about:debugging#/runtime/this-firefox
2. Click "Load Temporary Add-on..."
3. Select extension/dist-firefox/manifest.json (Harbor)
4. Click "Load Temporary Add-on..." again
5. Select web-agents-api/dist-firefox/manifest.json (Web Agents API)

Chrome:

1. Go to chrome://extensions
2. Enable "Developer mode"
3. Click "Load unpacked" → select extension/dist-chrome/
4. Click "Load unpacked" → select web-agents-api/dist-chrome/
5. Important: Note the Harbor extension ID and update native messaging — see Chrome Quickstart

1. Open the Harbor sidebar (Firefox: Cmd+B, Chrome: click toolbar icon)
2. Check for "Bridge: Connected" (green indicator)
3. Check for "LLM: Ollama"

cd demo && npm install && npm start

Open http://localhost:8000 and try the interactive demos.

→ Detailed Firefox Setup | Detailed Chrome Setup

Safari (Experimental): Safari support is checked into the repo under installer/safari/Harbor/ but is not fully supported. See Safari Setup if you want to experiment.

Building a hackathon project or integrating AI into your web app?

The Web Agent API gives your web pages access to:

<!DOCTYPE html>
<html>
<body>
  <button id="ask">Ask AI</button>
  <div id="output"></div>
  <script>
    document.getElementById('ask').onclick = async () => {
      // 1. Request permission
      await window.agent.requestPermissions({
        scopes: ['model:prompt'],
        reason: 'To answer your question'
      });
      
      // 2. Create session and prompt
      const session = await window.ai.createTextSession();
      const response = await session.prompt('What is 2+2?');
      document.getElementById('output').textContent = response;
    };
  </script>
</body>
</html>

Using an AI coding assistant? Point it to docs/LLMS.txt — it's designed for AI tools to quickly understand and build with the Web Agents API. Building from another project? Copy docs/BUILDING_ON_WEB_AGENTS_API.md into your repo (e.g. docs/ or .cursor/) so the API, examples, and capabilities are in context.

Want your AI to do more? Create MCP servers that give it new capabilities:

# Copy the template and start building
cp -r mcp-servers/templates/javascript my-tool
cd my-tool && edit server.js

Permissions: All capabilities require user consent. Request what you need:

await window.agent.requestPermissions({
  scopes: ['model:prompt', 'mcp:tools.list', 'mcp:tools.call'],
  reason: 'Enable AI features'
});

Feature Flags: Some APIs are gated. Users enable them in the sidebar:

• toolCalling — Enables agent.run() for autonomous tasks
• browserInteraction — Enables click/fill/scroll automation
• browserControl — Enables tab management and navigation

→ Feature Flags Reference

Want to contribute to Harbor or build your own Web Agent API implementation?

┌─────────────────────────────────────────────────────────────────┐
│                         WEB PAGE                                 │
│            window.ai / window.agent (injected APIs)             │
└───────────────────────────────┬─────────────────────────────────┘
                                │ postMessage
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│              WEB AGENTS API EXTENSION                            │
│  • Implements Web Agent API spec  • Permission prompts          │
│  • Injects window.ai/agent        • Delegates to Harbor         │
└───────────────────────────────┬─────────────────────────────────┘
                                │ Cross-extension messaging
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                   HARBOR EXTENSION                               │
│  • LLM provider selection      • In-browser WASM/JS MCP         │
│  • MCP server management       • Chat sidebar UI                │
└───────────────────────────────┬─────────────────────────────────┘
                                │ Native Messaging
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                      RUST BRIDGE                                 │
│  • LLM provider connections    • Native MCP servers             │
│  • Ollama/OpenAI/Anthropic     • OAuth flows                    │
└─────────────────────────────────────────────────────────────────┘

# Watch mode
cd extension && npm run dev    # Auto-rebuild on changes
cd bridge-rs && cargo build    # Rebuild after Rust changes

# Test
cd bridge-rs && cargo test
cd extension && npm test

→ Full contributing guide

The Web Agents API extension implements the Web Agent API specification. The specification itself is browser-agnostic and could be implemented by browsers natively or by other extensions.

harbor/
├── whitepaper/         # Public whitepaper (GitHub Pages)
├── spec/               # Web Agent API specification (browser-agnostic)
├── extension/          # Harbor extension (LLM connections, MCP hosting, sidebar)
├── web-agents-api/     # Web Agents API extension (implements window.ai/window.agent)
├── bridge-rs/          # Rust native messaging bridge
├── demo/               # Working examples
├── docs/               # Implementation documentation
├── mcp-servers/        # Built-in MCP servers (WASM, JS)
└── installer/          # Safari Xcode project (experimental)

This is version 0.1.0, released as a conversation starter. Some features are still in development:

• Streaming abort: Canceling streaming requests is not yet fully implemented
• Address bar parsing: LLM-based argument parsing for omnibox commands is placeholder
• Permission granularity: Origin-level permission checks are basic; more fine-grained controls planned
• Safari support: Experimental; code is in the repo but not fully tested
• Function calling: Native tool/function calling in the bridge uses response parsing (proper function calling planned)

See individual TODO comments in the source for specific implementation notes.

• GitHub Issues — Bug reports and feature requests
• Documentation — Guides and API references
• LLMS.txt — AI-optimized reference for coding assistants

MIT — See LICENSE for details.