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 · GitHub repository · Download · Watch the demo
Why build another browser?
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.
What can it actually do?
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.
How the assistant sees a page
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 explain the process boundaries, page tools, and execution loop.
Choose the model that fits the task
Nabsun separates the browser tools from the model using them.
- Built-in local model: Qwen3 1.7B runs on your CPU without an account or API key.
- Your local stack: connect Ollama or configure a different local model.
- Cloud APIs: configure Anthropic or OpenAI in Settings.
- Existing assistant accounts: connect Codex or Claude Code through Extensions → Assistants.
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.
Connect your editor to your real browser
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.
A signed-in browser needs clear boundaries
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:
- Prompt injection remains a risk. Instructions on a malicious page can influence a model; approval controls do not eliminate that problem.
- Structured tools restrict credential handling. Password and one-time-code values are excluded from structured extraction, and typing into those fields is blocked. Arbitrary page JavaScript has broader access.
- Plugins and MCP servers are trusted code. Plugins run with full Node privileges; they are not sandboxed.
- Stop cancels pending work. It cannot undo an action that has already completed.
Nabsun has not had an independent security audit. The security document describes the controls and remaining gaps.
Why open source? Why MIT?
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:
- What context reaches the selected model?
- Where are credentials stored?
- Which actions require approval?
- What changes when Autopilot is enabled?
- What privileges does an integration receive?
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.
Where it stands today
This is an early project, with real limitations:
- No automatic updates, profile sync, or private browsing mode.
- Unsigned Windows builds; macOS builds use ad-hoc signing without notarization.
- Apple silicon has been tested locally; Intel Mac remains unverified. Linux release packaging is not supported yet.
- The small bundled model can struggle with long tasks.
- No managed enterprise policy, central action audit log, or plugin sandbox.
The README is the place to check current setup instructions and platform support.
Try it in a few minutes
Download an available build from GitHub Releases. 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 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?
