# Nanobrowser: An Open-Source AI Web Automation Extension with Multi-Agent Architecture

> Nanobrowser is a free Chrome extension that runs AI-powered web automation tasks using a Planner and Navigator agent pair, requiring only the user's own LLM API keys. It targets engineers and power users who need to automate repetitive browser workflows without a paid subscription service.

**nanobrowser/nanobrowser** — Open-Source Chrome extension for AI-powered web automation. Run multi-agent workflows using your own LLM API key. Alternative to OpenAI Operator.

- Repository: https://github.com/nanobrowser/nanobrowser
- Website: https://nanobrowser.ai
- Stars: 13,850 · Forks: 1,467
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/nanobrowser-nanobrowser

## What Nanobrowser Is and Who Uses It

Nanobrowser is a Chrome extension that automates browser tasks by coordinating two AI agents: a Planner, which interprets the goal and decides what to do next, and a Navigator, which executes browser actions. The README describes it as a free alternative to OpenAI Operator, the commercial browser automation service.

The project targets users who want web automation without a subscription fee. The extension requires no Nanobrowser account or cloud service. Users provide their own LLM API keys, so costs depend on which model they configure and how many tasks they run. All processing runs in the local browser instance; credentials and browsing data do not leave the machine.

The extension is available from the Chrome Web Store and as a zip from the GitHub releases page. The source code is TypeScript under the Apache-2.0 license.

## The Planner and Navigator Agent Architecture

The two-agent design separates high-level reasoning from low-level browser control. The Planner receives the user's task description, reasons about what steps are needed, and issues instructions to the Navigator. The Navigator takes those instructions and performs the actual browser actions: clicking, typing, reading page content, and navigating between URLs.

The README describes a specific behavior: the Planner can self-correct when it encounters obstacles and dynamically adjust its instructions to the Navigator mid-task. This means a task description like "find the cheapest flight from London to Tokyo in October" triggers a sequence of planning and navigation steps, with the Planner deciding when to revise its approach based on what the Navigator reports back.

The separation also allows different models to be assigned to each agent. A more capable (and more expensive) model can be used for the Planner while a lighter, cheaper model handles the Navigator's mechanical actions. The README provides specific recommended configurations for different performance and cost targets.

## Installing Nanobrowser from the Chrome Web Store or Manually

The simplest install path is through the Chrome Web Store: visit the extension page (ID: imbddededgmcgfhfpcjmijokokekbkal), click "Add to Chrome", and confirm. The README notes that the Web Store version may lag behind the latest release because Chrome's review process introduces delays. For the latest features, the manual install path is recommended.

For manual install: download the `nanobrowser.zip` file from the GitHub releases page, unzip it, open `chrome://extensions/` in Chrome, enable Developer mode, click "Load unpacked", and select the unzipped `nanobrowser` folder. To upgrade, download the new zip, unzip it, replace the existing files, and click the refresh icon on the Nanobrowser card in `chrome://extensions/`.

After install, clicking the Nanobrowser toolbar icon opens the side panel. Clicking the Settings icon in the top right allows adding LLM API keys and choosing which model to assign to each agent. The extension supports OpenAI, Anthropic, Gemini, Ollama, Groq, Cerebras, Llama, and custom OpenAI-compatible providers.

## Building Nanobrowser from Source

Building the extension from source requires Node.js v22.12.0 or higher and pnpm v9.15.1 or higher. The README gives the full sequence:

```bash
git clone https://github.com/nanobrowser/nanobrowser.git
cd nanobrowser
```

Then install dependencies:

```bash
pnpm install
```

Then build the extension:

```bash
pnpm build
```

The build output lands in the `dist` directory. Load it into Chrome using the same "Load unpacked" steps as the manual install. For development with hot reload:

```bash
pnpm dev
```

The repository uses a pnpm workspace with Turbo for builds. The package.json also includes a `zip` script that builds and packages the extension: `pnpm zip`. The PostHog analytics key, if the builder wants to enable analytics during development, is configured through an `.env` file. The `.env.example` file shows the expected format:

```
VITE_POSTHOG_API_KEY=your-posthog-api-key-here
```

The `VITE_POSTHOG_HOST` variable is optional and defaults to the PostHog cloud endpoint.

## Configuring Models for the Planner and Navigator

The README gives two recommended model configurations. For better performance, the Planner should be Claude Sonnet 4 and the Navigator Claude Haiku 3.5. For cost-effective operation, the Planner can use Claude Haiku or GPT-4o, and the Navigator Gemini 2.5 Flash or GPT-4o-mini, with the caveat that complex tasks may need more iterations.

