# I Built Nabsun: An Open-Source AI Browser That Works in Your Real Tabs

> Source: <https://dev.to/naveen_alavilli/i-built-nabsun-an-open-source-ai-browser-that-works-in-your-real-tabs-1ea3>
> Published: 2026-09-25 00:57:06+00:00

You have three documentation tabs open, a form half-filled, and the account you need already signed in.

Then you ask an AI assistant for help—and start copying everything into a chat window.

That gap is why I built **Nabsun**, an open-source browser with an AI assistant built in. It can read the page you are looking at, compare information across tabs, and use browser tools to help complete a task in your existing session.

**It works where your work already is.**

Nabsun is built with Chromium and Electron. You can use its bundled local model, connect a cloud provider, or bring Codex or Claude Code into the browser. It is a developer preview, and the source is available under MIT.

[Website](https://nabsun.com) · [GitHub repository](https://github.com/naveenalavilli/nabsun) · [Download](https://github.com/naveenalavilli/nabsun/releases/latest) · [Watch the demo](https://www.youtube.com/watch?v=mCyKPYy7OHw)

The browser already holds much of the context an assistant needs: the page you are reading, the tabs you are comparing, and the application you are signed into.

Moving that work into a separate chat creates friction. You copy context over, get an answer, switch back, and translate the answer into clicks and keystrokes. A separate automation session can introduce another problem: getting it into the same state as your real session.

I wanted to make that handoff smaller.

In Nabsun, the assistant sits beside your tabs. The browser provides page-reading tools, action tools, and approval controls. You can watch the work happen and take over in the same tab.

That is the reason to build at the browser layer: **context, actions, and user control can live together.**

Open the assistant with **Ctrl+Shift+A**. Start with the current page or give it a task involving several tabs.

Here are examples of tasks to try—not promises that every model will complete every website workflow:

| Task | Example prompt | 
|---|---|
| Understand a page | “Summarize this documentation and point out the setup requirements.” | 
| Compare tabs | “Compare the options in these tabs. Make a table and link each finding to its source.” | 
| Extract information | “Turn this table into structured records. Flag missing values.” | 
| Prepare a form | “Fill this form using the details I provide. Stop before submitting.” | 
| Research a question | “Find the relevant documentation, read it, and explain the answer with links.” | 

The assistant can read, click, type, select options, scroll, and navigate. It can ask for clarification when a choice belongs to you.

Nabsun also includes the everyday browser features that make this practical: tabs, bookmarks, history, downloads, session restore, and encrypted saved passwords.

The useful distinction is the move from **discussing a task** to **helping carry it out**, while keeping the result visible.

For developers, this is one of the more interesting parts.

Nabsun provides an accessibility-derived outline of the page. Interactive elements receive opaque references that the agent can use with tools such as click, type, and select.

The normal loop is:

```
Read the page → choose an element → request an action
             → apply approval settings → act → read the updated page
```

The page bridge rejects stale references and changed element identities instead of silently using them against a different target.

This gives the agent a structured way to interact with a page without relying on screen coordinates for every action. It does not make arbitrary websites reliable: iframe and shadow-root coverage are limited, and website compatibility varies.

The [architecture notes](https://github.com/naveenalavilli/nabsun/blob/main/ARCHITECTURE.md) explain the process boundaries, page tools, and execution loop.

Nabsun separates the browser tools from the model using them.

For the CLI connections, Nabsun installs the official native CLI when needed and can reuse existing sign-ins. Your provider account must have access to the assistant. Credentials remain in the CLI's own store; signing out also affects that CLI outside Nabsun.

The bundled model matters because you can start without opening another account or paying for hosted inference. It is suitable for simple tasks; complex research and long action sequences benefit from a stronger model.

**Local inference works offline. Visiting websites still needs a network.** Cloud providers and signed-in CLI assistants use their respective services and receive the context sent to them. Ollama is local only when its endpoint is local.

Optional personal context lives in `soul.md`, a Markdown file shared only with local providers by default.

Nabsun also exposes an **MCP server**.

That lets an external agent use Nabsun's browser tools against your existing tabs. An assistant in your development workflow can access the browser through a defined interface.

Copy the configuration from:

**Settings → Integrations → Connect an external agent**

The sidebar and external agents use the same browser approval settings. The bridge listens on loopback and uses a fresh bearer token for each launch.

Nabsun can also consume tools from MCP servers, load plugins, and load unpacked Chrome extensions. Chrome API support is partial, and there is no Chrome Web Store installation flow yet.

An assistant acting inside your session has meaningful access. The controls deserve as much attention as the capabilities.

By default, reading tools run automatically. Clicking, typing, navigation, and page code require approval. Per-tool grants and Autopilot change those settings, including for connected external agents.

The application UI and web pages run in separate renderers. Action targets are captured before approval and revalidated before dispatch.

Those controls have limits:

Nabsun has **not had an independent security audit**. The [security document](https://github.com/naveenalavilli/nabsun/blob/main/SECURITY.md) describes the controls and remaining gaps.

A browser assistant can encounter private documents, internal applications, and authenticated sessions. People should be able to inspect how it handles that access.

Publishing the source makes concrete questions inspectable:

Open source does not automatically make software secure. It makes the implementation available for review, criticism, and improvement.

MIT also gives developers room to experiment: fork the browser, change its tools, adapt the interface, or reuse parts in another project under the license's terms. I want people building agent tools to be able to work with the implementation.

Nabsun's code is MIT-licensed. Bundled dependencies and model weights retain their own licenses and notices; those are documented in [third-party notices](https://github.com/naveenalavilli/nabsun/blob/main/THIRD-PARTY-NOTICES.md).

This is an early project, with real limitations:

The [README](https://github.com/naveenalavilli/nabsun#readme) is the place to check current setup instructions and platform support.

Download an available build from [GitHub Releases](https://github.com/naveenalavilli/nabsun/releases/latest). Windows has an installer and a portable executable. The bundled model makes the download roughly 1.4 GB; verify your download against the release's `SHA256SUMS.txt`.

Or, with Node.js, npm, and Git installed:

```
git clone https://github.com/naveenalavilli/nabsun.git
cd nabsun
npm ci
npm run fetch:model
npm start
```

If Electron did not download during installation, run `npm run setup`. Linux source setup requires manual engine setup; follow the instructions printed by `fetch:model`.

For a first task, open a public documentation page, press **Ctrl+Shift+A**, and ask:

Summarize this page, identify the prerequisites, and link to the sections I should read next.

Then try comparing two tabs. Start with something whose answer you can check.

If you want to contribute, the [contributor guide](https://github.com/naveenalavilli/nabsun/blob/main/CONTRIBUTING.md) is the starting point. Reproducible website failures, clearer permission flows, and improvements to page tools would all be useful feedback.

**What is one browser task you would hand to an assistant—and what would you need to see before letting it act?**