For users who want zero API costs, Ollama and other custom OpenAI-compatible providers are supported. The README lists recommended local models: Qwen3-30B-A3B-Instruct-2507, Falcon3 10B, Qwen 2.5 Coder 14B, and Mistral Small 24B. The README explicitly warns that local models require more specific and cleaner prompts, and that users should break complex tasks into clear, detailed steps rather than giving high-level ambiguous commands.

The ability to assign different models to Planner and Navigator independently is a design choice that reflects the different compute profiles of the two roles. The Planner's job is reasoning over a task description and deciding on a strategy; it benefits from a stronger model. The Navigator's job is executing specific browser actions; it benefits from a faster, cheaper model.

## Browser Support Constraints and What Does Not Work

Nanobrowser officially supports Chrome and Edge only. The README explicitly lists Firefox, Safari, and other Chromium-based browsers (Opera, Arc) as not supported. While the extension may function on some of those browsers, the project does not test or guarantee compatibility.

The extension cannot automate tasks that require a specific non-Chrome browser, bypass browser security policies, or interact with browser-level UI outside the web page (for example, browser settings dialogs). Tasks that require precise interaction with complex web applications may fail when the page layout is unusual or when JavaScript-heavy interfaces update the DOM between the Navigator's action and the Planner's next check.

The README notes that local models require more careful prompting than hosted API models. An ambiguous or high-level task description that works well with Claude Sonnet 4 may fail or loop with a local model. This makes the extension harder to use predictably when cost is controlled through local inference.

The latest release is v0.1.13, and the project is in a pre-1.0 state. The version number signals that the API and feature set are still evolving.

## Nanobrowser vs OpenAI Operator

OpenAI Operator is a hosted, subscription-based browser automation service from OpenAI. Nanobrowser is a local Chrome extension with no subscription. The practical difference is where control sits: Operator runs in OpenAI's infrastructure with a managed browser, while Nanobrowser runs in the user's own browser using the user's own API keys.

Operator provides a fixed, curated experience with its own model and interface. Nanobrowser lets the user choose any supported LLM, assign different models to different agents, and see the source code for exactly how automation is performed. The transparency comes with a cost: the user is responsible for configuring keys, selecting models, and handling cases where the Planner misreads a page.

For teams that need auditable automation code, the ability to run local models with zero data transmission, or control over which LLM vendor they use, Nanobrowser offers a different set of trade-offs than Operator. For teams that want a polished product without configuration work, Operator is the more managed option.

## Conclusion

Nanobrowser suits engineers and technical users who want browser automation with full control over which LLM they use and without paying a service subscription. The hard requirement is Chrome or Edge; Firefox and Safari users have no supported path. Anyone evaluating the extension for production workflows should check the latest release (v0.1.13 as of the last push on 2026-08-18) against their LLM provider of choice, since local model performance varies and the README recommends avoiding high-level ambiguous commands when using Ollama or other local providers. Teams with strict data-governance requirements should review PRIVACY.md before enabling PostHog analytics via the .env.example configuration.

## FAQ

### What is Nanobrowser?

Nanobrowser is a free, open-source Chrome extension that automates web tasks using a two-agent AI system (Planner and Navigator). Users configure their own LLM API keys; no subscription or Nanobrowser account is required.

### How do I use Nanobrowser?

Install the extension from the Chrome Web Store or manually via the GitHub releases page. After install, open the side panel by clicking the Nanobrowser icon, go to Settings to add your LLM API keys, choose a model for each agent, and type your automation task in the chat interface.

### Is Nanobrowser safe to use?

The README states that all processing runs locally in the user's browser and that credentials stay with the user, never shared with any cloud service. The repository includes a PRIVACY.md file and the source code is available for inspection under the Apache-2.0 license.

### How does Nanobrowser compare to browser-use?

The README does not document a comparison with browser-use. Nanobrowser is a Chrome extension with a Planner and Navigator agent pair; users configure their own LLM API keys and the extension runs entirely in the browser without a separate Python process.

## Sources

- [License: Apache-2.0](https://github.com/nanobrowser/nanobrowser/blob/master/LICENSE)
- [nanobrowser/nanobrowser on GitHub](https://github.com/nanobrowser/nanobrowser)
- [Project website](https://nanobrowser.ai)
- [README](https://github.com/nanobrowser/nanobrowser/blob/master/README.md)
- [Releases](https://github.com/nanobrowser/nanobrowser/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nanobrowser-nanobrowser