# Changelog
Source: https://docs.browseros.com/changelog
What's new in BrowserOS
All notable changes to BrowserOS are documented here. For the full release history with download links, see our [GitHub Releases](https://github.com/browseros-ai/BrowserOS/releases).
***
## v0.46.0
June 17, 2026
* **Claude Code & Codex in your browser** — The agent harness now bundles full coding agents. Claude Code and Codex plug straight into the assistant, so you can drive your browser with the agent — and the subscription — you already use.
* **A brand new experience** — A redesigned new tab, a calmer composer, and a rebuilt command center for switching between agents. The whole assistant is cleaner, faster to reach, and easier to live in.
* **New MCP tools** — A tighter, more reliable browser tool surface for agents, rebuilt from the ground up. Plus one-click install of BrowserOS as an MCP server into the agents you already run, with automatic URL sync.
* **Chromium 148** — Updated to the latest Chromium base with all recent upstream fixes and security patches
* **Streamlined** — We've pulled back a few features that weren't getting much use — Skills, Soul, and Memory — so we can focus and ship better versions soon.
***
## v0.44.0
March 20, 2026
* **ChatGPT Pro & GitHub Copilot** — Already paying for ChatGPT Pro, Plus, or GitHub Copilot? Use that subscription to automate browser tasks in BrowserOS at no extra cost — just log in with your existing account.
* **Voice input** — Talk to your agent instead of typing. The chat bar now accepts voice input for any query.
* **Smarter agent** — Overhauled agent grounding for more reliable and precise browser actions.
* **Bug fixes & reliability** — Improved memory tools, fixed fill tool issues, new tab layout fixes, and numerous stability improvements across the board.
***
## v0.43.0
March 12, 2026
* **Skills** — Reusable instructions that teach your agent how to handle specific tasks. Ships with 12 built-in skills like deep research, price comparison, and form filling — and you can create your own.
* **Memory** — Your assistant now remembers you across conversations. Core memory stores permanent facts like your name and projects, while daily notes capture session context and auto-expire after 30 days. Everything stays local on your machine.
* **Kimi K2.5** — In partnership with Moonshot AI, Kimi K2.5 is now the default model in BrowserOS — open-source, multimodal, and great for browser automation. Bring your own key from [platform.moonshot.ai](https://platform.moonshot.ai/) anytime.
* **SOUL.md** — Shape your assistant's personality, tone, and boundaries. It evolves on its own as you interact — the more you use it, the more it feels like yours.
***
## v0.42.0
March 9, 2026
* **SOUL.md** — Your assistant now has a soul. Tell it how you like to communicate, set boundaries, shape its personality — and it adapts on its own over time. The more you use it, the more it feels like *your* assistant.
* **Vertical tabs** — One of the most requested features is here. BrowserOS now ships with vertical tabs by default. More screen space, better tab management, and a cleaner layout out of the box. Prefer horizontal? You can switch back anytime in settings. [Read more →](/features/vertical-tabs)
* **Long-term memory** — Your assistant finally remembers you. Your name, your projects, what you talked about last week — it carries context across every conversation so you never have to repeat yourself. All stored locally on your machine.
* **Chromium 146** — Updated to the latest Chromium release with all recent upstream fixes and security patches
***
## v0.41.0
March 4, 2026
* **New agent (v3)** — Completely redone from scratch. 2x faster, 2–3x better performance
* **Tools — major upgrade** — Agent tools and MCP server both got a big overhaul. \~20 new tools (54 total) including file upload, save as PDF, background windows, and more. Connection with third-party coding agents (Claude Code, Codex, etc.) is much better now
* **General fixes** — Better agent installation, bug fixes, and smoother experience overall
* **Linux Debian packaging** — Fixed the remaining Debian packaging issues
***
## v0.40.1
February 16, 2026
* **Chromium 145** — Upgraded to the latest Chromium base with all recent upstream fixes and security patches
* **Login session import improvements** — Importing login sessions is now more reliable
* **Stability & reliability** — General improvements across the board
***
## v0.39.0
February 3, 2026
* **Sync** — Save your browser configuration, agent history, and scheduled tasks across machines. Your setup now follows you wherever you go
* **App Connector redesign** — Connecting MCP apps is now easier. The new App Connector UI makes it simpler to discover, install, and manage your connected apps
* **MCP port stability** — Additional fixes for users still experiencing port issues. More reliable connections across restarts
* **Keyboard shortcuts** — Updated shortcuts to avoid conflicts with European keyboards
***
## v0.38.0
January 28, 2026
Bug fix and stability release.
* **MCP port fix on Windows & Linux** — Fixed an issue with MCP port. Port now stays consistent across restarts and made it more reliable
* **Settings fix** — Fixed `chrome.browser.settings` not working correctly. Settings should now persist and apply as expected
* **Improved agent** — Made the agent more reliable and performant. General stability fixes across the agent loop
***
## v0.37.0
January 21, 2026
* **Workflows** — Build reliable, repeatable browser automations with a visual graph builder. Chat with the workflow agent to define step-by-step automation—ideal for complex tasks where ad-hoc prompts aren't enough.
* **Cowork** — Describe an outcome, step away, and come back to finished work. Combine browser automation with local file operations—research on the web and save reports, scrape data and export to files, all in one task. [Read more →](/features/cowork)
***
## v0.36.3
January 15, 2026
* **Agent history** — Agent conversations are now saved automatically. View and resume them anytime from the Assistant panel
***
## v0.36.2
January 10, 2026
Bug fix release focused on MCP stability.
* **MCP server disconnect fix** — Fixed port handling issue causing MCP connections to drop unexpectedly
***
## v0.36.0
January 8, 2026
* **Agent personalization** — Add your own prompts to personalize the agent. Tweak its behavior, adjust how it responds, set your preferred formatting, and more
* **Toolbar customization** — Hide the Hub chat and labels from the settings page to declutter your toolbar
* **MCP server port stability** — The port now stays consistent through browser restarts, so you don't have to keep updating your MCP clients
* **Fixed agent install/update issues** — The agent now handles installs and updates more proactively
***
## v0.35.0
December 25, 2025
* **Agent stability fixes** — Fixed bugs to make the agent loop much more reliable
* **Gemini 3 support** — Gemini 3 now supported through OpenRouter and Google adapters
* **Better error surfacing** — Error messages are now clearer
***
## v0.34.0
December 20, 2025
* **Third-party MCP server support** — Connect external MCP servers like Google Calendar, Notion, Google Docs, Gmail, and more. You can also connect your own custom MCP servers
* **Gemini 3 support** — Gemini 3 Pro and Flash models now work with BrowserOS
* **Windows icon fix** — The Windows icon now displays BrowserOS logo correctly
* **Agent & UI improvements** — Various agent loop fixes and UI polish
***
## v0.33.0
December 18, 2025
* **OpenAI-compatible provider support** — Connect any OpenAI-compatible API endpoint
* **Multi-window & multi-profile agent support** — Agent now works across multiple windows and browser profiles
* **MCP server reliability** — Fixed connection drops and improved stability
* **Agent reliability improvements** — General stability fixes
***
## v0.32.0
December 12, 2025
A complete revamp of BrowserOS.
**New features:**
* **New Agent** — Completely rebuilt agent: faster, smarter, and more reliable
* **Agent Per Tab** — Run multiple agents in different tabs simultaneously
* **Polished UI** — Fresh, cleaner interface design
* **Manifest V2 Support** — Ad blockers like uBlock Origin work again
* **Native Split View** — Work on two things side by side
* **Chromium 142** — Updated to Chromium 142.0.7444.49
* **Azure & AWS Bedrock** — Native support for Azure OpenAI and AWS Bedrock models
**Breaking changes:**
* Old agent will stop working — update required
* LLM provider settings won't carry over — reconfiguration needed
***
## v0.30.0
November 14, 2025
* **Better text extraction** — Improved copy button in LLM Chat
* **MCP server stability** — Improved connection reliability
* **UI cleanup** — Unpinned extensions for cleaner look
* **Third-party MCP fixes** — Fixed support for third-party MCP servers
***
For older releases, see the [full release history on GitHub](https://github.com/browseros-ai/BrowserOS/releases).
# Chrome DevTools MCP
Source: https://docs.browseros.com/comparisons/chrome-devtools-mcp
A developer-focused comparison of BrowserOS MCP and Chrome DevTools MCP for browser automation
Both BrowserOS MCP and [Chrome DevTools MCP](https://github.com/ChromeDevTools/chrome-devtools-mcp) give AI agents control over a browser via the Model Context Protocol. But they're built for different scopes. Chrome DevTools MCP focuses on debugging and inspection, while BrowserOS MCP is a complete browser automation and app integration platform.
This page breaks down the differences for developers evaluating which to use with Claude Code, Gemini CLI, Cursor, or any MCP client.
***
## At a Glance
| | **BrowserOS MCP** | **Chrome DevTools MCP** |
| ----------------------------- | -------------------------------------------------- | ----------------------------------------------------------------------- |
| **Total MCP tools** | 53 | 29 |
| **External app integrations** | 40+ (Gmail, Slack, GitHub, etc.) | None |
| **Setup** | Copy URL from settings, works instantly | Requires `--remote-debugging-port` flag and separate server process |
| **Browser session** | Your real browser with cookies, logins, extensions | Attached debug session (some sites block WebDriver-controlled browsers) |
| **Architecture** | Built into the browser | External Node.js process connecting via CDP |
***
## Feature Comparison
### Navigation & Tab Management
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| ----------------------------------------- | :---------------: | :-----------------: |
| Navigate to URL / back / forward / reload | `navigate_page` | `navigate_page` |
| Open new tab | `new_page` | `new_page` |
| Close tab | `close_page` | `close_page` |
| List open tabs | `list_pages` | `list_pages` |
| Switch to tab | `show_page` | `select_page` |
| Hidden/background tabs | `new_hidden_page` | - |
| Move tab between windows | `move_page` | - |
| Get active/focused tab | `get_active_page` | - |
| Wait for condition | - | `wait_for` |
### Content & Observation
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| ------------------------------- | :----------------------: | :-----------------: |
| Accessibility tree snapshot | `take_snapshot` | `take_snapshot` |
| Enhanced structural snapshot | `take_enhanced_snapshot` | - |
| Page content as Markdown | `get_page_content` | - |
| Extract all page links | `get_page_links` | - |
| Raw HTML / DOM access | `get_dom` | - |
| Search DOM (text / CSS / XPath) | `search_dom` | - |
| Screenshot | `take_screenshot` | `take_screenshot` |
| Execute JavaScript | `evaluate_script` | `evaluate_script` |
### Interaction & Input
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| ----------------------------- | :-----------------: | :-----------------: |
| Click element | `click` | `click` |
| Click at coordinates | `click_at` | - |
| Type / fill text | `fill` | `fill` |
| Fill entire form | - | `fill_form` |
| Type text (raw keystrokes) | - | `type_text` |
| Clear input | `clear` | - |
| Hover | `hover` | `hover` |
| Drag | `drag` | `drag` |
| Press key / key combo | `press_key` | `press_key` |
| Check / uncheck checkbox | `check` / `uncheck` | - |
| Select dropdown option | `select_option` | - |
| Focus element | `focus` | - |
| Scroll (directional) | `scroll` | - |
| Upload file | `upload_file` | `upload_file` |
| Handle dialog (alert/confirm) | `handle_dialog` | `handle_dialog` |
### File & Export
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| ----------------------- | :---------------: | :-----------------: |
| Save page as PDF | `save_pdf` | - |
| Save screenshot to disk | `save_screenshot` | - |
| Download file via click | `download_file` | - |
### Window Management
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| ----------------------- | :--------------------: | :-----------------: |
| List windows | `list_windows` | - |
| Create window | `create_window` | - |
| Create hidden window | `create_hidden_window` | - |
| Close window | `close_window` | - |
| Activate / focus window | `activate_window` | - |
### Tab Groups
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| -------------------------- | :----------------: | :-----------------: |
| List tab groups | `list_tab_groups` | - |
| Create tab group | `group_tabs` | - |
| Update group (title/color) | `update_tab_group` | - |
| Ungroup tabs | `ungroup_tabs` | - |
| Close tab group | `close_tab_group` | - |
### Bookmarks
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| ------------------------ | :----------------: | :-----------------: |
| List bookmarks | `get_bookmarks` | - |
| Create bookmark / folder | `create_bookmark` | - |
| Remove bookmark | `remove_bookmark` | - |
| Update bookmark | `update_bookmark` | - |
| Move bookmark | `move_bookmark` | - |
| Search bookmarks | `search_bookmarks` | - |
### History
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| ----------------------- | :--------------------: | :-----------------: |
| Search history | `search_history` | - |
| Get recent history | `get_recent_history` | - |
| Delete URL from history | `delete_history_url` | - |
| Delete history range | `delete_history_range` | - |
### Debugging & Performance
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| -------------------------- | :-----------: | :--------------------------------------------------: |
| Console messages | Coming soon | `get_console_message` / `list_console_messages` |
| Network request inspection | Coming soon | `get_network_request` / `list_network_requests` |
| Performance tracing | Coming soon | `performance_start_trace` / `performance_stop_trace` |
| Performance analysis | Coming soon | `performance_analyze_insight` |
| Memory snapshot | Coming soon | `take_memory_snapshot` |
| Lighthouse audit | Coming soon | `lighthouse_audit` |
| Device / network emulation | Coming soon | `emulate` |
| Resize viewport | Coming soon | `resize_page` |
### External App Integrations
| Feature | BrowserOS MCP | Chrome DevTools MCP |
| ------------------------------------ | :-----------: | :-----------------: |
| Gmail, Outlook | Yes | - |
| Google Calendar, Outlook Calendar | Yes | - |
| Slack, Discord, Teams, WhatsApp | Yes | - |
| GitHub, GitLab | Yes | - |
| Linear, Jira, Asana, Monday, ClickUp | Yes | - |
| Notion, Google Docs/Sheets/Drive | Yes | - |
| Figma, Canva | Yes | - |
| Salesforce, HubSpot | Yes | - |
| Shopify, Stripe | Yes | - |
| 20+ more services | Yes | - |
***
## Setup Comparison
BrowserOS MCP is built into the browser. No separate process, no debug flags.
```bash theme={null}
# One command, done
claude mcp add --transport http browseros http://127.0.0.1:9239/mcp --scope user
```
The server URL is available at `chrome://browseros/mcp`. Copy it and connect.
Chrome DevTools MCP requires launching Chrome with remote debugging enabled and running a separate Node.js server.
```bash theme={null}
# Step 1: Launch Chrome with debug port
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222
# Step 2: Install and run the MCP server
npx @anthropic-ai/chrome-devtools-mcp@latest
# Step 3: Connect your MCP client to the server
```
Some sites may block sign-in when the browser is controlled via WebDriver (the default launch mechanism).
***
## Summary
| Dimension | BrowserOS MCP | Chrome DevTools MCP |
| ----------------------------------------- | :------------------------: | :------------------------------: |
| Browser automation tools | **54** | **29** |
| External app integrations | **40+** | **0** |
| Window management | Yes | No |
| Tab groups | Yes | No |
| Bookmarks & history | Yes | No |
| File export (PDF, screenshots, downloads) | Yes | No |
| Content extraction (Markdown, links, DOM) | Yes | No |
| Console / network inspection | Coming soon | Yes |
| Performance tracing & Lighthouse | Coming soon | Yes |
| Memory snapshots | Coming soon | Yes |
| Device emulation | Coming soon | Yes |
| Setup complexity | Copy URL | Debug port + Node server |
| Browser session | Real (cookies, extensions) | Debug-attached (WebDriver flags) |
BrowserOS MCP gives you a broader automation surface: browser control, content extraction, file operations, and 40+ app integrations through a single connection. Debugging and performance tools are coming soon to BrowserOS MCP, which will close the remaining gap with Chrome DevTools MCP. For most AI agent workflows, BrowserOS MCP already covers more ground out of the box.
# Claude Cowork
Source: https://docs.browseros.com/comparisons/claude-cowork
How BrowserOS Cowork compares to Claude Cowork for getting real work done with AI
Both BrowserOS Cowork and [Claude Cowork](https://claude.com/product/cowork) let an AI agent work with your local files autonomously. You describe a task, step away, and come back to completed work. They share a similar file toolkit under the hood. The key difference is what else each product can do. BrowserOS Cowork runs inside a real browser with full web access and 40+ app integrations. Claude Cowork runs inside an isolated VM with professional document generation.
This page compares both products so you can decide which fits your workflow.
***
## At a Glance
| | **BrowserOS Cowork** | **Claude Cowork** |
| ----------------------- | ------------------------------------------------------- | ---------------------------------------------------------- |
| **Runs in** | Your real browser | Claude Desktop app (VM) |
| **File tools** | Read, write, edit, search, organize | Read, write, edit, search, organize |
| **Browser automation** | Yes, 53 tools (click, type, screenshot, navigate, etc.) | No |
| **App integrations** | 40+ (Gmail, Slack, GitHub, Calendar, Notion, etc.) | \~4 connectors (Google Drive, Gmail, DocuSign) |
| **AI model** | Your choice (Claude, GPT, Gemini, Kimi, local models) | Claude only |
| **Internet access** | Full (through your real browser) | Restricted |
| **Document generation** | Basic (HTML, Markdown, CSV) | Advanced (Excel with formulas, PowerPoint, formatted docs) |
| **Pricing** | Free (bring your own AI key) | Requires paid Claude subscription |
| **Platform** | Any OS with BrowserOS | macOS, Windows x64 |
***
## Feature Comparison
### File Operations
Both products provide a comparable set of file tools. You can read, write, edit, search, and organize files in both. This is table-stakes for both products.
| What you can do | BrowserOS Cowork | Claude Cowork |
| --------------------------------- | :--------------: | :-----------------: |
| Read and view files | Yes | Yes |
| Create and save new files | Yes | Yes |
| Edit specific parts of a file | Yes | Yes |
| Search inside files for text | Yes | Yes |
| Find files by name or pattern | Yes | Yes |
| List and browse folders | Yes | Yes |
| Run commands/scripts | Yes | Yes |
| Break work into parallel subtasks | Coming soon | Built-in sub-agents |
The file tools are largely equivalent. The real differentiator is what else each product can do beyond file operations.
### Working with the Web
This is the biggest difference. BrowserOS Cowork runs inside a real browser with your existing logins and sessions.
| What you can do | BrowserOS Cowork | Claude Cowork |
| ------------------------------------ | :-----------------------------: | :-----------: |
| Open and navigate websites | Yes | No |
| Click buttons, fill forms, type text | Yes | No |
| Take screenshots of web pages | Yes | No |
| Extract content from web pages | Yes | No |
| Save pages as PDF | Yes | No |
| Download files from the web | Yes | No |
| Access sites where you're logged in | Yes (your real browser session) | No |
| Manage tabs, windows, and bookmarks | Yes | No |
| Search your browsing history | Yes | No |
Claude Cowork has no browser access. If your task involves anything on the web, whether that's researching, filling out forms, grabbing content from a site, or checking on a web app, you need BrowserOS.
### Connected Apps
BrowserOS connects to 40+ services directly. Claude Cowork has a handful of connectors.
| Service | BrowserOS Cowork | Claude Cowork |
| --------------------- | :--------------: | :-----------: |
| Gmail | Yes | Yes |
| Google Drive | Yes | Yes |
| Google Calendar | Yes | Limited |
| Slack | Yes | No |
| GitHub | Yes | No |
| Linear / Jira / Asana | Yes | No |
| Notion | Yes | No |
| Figma | Yes | No |
| Salesforce / HubSpot | Yes | No |
| Shopify / Stripe | Yes | No |
| 30+ more services | Yes | No |
### Document Generation
Claude Cowork has an edge when it comes to creating polished office documents.
| What you can do | BrowserOS Cowork | Claude Cowork |
| --------------------------- | :--------------: | :-----------: |
| HTML and Markdown files | Yes | Yes |
| CSV and data files | Yes | Yes |
| Excel with working formulas | No | Yes |
| PowerPoint presentations | No | Yes |
| Formatted Word documents | No | Yes |
***
## How They Work
BrowserOS Cowork runs inside the browser. The agent has access to your real browser session (cookies, logins, extensions) and a sandboxed folder on your computer.
* Works in your real browser with your existing logins
* File access sandboxed to the folder you select
* 40+ app integrations via OAuth
* Connect from any AI tool (Claude Code, Gemini CLI, Cursor, etc.)
* Uses whatever AI model you choose
Claude Cowork runs in an isolated virtual machine on your desktop via the Claude Desktop app.
* Runs in a secure VM, isolated from your main system
* File access to folders you grant permission to
* \~4 connectors (Google Drive, Gmail, DocuSign, FactSet)
* Only works in the Claude Desktop app
* Uses Claude models only
* Comes pre-loaded with Python, Node.js, Ruby, and common tools
***
## Where Claude Cowork Shines
* **Professional documents**: Create Excel spreadsheets with working formulas, PowerPoint presentations, and formatted Word documents
* **Parallel subtasks**: Automatically breaks complex work into smaller tasks that run at the same time
* **Stronger isolation**: Runs in a full virtual machine, giving you OS-level separation from your main system
* **Zero setup**: Works out of the box in the Claude Desktop app with pre-installed tools and languages
***
## Where BrowserOS Cowork Shines
* **Full browser access**: Navigate websites, fill forms, click buttons, take screenshots, and extract content from any page. Claude Cowork cannot touch the web.
* **Your real logins**: Because it runs in your actual browser, the agent can access sites where you're already logged in: dashboards, internal tools, social media, banking portals, anything.
* **40+ app integrations**: Gmail, Slack, GitHub, Calendar, Notion, Linear, Figma, Salesforce, and more. All accessible in the same session as your file work. Claude Cowork has about 4 connectors.
* **Pick your AI model**: Use Claude, GPT-5, Gemini, Kimi K2.5, or a local model. Claude Cowork only works with Claude.
* **Full internet access**: Your agent can visit any website. Claude Cowork's VM is restricted to a short list of allowed sites.
* **Free**: BrowserOS is free. Just bring your own AI API key. Claude Cowork requires a paid Claude subscription.
***
## Summary
| | BrowserOS Cowork | Claude Cowork |
| -------------------------------------- | :-----------------------------------------: | :-----------------: |
| File tools (read, write, edit, search) | Yes | Yes |
| Browse the web | **Yes (53 tools)** | No |
| Connected apps | **40+** | \~4 |
| Internet access | Full | Restricted |
| Choose your AI model | Yes | Claude only |
| Works with other AI tools | Yes (Claude Code, Gemini CLI, Cursor, etc.) | Claude Desktop only |
| Excel, PowerPoint, Word | No | **Yes** |
| Parallel subtasks | Coming soon | **Built-in** |
| Security model | Folder-level sandbox | VM isolation |
| Platform | Any OS | macOS, Windows x64 |
| Pricing | Free + API key | Paid subscription |
Both products handle file operations equally well. The choice comes down to what else you need. If your work touches the web, connected apps, or you want to choose your own AI model, BrowserOS Cowork gives you that. If you need polished office documents and prefer a fully isolated desktop experience, Claude Cowork is a good fit.
# OpenClaw
Source: https://docs.browseros.com/comparisons/openclaw
How BrowserOS compares to OpenClaw for everyday AI assistance
[OpenClaw](https://openclaw.ai/) is an open-source personal AI assistant that runs on your machine and connects through messaging apps like WhatsApp, Telegram, Slack, and Discord. It is a powerful tool for technical users who want a self-hosted, always-on AI agent.
BrowserOS takes a different approach. Instead of running a background server that you message through chat apps, BrowserOS puts the AI assistant directly inside your browser, where most of your work already happens. No terminal setup, no daemon management, no Node.js required.
This comparison is for users deciding which tool fits their needs.
## At a Glance
| | **BrowserOS** | **OpenClaw** |
| -------------------------- | --------------------------------------------------------------------------- | ---------------------------------------------------------- |
| **What it is** | AI-powered browser with built-in assistant | Self-hosted AI agent you message through chat apps |
| **Setup** | Download and open | Install via npm, run onboarding wizard, configure daemon |
| **Technical skill needed** | None | Comfortable with terminal and Node.js |
| **Interface** | Built into your browser | WhatsApp, Telegram, Slack, Discord, iMessage, and 15+ more |
| **Browser automation** | 53 tools (clicks, forms, navigation, screenshots, tabs, bookmarks, history) | Chrome via CDP (snapshots and actions) |
| **App integrations** | 40+ built-in (OAuth or API key depending on the service) | Skills-based (community-built, self-installable) |
| **LLM support** | 11+ providers including local models (Ollama, LM Studio) | Multiple providers with failover routing |
| **Runs on** | macOS, Windows, Linux | macOS, Windows, Linux (+ iOS/Android companion apps) |
| **Authentication** | OAuth or API key depending on the service | API keys, OAuth, pairing codes per channel |
| **Open source** | Yes (AGPL-3.0) | Yes (MIT) |
## Where BrowserOS Shines
### No technical setup required
OpenClaw requires Node.js 22+, npm installation, a terminal-based onboarding wizard, daemon configuration (launchd or systemd), and channel pairing for each messaging platform. If something goes wrong, you need `openclaw doctor` to diagnose issues.
BrowserOS is a browser. Download it, open it, and start talking to the assistant. There is no daemon to manage, no services to keep running, and no terminal needed.
### Browser automation built in
BrowserOS gives the assistant full control of your browser with 53 tools: clicking buttons, filling forms, navigating between pages, taking screenshots, managing tabs, organizing bookmarks, searching history, and more. The assistant sees what you see and can interact with any website you are logged into.
OpenClaw has browser automation through a dedicated Chrome instance with CDP, but it runs as a separate process rather than being integrated into the browser you are already using. With BrowserOS, the assistant works directly in your browsing session with all your cookies, logins, and open tabs.
### 40+ app integrations built in
BrowserOS connects to Gmail, Google Calendar, Slack, Notion, GitHub, Linear, Jira, Figma, Salesforce, Stripe, and 30+ more services out of the box. Most services connect through OAuth (one-click sign-in), while some require an API key. Either way, the assistant detects when an app is not connected and walks you through the setup right in the conversation.
OpenClaw uses a skills system where integrations are community-built plugins. Some popular services have skills available, but connecting a new service often means finding the right skill, installing it, and configuring credentials manually.
### Works where you already are
Most of your work happens in a browser. BrowserOS puts the assistant right there, so it can see the page you are on, interact with web apps, and pull data from your open tabs. There is no context-switching between a chat app and your browser.
OpenClaw's approach of messaging through WhatsApp or Telegram is clever for mobile use, but when you are at your computer working in a browser, having the assistant inside that browser is more natural and more capable.
## Where OpenClaw Shines
### Messaging app access
OpenClaw connects to 20+ messaging platforms including WhatsApp, Telegram, Signal, iMessage, Discord, Slack, Microsoft Teams, and more. You can message your assistant from your phone or any chat app without opening a specific application. This is ideal if you want AI help on the go through apps you already have open.
BrowserOS is a desktop browser. To use the assistant, you need to be in BrowserOS.
### Always-on background agent
OpenClaw runs as a daemon on your machine, processing tasks even when you are not actively chatting. It supports cron jobs, webhooks, and Gmail Pub/Sub for automated triggers. It can wake up, do something, and report back through your messaging app.
BrowserOS has [scheduled tasks](/features/scheduled-tasks) that run automations on a schedule, but the browser needs to be running. OpenClaw's daemon approach is more suited for server-like always-on operation.
### Mobile companion apps
OpenClaw offers iOS and Android companion apps with camera access, voice input, screen recording, and device-level actions (notifications, contacts, calendar, SMS). This extends the assistant to your phone in a way that BrowserOS cannot currently match.
### Agent-to-agent communication
OpenClaw supports multi-session agent coordination where agents can discover each other, read transcripts, and send messages between sessions. This is useful for complex workflows where multiple specialized agents collaborate.
### Self-modifying skills
OpenClaw agents can write and install their own skills during a conversation. If the assistant does not have a capability, it can create one on the fly. This makes it extremely flexible for power users who want the agent to extend itself.
## Feature Comparison
### App Integrations
| Service | BrowserOS | OpenClaw |
| ------------------ | --------------------------- | ----------------- |
| Gmail | Built-in (OAuth) | Skill + API setup |
| Google Calendar | Built-in (OAuth) | Skill + API setup |
| Slack | Built-in (OAuth) | Built-in channel |
| Discord | Built-in (OAuth) | Built-in channel |
| Notion | Built-in (OAuth) | Skill |
| GitHub | Built-in (OAuth) | Skill |
| Linear | Built-in (OAuth or API key) | Skill |
| Jira | Built-in (OAuth) | Skill |
| Figma | Built-in (OAuth) | Skill |
| Salesforce | Built-in (OAuth) | Skill |
| Stripe | Built-in (API key) | Skill |
| WhatsApp | Built-in (OAuth) | Built-in channel |
| Shopify | Built-in (OAuth or API key) | Community skill |
| Total integrations | 40+ built-in | 50+ via skills |
### Setup and Maintenance
| | BrowserOS | OpenClaw |
| ----------------- | ---------------- | ------------------------------------------------ |
| Installation | Download browser | `npm install -g openclaw`, run onboarding wizard |
| Runtime | Open the browser | Daemon process (launchd/systemd) |
| Updates | Auto-update | `openclaw update --channel stable` |
| Troubleshooting | Built-in | `openclaw doctor` CLI tool |
| Node.js required | No | Yes (v22+) |
| Terminal required | No | Yes |
## Who Should Use What
* Want an AI assistant without any technical setup
* Do most of your work in a browser
* Need browser automation (filling forms, clicking buttons, extracting data)
* Want 40+ app integrations that connect with one click
* Prefer a visual interface over terminal commands
* Want to message your AI from WhatsApp, Telegram, or Signal
* Need an always-on agent that runs 24/7 as a background service
* Are comfortable with Node.js and terminal-based setup
* Want mobile companion apps for on-the-go access
* Need agents that can write their own extensions
## Using Both Together
BrowserOS and OpenClaw are not mutually exclusive. Some users run OpenClaw as their always-on mobile assistant (accessible through WhatsApp or Telegram) while using BrowserOS as their desktop browser for work that involves web apps, browser automation, and visual tasks. The two tools complement each other rather than compete directly.
# Contributing to BrowserOS
Source: https://docs.browseros.com/contributing
Guide to contributing to BrowserOS
BrowserOS has two main parts you can contribute to:
* **Agent** — The AI features, UI, and browser automation (TypeScript/React)
* **Browser** — The custom Chromium build (C++/Python)
Most contributors work on the Agent since it's much easier to set up.
## Quick Links
* [GitHub Repository](https://github.com/BrowserOS-ai/BrowserOS)
* [Discord Community](https://discord.gg/YKwjt5vuKr)
* [Report Issues](https://github.com/BrowserOS-ai/BrowserOS/issues)
## Ways to Contribute
**Report bugs** — [Open an issue](https://github.com/browseros-ai/BrowserOS/issues/new) with steps to reproduce, expected vs actual behavior, and screenshots.
**Suggest features** — Share ideas on [GitHub](https://github.com/browseros-ai/BrowserOS/issues/99) or [Discord](https://discord.gg/YKwjt5vuKr).
**Improve docs** — Docs live in `docs/` and use Mintlify. Edit pages and update `docs/docs.json` for navigation.
***
## Path 1: Agent Development
The Agent is a monorepo with 3 components:
| Component | Path | What it does |
| -------------- | --------------------- | -------------------------------------------------------- |
| **Agent UI** | `apps/app` | Chrome extension — chat interface, settings, side panel |
| **Server** | `apps/server` | Bun server — agent loop, MCP tools, API endpoints |
| **Controller** | `apps/controller-ext` | Chrome extension — bridges `chrome.*` APIs to the server |
### Architecture
### Setup
```bash theme={null}
# Clone the repo
git clone https://github.com/YOUR-USERNAME/BrowserOS.git
cd BrowserOS/packages/browseros-agent
# Install dependencies
bun install
# Copy environment files
cp apps/server/.env.example apps/server/.env.development
cp apps/app/.env.example apps/app/.env.development
```
### Running Locally
```bash theme={null}
# Terminal 1: Start the server
bun run start:server
# Terminal 2: Start the agent extension (dev mode)
bun run start:agent
```
Then load the extension in BrowserOS:
1. Go to `chrome://extensions/`
2. Enable **Developer mode**
3. Click **Load unpacked** and select the `apps/app/dist/` folder
### Commands
| Command | Description |
| ---------------------- | -------------------------------- |
| `bun run start:server` | Start the server |
| `bun run start:agent` | Start agent extension (dev mode) |
| `bun run build:server` | Build server for production |
| `bun run build:agent` | Build agent extension |
| `bun run build:ext` | Build controller extension |
| `bun run test` | Run tests |
| `bun run lint` | Check with Biome |
| `bun run typecheck` | TypeScript check |
***
## Path 2: Browser Development
Only go down this path if you're working on Chromium-level features like patches to the browser itself.
**Requirements:**
* \~100GB disk space
* 16GB+ RAM recommended
* 3+ hours for first build
### Prerequisites
* macOS with Xcode and Command Line Tools
* Python 3.12+
* [UV](https://docs.astral.sh/uv/) (Python package manager)
* Git
* Ubuntu 20.04+ or similar
* build-essential package
* Python 3.12+
* [UV](https://docs.astral.sh/uv/)
* Git
* Windows 10/11
* Visual Studio 2022 with C++ workload
* Python 3.12+
* [UV](https://docs.astral.sh/uv/)
* Git
### Build Instructions
**1. Clone Chromium source**
Follow the official [Chromium: Get the Code](https://www.chromium.org/developers/how-tos/get-the-code/) guide. This sets up `depot_tools` and fetches \~100GB of source code.
Note the path where you clone it (e.g., `~/chromium/src`).
**2. Install UV and dependencies**
```bash theme={null}
# Install UV
curl -LsSf https://astral.sh/uv/install.sh | sh
# Navigate to build system
cd packages/browseros
# Install dependencies
uv sync
```
**3. Build debug version**
```bash theme={null}
uv run browseros build \
--chromium-src \
--setup \
--prep \
--build \
--build-type debug
```
The `--setup` and `--prep` flags are only needed for the first build. After that, just use `--build` for incremental builds:
```bash theme={null}
uv run browseros build --chromium-src --build --build-type debug
```
**4. Run BrowserOS**
```bash theme={null}
/out/Default_arm64/BrowserOS\ Dev.app/Contents/MacOS/BrowserOS\ Dev \
--enable-logging=stderr \
--use-mock-keychain \
--user-data-dir=/tmp/test-profile
```
```bash theme={null}
/out/Default_x64/BrowserOS\ Dev.app/Contents/MacOS/BrowserOS\ Dev \
--enable-logging=stderr \
--use-mock-keychain \
--user-data-dir=/tmp/test-profile
```
```bash theme={null}
\out\Default_x64\BrowserOS Dev.exe \
--enable-logging=stderr \
--user-data-dir=%TEMP%\test-profile
```
```bash theme={null}
/out/Default_x64/browseros \
--enable-logging=stderr \
--user-data-dir=/tmp/test-profile
```
### Build Flags
| Flag | Description |
| ---------------- | ---------------------------------- |
| `--chromium-src` | Path to Chromium source directory |
| `--setup` | Run setup phase (first build only) |
| `--prep` | Run prep phase (first build only) |
| `--build` | Run the compile phase |
| `--build-type` | `debug` or `release` |
| `--sign` | Sign the build |
| `--package` | Package for distribution |
### Troubleshooting
**Build fails with missing dependencies** — Make sure you followed all steps from the Chromium build guide for your platform.
**Out of disk space** — Chromium needs \~100GB. Check with `df -h`.
**Build takes too long** — Use ccache, more CPU cores, or stick to debug builds.
**UV command not found** — Restart your terminal after installing UV.
***
## Making Your First PR
1. **Fork** the repository on GitHub
2. **Clone** your fork locally
3. **Create a branch**: `git checkout -b feature/your-feature`
4. **Make changes** and test them
5. **Commit**: `git commit -m "feat: add your feature"`
6. **Push**: `git push origin feature/your-feature`
7. **Open a PR** with a clear description
### Sign the CLA
On your first PR, our bot will ask you to sign the Contributor License Agreement. Just comment:
```
I have read the CLA Document and I hereby sign the CLA
```
***
## Code Standards
**TypeScript:**
* Use strict typing, avoid `any`
* Use Zod schemas instead of TypeScript interfaces
* Use path aliases (`@/lib`) not relative paths (`../`)
* Naming: `PascalCase` for classes, `camelCase` for functions
**React:**
* Tailwind CSS only (no SCSS or CSS modules)
* Hooks at top level only
* Test with Vitest
**General:**
* Keep functions short (under 20 lines)
* Write tests for new features
* Handle errors gracefully
***
## Getting Help
* **Discord** — [discord.gg/YKwjt5vuKr](https://discord.gg/YKwjt5vuKr)
* **GitHub Issues** — [github.com/BrowserOS-ai/BrowserOS/issues](https://github.com/BrowserOS-ai/BrowserOS/issues)
* **GitHub Discussions** — [github.com/BrowserOS-ai/BrowserOS/discussions](https://github.com/BrowserOS-ai/BrowserOS/discussions)
***
By contributing, you agree that your contributions will be licensed under AGPL-3.0.
# Ad Blocking
Source: https://docs.browseros.com/features/ad-blocking
BrowserOS supports full ad blocking with uBlock Origin
BrowserOS supports full ad blocking through [uBlock Origin](https://ublockorigin.com/), the most powerful open-source ad blocker available — the full extension, not the watered-down "Lite" version.
## Why BrowserOS?
Chrome [killed support](https://developer.chrome.com/docs/extensions/develop/migrate/mv2-deprecation-timeline) for uBlock Origin by phasing out Manifest V2 extensions. The only option left on Chrome is "uBlock Origin Lite," a significantly weaker version that can't use advanced filtering rules.
**BrowserOS re-enabled full Manifest V2 support**, so you can install and run the original uBlock Origin at full power — the same extension Chrome no longer allows.
Install the full uBlock Origin extension from the Chrome Web Store. Works on BrowserOS out of the box.
## BrowserOS vs Chrome
We ran both browsers through [adblock.turtlecute.org](https://adblock.turtlecute.org/), a test that measures how effectively a browser blocks ads and tracking scripts.
Out of 133 ad-related requests:
* **BrowserOS** blocked 91 (68%)
* **Chrome** blocked 9 (7%)
That's roughly **10x more protection** with zero configuration.
## What This Means
Fewer ads means faster page loads, less bandwidth usage, and significantly reduced tracking. BrowserOS handles this natively so you can focus on browsing.
# Bring Your Own LLM
Source: https://docs.browseros.com/features/bring-your-own-llm
Connect your own AI models to BrowserOS
BrowserOS includes a default AI model you can use right away, but it has strict rate limits. For the best experience, bring your own API keys or run models locally.
See how to connect your own LLM in under a minute:
## Use Your Existing Subscription
Already paying for ChatGPT Pro or GitHub Copilot? Connect your existing account to BrowserOS with a single sign-in — no API keys, no extra cost.
**ChatGPT Pro / Plus**
Sign in with your OpenAI account. Access GPT-5 Codex, GPT-5.4, and the full Codex lineup with up to 400K context.
**GitHub Copilot**
Sign in with your GitHub account. Access 19+ models including Claude, GPT-5, and Gemini through one subscription.
***
## Which Model Should I Use?
| Mode | What works | Recommendation |
| -------------- | -------------------------- | -------------------------------------------------- |
| **Chat Mode** | Any model, including local | Ollama or Gemini Flash |
| **Agent Mode** | Cloud models only | Claude Opus 4.5, GPT-5, or Kimi K2.5 (open source) |
**Local LLMs aren't powerful for most agentic tasks yet.** They're great for Chat — asking questions about a page, summarizing, etc. But agent tasks need strong reasoning to click the right elements and handle multi-step workflows. Use Claude Opus 4.5, GPT-5, or Kimi K2.5 for agents.
***
## Kimi K2.5 — In Partnership with Moonshot AI
BrowserOS has partnered with [Moonshot AI](https://www.kimi.com) to bring **Kimi K2.5** as a first-class provider. Kimi K2.5 is now the **recommended model** in BrowserOS and is set as the default provider.
For a limited time, BrowserOS users get **extended usage limits** powered by Kimi K2.5. This means you can use the AI agent, chat, and other AI-powered features with increased limits at no cost.
Fully open-source model you can inspect and trust.
Supports images out of the box, including screenshots and visual context.
Strong reasoning for browser automation, form filling, and multi-step workflows.
Excellent agentic performance at a fraction of the cost of other frontier models.
### Why Kimi K2.5?
Kimi K2.5 offers excellent performance for agentic tasks at a fraction of the cost of other frontier models. It supports images, has a 128,000 token context window, and delivers strong results on browser automation tasks. Combined with BrowserOS's open-source agent framework, this makes for a powerful and affordable AI browsing experience.
### Bring Your Own Kimi API Key
You can also bring your own Kimi API key if you want to use Kimi K2.5 beyond the extended usage period, or if you want your own dedicated limits.
**Get your API key:**
1. Go to [platform.moonshot.ai](https://platform.moonshot.ai) and create an account
2. Navigate to the **API keys** section in your dashboard
3. Click **Create new API key** and copy the key
**Add to BrowserOS:**
1. Go to `chrome://browseros/settings`
2. Click **USE** on the **Moonshot AI** card
3. Enter your API key (it will be encrypted and stored locally on your machine)
4. The model is pre-configured to `kimi-k2.5` with a 128,000 context window
5. Click **Save**
The base URL for the Kimi API (`https://api.moonshot.ai/v1`) is pre-filled automatically when you select the Moonshot AI provider template.
***
## Cloud Providers
Connect to powerful AI models using your API keys. Your keys stay on your machine — requests go directly to the provider.
Gemini Flash is fast and free. Google gives you 20 requests per minute at no cost.
**Get your API key:**
1. Go to [aistudio.google.com](https://aistudio.google.com)
2. Click **Get API key** in the sidebar
3. Click **Create API key** and copy it
**Add to BrowserOS:**
1. Go to `chrome://browseros/settings`
2. Click **USE** on the Gemini card
3. Set **Model ID** to `gemini-2.5-flash` (or `gemini-2.5-pro`, `gemini-3-pro-preview`, `gemini-3-flash-preview`)
4. Paste your API key
5. Check **Supports Images**, set **Context Window** to `1000000`
6. Click **Save**
Claude Opus 4.5 gives the best results for Agent Mode.
**Get your API key:**
1. Go to [console.anthropic.com](https://console.anthropic.com/dashboard)
2. Click **API keys** in the sidebar
3. Click **Create Key** and copy it
**Add to BrowserOS:**
1. Go to `chrome://browseros/settings`
2. Click **USE** on the Anthropic card
3. Set **Model ID** to `claude-opus-4-5-20251101` (or `claude-sonnet-4-5-20250929`, `claude-haiku-4-5-20251001`)
4. Paste your API key
5. Check **Supports Images**, set **Context Window** to `200000`
6. Click **Save**
GPT-5 is OpenAI's most capable model for both chat and agent tasks.
**Get your API key:**
1. Go to [platform.openai.com](https://platform.openai.com)
2. Click settings icon → **API keys**
3. Click **Create new secret key** and copy it
**Add to BrowserOS:**
1. Go to `chrome://browseros/settings`
2. Click **USE** on the OpenAI card
3. Set **Model ID** to `gpt-5` (or `gpt-5.2`, `gpt-5-mini`, `gpt-4.1`, `o4-mini`)
4. Paste your API key
5. Check **Supports Images**, set **Context Window** to `200000`
6. Click **Save**
Access 500+ models through one API.
**Get your API key:**
1. Go to [openrouter.ai](https://openrouter.ai) and sign up
2. Go to [openrouter.ai/keys](https://openrouter.ai/keys) and create a key
**Pick a model:**
Go to [openrouter.ai/models](https://openrouter.ai/models) and copy the model ID you want (e.g., `anthropic/claude-opus-4.5`, `google/gemini-2.5-flash`).
**Add to BrowserOS:**
1. Go to `chrome://browseros/settings`
2. Click **USE** on the OpenRouter card
3. Paste the model ID and your API key
4. Set **Context Window** based on the model
5. Click **Save**
Use OpenAI models hosted on your own Azure subscription for enterprise compliance and data residency.
**Prerequisites:**
1. An Azure subscription with access to [Azure OpenAI Service](https://portal.azure.com/#view/Microsoft_Azure_ProjectOxford/CognitiveServicesHub/~/OpenAI)
2. A deployed model (e.g., GPT-4o) in your Azure OpenAI resource
**Get your credentials:**
1. Go to [portal.azure.com](https://portal.azure.com) → **Azure OpenAI** resource
2. Navigate to **Keys and Endpoint**
3. Copy **Key 1** and your **Endpoint URL**
**Add to BrowserOS:**
1. Go to `chrome://browseros/settings`
2. Click **USE** on the Azure card
3. Set **Base URL** to your Azure endpoint (e.g., `https://your-resource.openai.azure.com/openai/deployments/your-deployment`)
4. Set **Model ID** to your deployment name
5. Paste your API key
6. Check **Supports Images**, set **Context Window** to `128000`
7. Click **Save**
Access Claude, Llama, and other models through your AWS account with IAM-based authentication.
**Prerequisites:**
1. An AWS account with [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html) enabled
2. Model access granted in the Bedrock console for your desired models
**Get your credentials:**
1. Go to the [AWS Console](https://console.aws.amazon.com) → **IAM**
2. Create or use an existing access key with Bedrock permissions
3. Note your **Access Key ID**, **Secret Access Key**, and **Region**
**Add to BrowserOS:**
1. Go to `chrome://browseros/settings`
2. Click **USE** on the AWS Bedrock card
3. Set **Base URL** to your Bedrock endpoint (region-specific)
4. Set **Model ID** to the Bedrock model ID (e.g., `anthropic.claude-3-sonnet-20240229-v1:0`)
5. Paste your credentials
6. Check **Supports Images**, set **Context Window** to `200000`
7. Click **Save**
Connect to any provider that implements the OpenAI-compatible API format (e.g., Together AI, Fireworks, Groq, Perplexity).
**Add to BrowserOS:**
1. Go to `chrome://browseros/settings`
2. Click **USE** on the OpenAI Compatible card
3. Set **Base URL** to the provider's API endpoint
4. Set **Model ID** to the model you want to use
5. Paste your API key
6. Set **Supports Images** and **Context Window** based on the model
7. Click **Save**
Most newer AI providers support the OpenAI-compatible API format. Check your provider's docs for the base URL and available model IDs.
***
## Local Models
Run AI completely offline with Ollama or LM Studio. Includes recommended models, context length setup, and configuration steps.
***
## Switching Between Models
Use the model switcher in the Assistant panel to change providers anytime. The default provider is highlighted.
Use local models for sensitive work data. Switch to Claude for agent tasks that need complex reasoning.
# ChatGPT Pro / Plus
Source: https://docs.browseros.com/features/chatgpt-pro-oauth
Use your ChatGPT subscription to power BrowserOS
Connect your ChatGPT Pro or Plus subscription to BrowserOS and access GPT-5.5, GPT-5 Codex, GPT-5.4, and the full lineup of OpenAI's most advanced models — with up to 1.05M context. No API keys needed.
## Setup
**1.** Open BrowserOS and go to **Settings** (`chrome://browseros/settings`). You'll see the AI Providers section.
**2.** Click **USE** on the **ChatGPT Plus/Pro** card. You'll be prompted to sign in with your OpenAI account.
**3.** Sign in with the OpenAI account that has your ChatGPT Pro or Plus subscription active, and accept the authorization.
**4.** Once authorized, ChatGPT will appear as a provider in your settings. Select a model and start using it.
## Available Models
| Model | Context Window |
| --------------------- | -------------- |
| `gpt-5.5` | 1.05M |
| `gpt-5.4` | 400K |
| `gpt-5.4-mini` | 400K |
| `gpt-5.4-nano` | 400K |
| `gpt-5.3-codex` | 400K |
| `gpt-5.3-codex-spark` | 128K |
| `gpt-5.2-codex` | 400K |
| `gpt-5.2` | 200K |
| `gpt-5.1-codex` | 400K |
| `gpt-5.1-codex-max` | 400K |
| `gpt-5.1-codex-mini` | 400K |
| `gpt-5.1` | 200K |
ChatGPT Pro subscribers have access to the full model lineup. ChatGPT Plus subscribers can access a subset of models depending on their plan. The available models will be shown automatically after you connect.
The Codex models (e.g., `gpt-5.3-codex`) are optimized for code and reasoning tasks — ideal for complex browser automation workflows that involve form filling, data extraction, and multi-step navigation.
## Reasoning Settings
ChatGPT Pro includes additional settings for models that support reasoning:
* **Reasoning Effort** — Control how much the model "thinks" before responding. Options: none, low, medium, high.
* **Reasoning Summary** — Choose how reasoning is displayed. Options: auto, concise, detailed.
These settings are available in the provider configuration after connecting.
## Disconnecting
To disconnect your OpenAI account, go to **Settings**, find the ChatGPT Plus/Pro provider, and click **Disconnect**. Your OAuth tokens will be immediately deleted from your machine.
# Connect Apps
Source: https://docs.browseros.com/features/connect-mcps
Connect 40+ apps to BrowserOS so the assistant can work with your email, calendar, projects, and more
Connect your favorite apps to BrowserOS and let the assistant work across all of them. Read emails, check your calendar, create tasks, post messages, manage files, and more, all through natural conversation.
## How It Works
BrowserOS uses the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) to connect your apps. You do not need to install anything or manage API keys. Just sign in once and the assistant handles the rest.
## Smart App Connection
When you ask the assistant to do something that needs an app you have not connected yet, it shows an interactive card right in the conversation. You can connect the app with one click or choose to skip it. No need to set things up in advance.
Ask the assistant something like "What's on my calendar today?" or "Send an email to Sarah."
The assistant detects the app is not connected and shows a card explaining why connecting it would help. You get two choices: **Connect** or **Do it manually**.
* **Connect**: Opens a sign-in page. Authorize the app and the assistant continues with full integration access.
* **Do it manually**: The assistant skips the integration and navigates to the app's website directly using browser automation.
Once connected, the app stays linked for all future conversations. If you chose to skip, the assistant remembers and will not ask again.
See [Smart Nudges](/features/smart-nudges#app-connection) for more details on how connection suggestions work.
You can also connect apps ahead of time from the sidebar if you prefer.
## Connect from the Sidebar
Click **Connect Apps** in the sidebar.
Click **Add built-in app** and select the app you want
Complete the OAuth sign-in when prompted
## 40+ Supported Apps
BrowserOS connects to over 40 apps across every category you need.
| App | What you can do |
| ---------------- | ------------------------------------------------------- |
| **Gmail** | Send, read, and search emails, manage drafts and labels |
| **Outlook Mail** | Send, read, and manage emails |
| **Resend** | Send transactional and marketing emails |
| App | What you can do |
| -------------------- | ----------------------------------------------- |
| **Google Calendar** | Create events, find free time, manage calendars |
| **Outlook Calendar** | Schedule meetings, manage events |
| **Cal.com** | Schedule meetings, manage availability |
| App | What you can do |
| ------------------- | ----------------------------------- |
| **Slack** | Post messages, manage channels |
| **Discord** | Send messages, manage servers |
| **WhatsApp** | Send messages, manage conversations |
| **Microsoft Teams** | Chat, meet, and collaborate |
| App | What you can do |
| -------------- | ---------------------------------------- |
| **GitHub** | Manage repos, issues, and pull requests |
| **GitLab** | Manage repos, issues, and merge requests |
| **Vercel** | Deploy and manage web applications |
| **Postman** | Test and manage APIs |
| **Cloudflare** | Manage domains, DNS, and security |
| **Supabase** | Manage databases and backend services |
| App | What you can do |
| ----------- | ----------------------------------------- |
| **Linear** | Create issues, manage cycles and projects |
| **Jira** | Create issues, manage sprints |
| **Asana** | Organize and track team projects |
| **Monday** | Manage work and team collaboration |
| **ClickUp** | Manage tasks, projects, and workflows |
| App | What you can do |
| ----------------- | ----------------------------------- |
| **Notion** | Create pages, manage databases |
| **Google Docs** | Create and edit documents |
| **Google Sheets** | Create and edit spreadsheets |
| **Google Drive** | Upload, download, and manage files |
| **Google Forms** | Create and manage forms and surveys |
| **Confluence** | Create and manage documentation |
| **Airtable** | Manage bases, tables, and records |
| App | What you can do |
| ------------ | ----------------------------------- |
| **Dropbox** | Store and share files |
| **OneDrive** | Store and sync files with Microsoft |
| **Box** | Manage and share enterprise files |
| App | What you can do |
| --------- | ------------------------------ |
| **Figma** | Access and manage design files |
| **Canva** | Create and manage designs |
| App | What you can do |
| -------------- | ----------------------------------------- |
| **Salesforce** | Manage leads, contacts, and opportunities |
| **HubSpot** | Manage contacts, deals, and marketing |
| App | What you can do |
| ----------- | ---------------------------------- |
| **Shopify** | Manage products, orders, and store |
| **Stripe** | Manage payments and subscriptions |
| App | What you can do |
| ------------ | ------------------------------------- |
| **PostHog** | Query analytics, manage feature flags |
| **Mixpanel** | Analyze user behavior and metrics |
| App | What you can do |
| ------------ | ------------------------------------- |
| **Zendesk** | Manage support tickets and customers |
| **Intercom** | Manage customer messaging and support |
| App | What you can do |
| ---------------- | ------------------------------ |
| **Brave Search** | Search the web privately |
| **Exa** | AI-powered semantic web search |
| **Mem0** | Store and retrieve AI memory |
| App | What you can do |
| ------------- | --------------------------------- |
| **LinkedIn** | Post updates, manage connections |
| **YouTube** | Access video info and transcripts |
| **WordPress** | Manage websites and blog content |
## Example Prompts
The assistant figures out which apps to use based on what you ask. Just describe what you want in plain language.
* What's on my calendar today?
* Schedule a meeting with Sarah tomorrow at 2pm
* When is my next meeting with the marketing team?
* Block off Friday afternoon for focus time
* Show me unread emails from my manager
* Draft a reply to the last email from John thanking him for the update
* Find emails about the Q4 budget from last week
* Send an email to the team with the meeting notes
* Post a message to #general saying I'll be out tomorrow
* What's the latest message in #engineering?
* Send a DM to Sarah asking if she's free for lunch
* Summarize what was discussed in #product today
* Create a new Linear issue for the homepage redesign
* What are my open tasks in Jira?
* Move the "Launch campaign" task to complete in Asana
* Add a comment to the latest ClickUp task
* Add "Review Q4 report" to my Notion tasks database
* Create a new page in my Projects database for the website redesign
* What are my open tasks in Notion?
* Update the status of the "Launch campaign" task to complete
## Cross-App Workflows
The real power of connected apps is combining them in a single request. The assistant can pull data from one app and use it in another without you switching between tabs.
"Find action items in my latest emails and add them to my Notion tasks"
"Check my calendar for tomorrow, then draft an email to John summarizing what we're meeting about"
"Test the checkout flow on our staging site, file a Linear issue if anything is broken, and post a summary to #engineering on Slack"
"Pull my open deals from Salesforce and create a summary spreadsheet in Google Sheets"
"Check the latest pull requests on our main repo and post a daily summary to #dev-updates on Slack"
"Find all receipts in my Gmail from this month and organize them in a Google Sheet"
## Add a Custom MCP Server
You can connect any MCP-compatible server that exposes an SSE endpoint.
1. Go to **Settings > Connected Apps**
2. Click **Add custom app**
3. Enter your server URL (e.g., `http://localhost:8000/sse`) and give it a name
Custom servers appear alongside built-in apps and work the same way.
MCP has a growing ecosystem of servers. Browse [MCP servers on GitHub](https://github.com/modelcontextprotocol/servers) to find integrations for databases, APIs, and more.
### Connect to OAuth-Protected Remote Servers
Some remote MCP servers (like Atlassian Jira, GitHub, etc.) require OAuth authentication. Use [mcp-remote](https://www.npmjs.com/package/mcp-remote) and [supergateway](https://github.com/supercorp-ai/supergateway) to handle the OAuth flow locally:
```bash theme={null}
npx -y supergateway --stdio "npx -y mcp-remote https://mcp.atlassian.com/v1/sse" --port 8000
```
A browser window will open to sign in. Once authenticated, add `http://localhost:8000/sse` as a custom MCP in BrowserOS.
Keep the terminal running while you use BrowserOS. The local server handles authentication and proxies requests to the remote MCP server.
```bash theme={null}
npx -y supergateway --stdio "npx -y mcp-remote https://mcp.atlassian.com/v1/sse" --port 8000
```
Then add `http://localhost:8000/sse` as a custom MCP.
```bash theme={null}
npx -y supergateway --stdio "npx -y mcp-remote https://api.githubcopilot.com/mcp/sse" --port 8001
```
Then add `http://localhost:8001/sse` as a custom MCP.
## Privacy and Security
All apps use OAuth sign-in. BrowserOS never sees or stores your passwords.
Apps are only accessed when you ask. Nothing runs in the background.
Connect or disconnect any app at any time from Settings.
Your authentication tokens are managed securely and stored locally on your machine.
# Cowork
Source: https://docs.browseros.com/features/cowork
Give the agent controlled access to local files and commands alongside browser automation
Cowork lets you describe complex tasks and let the agent handle them end-to-end. It combines browser automation with local file operations: research on the web, then save reports directly to your folder. Read code, edit files, run shell commands, and search through your project, all in the same session as your browser tasks.
Here's what it looks like to give the agent access to your local files:
## Why Cowork?
Without Cowork, the agent can only interact with browser tabs. With Cowork enabled, it gains full access to a folder on your machine through 7 filesystem tools:
Read documents and data files, write reports, markdown, HTML, and other outputs
Make targeted edits to existing files with surgical string replacement
Execute shell commands within the sandboxed folder
Search file contents with regex or literal patterns across your project
Find files by glob pattern, with smart filtering of build directories
List directory contents with file sizes, sorted and organized
The real power: do both browser automation AND file operations in a single task. Describe what you want, step away, and come back to finished work.
## Setting Up Cowork
Click the **Cowork** dropdown next to the prompt input
Select a recent folder or click **Choose a different folder**
Allow BrowserOS to access that folder when prompted
The agent is sandboxed to your selected folder. It cannot access files outside of it.
Cowork is available in **Agent Mode** only. In Chat Mode, the agent works with browser tabs only.
To disable file access, select **No folder** and the agent will work with browser tabs only.
## Filesystem Tools
Cowork provides 7 filesystem tools that the agent can use alongside browser automation:
Read a file from the filesystem. Returns text content with line numbers, or image data for image files (PNG, JPG, GIF, WEBP, BMP, SVG, ICO). Supports pagination through large files with `offset` and `limit` parameters.
| Parameter | Type | Description |
| --------- | ----------------- | --------------------------------------- |
| `path` | string (required) | File path relative to working directory |
| `offset` | number (optional) | Starting line number (1-indexed) |
| `limit` | number (optional) | Max lines to read |
Responses are capped at 2000 lines or 50KB per request.
Create or overwrite a file. Automatically creates parent directories if they don't exist.
| Parameter | Type | Description |
| --------- | ----------------- | --------------------------------------- |
| `path` | string (required) | File path relative to working directory |
| `content` | string (required) | Complete file content to write |
Make a targeted edit by replacing an exact string match. If the exact match fails, a whitespace-tolerant fuzzy match is attempted. Preserves original line endings (CRLF, CR, LF) and BOM.
| Parameter | Type | Description |
| ------------ | ----------------- | --------------------------------------- |
| `path` | string (required) | File path relative to working directory |
| `old_string` | string (required) | Exact text to find |
| `new_string` | string (required) | Replacement text |
Returns a side-by-side diff of the change.
Execute a shell command and return its output. Commands run in `sh`/`bash` on Unix or `cmd` on Windows.
| Parameter | Type | Description |
| --------- | ----------------- | --------------------------------- |
| `command` | string (required) | Shell command to execute |
| `timeout` | number (optional) | Timeout in seconds (default: 120) |
Output is truncated to the last 2000 lines if too large. Returns the exit code on failure.
Find files matching a glob pattern. Searches recursively while skipping common build directories (`node_modules`, `.git`, `dist`, `build`, `.next`, `coverage`, `__pycache__`, and more).
| Parameter | Type | Description |
| --------- | ----------------- | ------------------------------------------------ |
| `pattern` | string (required) | Glob pattern (e.g., `*.ts`, `**/*.json`) |
| `path` | string (optional) | Directory to search (default: working directory) |
| `limit` | number (optional) | Max results (default: 1000) |
Returns relative file paths sorted alphabetically.
Search file contents using regex or literal string matching. Skips binary files and files over 2MB.
| Parameter | Type | Description |
| ------------- | ------------------ | ----------------------------------- |
| `pattern` | string (required) | Search pattern (regex by default) |
| `path` | string (optional) | Directory or file to search |
| `glob` | string (optional) | Filter files by glob (e.g., `*.ts`) |
| `ignore_case` | boolean (optional) | Case-insensitive search |
| `literal` | boolean (optional) | Treat pattern as literal string |
| `context` | number (optional) | Lines of context around matches |
| `limit` | number (optional) | Max matches (default: 100) |
List directory contents. Shows directories first (with trailing `/`), then files with human-readable sizes.
| Parameter | Type | Description |
| --------- | ----------------- | ------------------------------------------- |
| `path` | string (optional) | Directory path (default: working directory) |
| `limit` | number (optional) | Max entries (default: 500) |
Entries are sorted alphabetically, case-insensitive.
## Try It: Research and Create a Report
With Cowork enabled, try this prompt:
```
Read the top 3 stories on Hacker News, read the comments too, and write an HTML report.
```
The agent will:
Opens the site and identifies top stories
Clicks into each story and reads discussion threads
Creates an HTML report summarizing the findings
Writes the report to your selected folder
## Example Use Cases
> Go through my Downloads folder and organize files by type: documents, images, videos, archives.
> Research key trends about \[topic] on Reddit, Twitter, and LinkedIn. Create an HTML report with your findings.
> Visit these 10 product pages, extract the name, price, and description, and save the results as a markdown file.
> Find the top posts from these 5 subreddits today and compile them into a daily digest document.
> Search my project for all TODO comments, list them with file paths and line numbers, then create a summary markdown file.
> Grep through the log files in this folder for errors from the last 24 hours and write a summary of what went wrong.
## Security
The agent can only access the folder you select. No parent directories, no path traversal.
Select **No folder** to instantly disable file access
All file operations happen locally on your machine
# GitHub Copilot
Source: https://docs.browseros.com/features/github-copilot-oauth
Use your GitHub Copilot subscription to power BrowserOS
Connect your GitHub Copilot subscription to BrowserOS and access 19+ models — including Claude, GPT-5, and Gemini — through a single GitHub sign-in. No API keys needed.
**Free tier** includes GPT-5 Mini, Claude Haiku 4.5, GPT-4o, and GPT-4.1. **Copilot Pro** (\$10/month) unlocks Claude Sonnet 4.6, Claude Opus 4.6, Gemini 3 Pro, GPT-5.4, and more.
## Setup
**1.** Open BrowserOS and go to **Settings** (`chrome://browseros/settings`). You'll see the AI Providers section.
**2.** Click **USE** on the **GitHub Copilot** card. A device code will appear — copy it, then click the link to open GitHub's device authorization page.
**3.** Select your GitHub account to authorize.
**4.** Paste the device code and authorize BrowserOS to access your Copilot subscription.
**5.** Once authorized, GitHub Copilot will appear as a provider in your settings. Select a model and start using it.
## Available Models
### Free Tier
| Model | Context Window |
| ------------------ | -------------- |
| `gpt-5-mini` | 128K |
| `claude-haiku-4.5` | 128K |
| `gpt-4o` | 64K |
| `gpt-4.1` | 64K |
### Copilot Pro / Pro+
| Model | Context Window |
| ---------------------- | -------------- |
| `claude-sonnet-4.6` | 200K |
| `claude-opus-4.6` | 200K |
| `gemini-2.5-pro` | 1M |
| `gemini-3-pro-preview` | 1M |
| `gpt-5.4` | 400K |
| `gpt-5.3-codex` | 400K |
| `gpt-5.2-codex` | 400K |
| `grok-code-fast-1` | 128K |
GitHub Copilot is the most versatile provider — one subscription gives you access to models from OpenAI, Anthropic, Google, and xAI. Great if you want to switch between models for different tasks.
## Disconnecting
To disconnect your GitHub account, go to **Settings**, find the GitHub Copilot provider, and click **Disconnect**. Your OAuth tokens will be immediately deleted from your machine.
# Bring Your Local Model
Source: https://docs.browseros.com/features/local-models
Run AI models locally with Ollama or LM Studio for free, private, offline use
BrowserOS works great with local models for Chat Mode. Run models completely offline — your data never leaves your machine.
## Context Length
**Ollama defaults to 4,096 tokens of context — this is too low for BrowserOS.** Below 15K tokens, the context overflows and the agent gets stuck in a loop constantly trying to recover. Only Chat Mode will work at low context lengths. Set at least **15,000–20,000 tokens** for local models to function properly.
Set context length when starting Ollama:
```bash theme={null}
OLLAMA_CONTEXT_LENGTH=20000 ollama serve
```
Increasing context length uses more VRAM. Run `ollama ps` to check your current allocation. See the [Ollama context length docs](https://docs.ollama.com/context-length) for more details.
***
## Setup
The easiest way to run models locally.
Download from [ollama.com](https://ollama.com) and install it.
```bash theme={null}
ollama pull qwen/qwen3-4b
```
```bash theme={null}
OLLAMA_CONTEXT_LENGTH=20000 ollama serve
```
1. Go to `chrome://browseros/settings`
2. Click **USE** on the Ollama card
3. Set **Model ID** to `qwen/qwen3-4b`
4. Set **Context Window** to `20000`
5. Click **Save**
Nice GUI if you don't want to use the terminal.
Download from [lmstudio.ai](https://lmstudio.ai) and install it.
Open LM Studio → **Developer** tab → load a model. It runs a server at `http://localhost:1234/v1/`.
1. Go to `chrome://browseros/settings`
2. Click **USE** on the **OpenAI Compatible** card
3. Set **Base URL** to `http://localhost:1234/v1/`
4. Set **Model ID** to the model you loaded
5. Set **Context Window** to at least `20000`
6. Click **Save**
***
## Recommended Models
Pick a model based on your available RAM/VRAM. Smaller models are faster but less capable.
### Lightweight (under 5 GB)
Good for machines with 8 GB RAM. Fast responses, suitable for simple chat tasks.
| Model | Publisher | Params | Quant | Size |
| ------------------------------ | ------------------ | ------ | -------- | ------- |
| `qwen/qwen3-4b` | Qwen | 4B | 4bit | 2.28 GB |
| `mistralai/ministral-3-3b` | Mistral | 3B | Q4\_K\_M | 2.99 GB |
| `deepseek-r1-distill-qwen-7b` | lmstudio-community | 7B | Q4\_K\_M | 4.68 GB |
| `deepseek-r1-distill-llama-8b` | lmstudio-community | 8B | Q4\_K\_M | 4.92 GB |
### Mid-range (10–15 GB)
Needs 16+ GB RAM. Better reasoning, handles longer conversations well.
| Model | Publisher | Params | Quant | Size |
| --------------------------------- | --------- | ------ | ----- | -------- |
| `openai/gpt-oss-20b` | OpenAI | 20B | MXFP4 | 12.11 GB |
| `mistralai/magistral-small` | Mistral | 23.6B | 4bit | 13.28 GB |
| `mistralai/devstral-small-2-2512` | Mistral | 24B | 4bit | 14.12 GB |
### Heavy (60+ GB)
For workstations with 64+ GB RAM. Closest to cloud model quality.
| Model | Publisher | Params | Quant | Size |
| --------------------- | --------- | ------ | ----- | -------- |
| `openai/gpt-oss-120b` | OpenAI | 120B | MXFP4 | 63.39 GB |
Start with `qwen/qwen3-4b` if you're unsure — it's small, fast, and surprisingly capable for its size.
# Scheduled Tasks
Source: https://docs.browseros.com/features/scheduled-tasks
Run the BrowserOS agent automatically on a schedule
Scheduled Tasks let you run the BrowserOS agent automatically, whether it is daily, every few hours, or every few minutes. Write a prompt once, set a schedule, and let the agent handle it on autopilot.
Watch how to set up a scheduled task from scratch:
## Creating a Scheduled Task
There are two ways to create a scheduled task: from a conversation or from the settings page.
### From a conversation
After the agent completes a task that could run on a schedule, it will suggest scheduling it with an interactive card. You can also ask directly:
* "Schedule this to run every morning"
* "Can this run daily at 8am?"
* "Automate this task"
The agent fills in the task details for you. Just review and confirm. See [Smart Nudges](/features/smart-nudges#schedule-suggestion) for more details.
### From settings
Click **Scheduled Tasks** in the sidebar.
Click the **New Task** button to open the creation dialog.
* **Name**: A friendly name for your task
* **Prompt**: What you want the agent to do (any natural language instruction)
* **Schedule type**: Daily at a specific time, every N hours, or every N minutes
* **Enable**: Toggle on to start running immediately
Click **Create**. The task will run at the next scheduled time automatically.
## Schedule Types
Runs once a day at a specific time you choose (e.g., every morning at 8:00 AM).
Runs every N hours (e.g., every 2 hours, every 6 hours). Set an interval from 1 to 24 hours.
Runs every N minutes (e.g., every 15 minutes, every 30 minutes). Set an interval from 1 to 60 minutes.
## Example Use Cases
> Every morning at 8am, check my Google Calendar and send me a summary of today's events. For each meeting, do a quick Google search on the attendees and include their LinkedIn summary.
> Every day, go to LinkedIn and accept up to 25 pending connection requests.
> Check the price of this Amazon item every hour. If it drops below \$50, place the order.
> Every morning at 9am, visit these 5 competitor websites and check for new product announcements or pricing changes. Summarize what is new.
> Every evening at 6pm, check the top posts on Hacker News and r/programming. Create a brief summary of the most interesting discussions.
> Check my Google Calendar for tomorrow's meetings, then post a summary to my Slack channel, and create a Notion page with prep notes for each meeting.
Your scheduled task prompts can be as complex as you want. If you have [connected apps](/features/connect-mcps) like Google Calendar, Slack, Notion, or Gmail, your scheduled tasks can work across all of them.
## Viewing Results
When a scheduled task runs, you can see the results in two places:
* **New Tab page**: Results show up right on your new tab
* **Scheduled Tasks page**: View the full run history for each task
Each task keeps a history of its last 15 runs. Click on any run to see the full output, including what tools the agent used and what it found.
You can also:
* **Test** a task manually without waiting for the next scheduled run
* **Retry** a failed task
* **Cancel** a task that is currently running
## How It Works
BrowserOS uses your browser's built-in alarm system to trigger tasks at the right time. If your laptop was closed at the scheduled time, the task runs as soon as you open BrowserOS again.
A hidden browser window opens automatically. The task runs there so it never interrupts whatever you are working on. You will not see anything happen on screen.
The agent runs your prompt with full access to browser automation and any connected apps. It can navigate pages, fill forms, extract data, and interact with your services.
When the task finishes, the result is saved and appears on your New Tab page and in the task's run history. The hidden window closes automatically.
BrowserOS needs to be open for scheduled tasks to run. Tasks have a 10-minute timeout. If a task takes longer than that, it will be marked as failed and you can retry it.
## Cloud Sync
If you are signed in, your scheduled task configurations sync across devices. Create a task on your laptop and it appears on your desktop. Edits sync both ways, and conflicts are resolved automatically using timestamps.
Only the schedule setup syncs (name, prompt, schedule type, and timing). Task run results and output stay on the device where the task ran.
See [Sync to Cloud](/features/sync-to-cloud) for more details.
## Privacy
All tasks run on your machine in a hidden browser window. Nothing is sent to external servers.
Enable, disable, edit, or delete any task at any time. You decide what runs and when.
# Smart Nudges
Source: https://docs.browseros.com/features/smart-nudges
BrowserOS suggests app connections and task scheduling at the right moment
Smart Nudges are context-aware suggestions that appear as interactive cards during a conversation. The agent detects opportunities to connect an app or schedule a task, and shows you a card at the right moment. You decide whether to act on it or skip it.
There are two types of nudges: **App Connection** and **Schedule Suggestion**.
## App Connection
When you ask the agent to do something that involves an external app (like sending an email or checking your calendar), it checks whether that app is connected. If it is not, the agent shows a connection card before starting the task.
For example: "Send Sarah an email with the meeting notes."
Gmail is not connected yet, so the agent cannot send emails through the integration.
The card explains why connecting the app would help and gives you two choices: **Connect** or **Do it manually**.
* **Connect**: Opens a sign-in page for the app. Once you authorize, the agent continues with full integration access.
* **Do it manually**: The agent skips the integration and uses browser automation instead (navigates to the website directly).
### What happens after you choose
The app is added to your connected list. The agent uses the integration for this and all future conversations. You can manage connected apps in [Connect Apps](/features/connect-mcps).
The agent remembers your choice and will not ask about this app again. It uses browser automation to complete the task instead.
If you declined an app but change your mind later, you can connect it anytime from the [Connect Apps](/features/connect-mcps) settings page.
### Supported apps
The agent can suggest connections for all 40+ built-in integrations, including Gmail, Google Calendar, Slack, Notion, GitHub, Linear, Jira, Figma, Salesforce, and many more. See [Connect Apps](/features/connect-mcps) for the full list.
## Schedule Suggestion
After the agent completes a task that could run on a recurring schedule, it shows a scheduling card. This helps you turn one-time tasks into automated routines without leaving the conversation.
For example: "Here are the top 5 tech headlines from today."
News gathering, price monitoring, report building, data tracking, and similar tasks that do not need your real-time input are good candidates.
The card suggests a name and schedule. For example: "Run this automatically? 'Morning News Briefing' - daily at 09:00."
* **Schedule this task**: Opens the Scheduled Tasks page with the details pre-filled. Review and confirm to create the task.
* **Maybe later**: Dismisses the card. You can always create the scheduled task manually later.
### You can also ask directly
You do not have to wait for the agent to suggest it. Just tell the agent you want to schedule the task:
* "Schedule this to run every morning"
* "Can this run daily at 8am?"
* "Automate this task"
* "Run this every hour"
The agent will infer the task name, schedule type, and timing from your conversation and show the scheduling card immediately.
### What gets scheduled
The scheduling card pre-fills the [Scheduled Tasks](/features/scheduled-tasks) dialog with:
* **Task name**: A short description based on the conversation
* **Prompt**: The original query you asked the agent
* **Schedule type**: Daily or hourly, based on what makes sense for the task
* **Time**: A suggested time (for daily tasks)
You can adjust any of these before confirming.
## When Nudges Appear
Nudges are designed to appear at the right moment without interrupting your workflow:
| Nudge | When it appears | How often |
| ------------------- | ------------------------------------------------------------------- | ----------------------------- |
| App Connection | Before the agent starts working, when it detects an unconnected app | Once per app per conversation |
| Schedule Suggestion | After the agent finishes a task that could be automated | Once per conversation |
Nudges do not appear in:
* **Scheduled tasks** running in the background
* **Chat mode** (read-only, no browser automation)
## Privacy
The agent only suggests a connection. No data is shared with the app until you explicitly authorize it.
Declined apps are stored on your device. The agent will not ask about them again unless you reconnect from settings.
# Sync to Cloud
Source: https://docs.browseros.com/features/sync-to-cloud
Sign in to sync your conversations, settings, and automations across all your devices
Sign in to BrowserOS and your data follows you everywhere. Your conversations, AI model settings, and scheduled tasks sync automatically to the cloud so you never lose your setup.
## Why Sign In?
Without an account, everything stays on one device. Sign in and your data is backed up and available wherever you use BrowserOS.
Open BrowserOS on a new device and your conversations, model settings, and scheduled tasks are already there.
Chat history is saved to the cloud automatically. Clear your browser data or switch machines and everything is still available.
Set up your AI models once. Your provider configurations sync across devices so you never re-enter the same setup twice.
Create a scheduled task on your laptop and it appears on your desktop. Edits sync both ways.
## How to Sign In
Open a new tab in BrowserOS to see the home page.
Click **Sign In** in the sidebar to open the login page.
Enter your email for a magic link, or sign in with Google.
Click the link in your email (or complete Google sign-in). BrowserOS starts syncing your data immediately.
Magic link sign-in means you never need to create or remember a password. Just enter your email and click the link.
## What Gets Synced
Your full chat history syncs to the cloud as you go. Every message is saved in real time so you can pick up any conversation on another device. Locally, BrowserOS keeps your 50 most recent conversations. In the cloud, there is no limit.
Your configured LLM providers (OpenAI, Anthropic, Google, Moonshot, Azure, Bedrock, and others) sync across devices. This includes the model name, provider type, base URL, temperature, and context window settings.
**Your API keys are never synced.** Sensitive credentials like API keys, access keys, and session tokens stay on the device where you entered them. You will need to re-enter API keys on each new device.
Your scheduled task configurations sync in both directions. Create a task on one device, edit it on another, and changes are merged automatically using timestamps to resolve conflicts. Only the schedule setup syncs (name, prompt, schedule type, and timing). Task run results and output stay on the device where the task ran.
Your name, profile picture, and account preferences sync across devices. Information you provide during onboarding (role, company) is also saved to your profile.
## What Stays Local
Some settings are device-specific and do not sync to the cloud:
* **API keys and secrets** for LLM providers
* **Theme** (light/dark mode)
* **Workspace folder** selection
* **Connected MCP servers**
* **Scheduled task results** (run output stays on the device where the task ran)
This is intentional. Sensitive credentials never leave your device, and display preferences can differ between machines.
## How Sync Works
BrowserOS uses a local-first approach. Your data is always saved on your device first, then synced to the cloud in the background.
Every action (sending a message, adding a provider, creating a task) is saved locally first. BrowserOS works fully offline.
When you are signed in, changes are automatically pushed to the cloud. New chat messages sync in real time. Provider and task changes sync whenever they are updated.
When you sign in on a new device, BrowserOS pulls your conversations, model settings, scheduled tasks, and profile from the cloud and merges them with any local data.
If the same scheduled task is edited on two devices before they sync, BrowserOS keeps the version with the most recent timestamp.
## Security
Sensitive credentials like API keys, access keys, and tokens are excluded from cloud sync entirely.
Sign-in uses magic links or Google OAuth. No passwords are stored.
All synced data is tied to your user account and is not accessible to anyone else.
If cloud sync fails (e.g., no internet), your local data is unaffected. Sync resumes automatically when connectivity is restored.
# MCP Clients (Claude Code, OpenClaw)
Source: https://docs.browseros.com/features/use-with-claude-code
Control your browser and 40+ apps from Claude Code, OpenClaw, Gemini CLI, or any MCP client
BrowserOS is the best browser for AI coding agents. It comes with a built-in MCP server that gives your AI agent **full browser control** and **direct access to 40+ external services** — Gmail, Slack, GitHub, Google Calendar, Linear, Notion, and more — all through a single MCP connection.
Unlike Chrome DevTools MCP which requires setting up debug profiles and running separate servers, BrowserOS MCP works out of the box. Just copy the URL from settings and connect.
## Why Use BrowserOS with Claude Code?
Claude tests your web app, reads console errors, and fixes the code — all in one loop.
Gmail, Slack, GitHub, Jira, Notion, Google Sheets, and more — accessible directly from your AI agent.
Extract your LinkedIn profile, tweets, or any authenticated page content.
Fill forms, navigate multi-step workflows, and automate repetitive browser tasks.
Full browser control: tabs, navigation, clicks, typing, screenshots, bookmarks, history, tab groups, and window management.
Connect external services via OAuth — credentials are managed securely, never stored in BrowserOS.
Wondering how BrowserOS MCP compares to Chrome DevTools MCP or other browser automation tools? See our [detailed feature comparison](/comparisons/chrome-devtools-mcp) covering 53 browser tools, 40+ app integrations, and why BrowserOS MCP gives developers more out of the box.
## Getting Started
Navigate to `chrome://browseros/mcp` or click **Settings** → **BrowserOS as MCP** in the sidebar.
Copy the Server URL shown on the page (e.g., `http://127.0.0.1:9239/mcp`).
Use the tabs below to connect your preferred client.
Add BrowserOS to Claude Code:
```bash theme={null}
claude mcp add --transport http browseros --scope user
# Example: claude mcp add --transport http browseros http://127.0.0.1:9239/mcp --scope user
```
Start Claude Code and try it:
```bash theme={null}
claude
> Open amazon.com in BrowserOS
```
Run `claude --dangerously-skip-permissions` to skip confirmation prompts for each browser action.
To remove later:
```bash theme={null}
claude mcp remove browseros --scope user
```
Add BrowserOS to Gemini CLI:
```bash theme={null}
gemini mcp add local-server --transport http --scope user
# Example: gemini mcp add local-server http://127.0.0.1:9239/mcp --transport http --scope user
```
Add BrowserOS to OpenAI Codex CLI:
```bash theme={null}
codex mcp add browseros --transport http
# Example: codex mcp add browseros http://127.0.0.1:9239/mcp --transport http
```
Add BrowserOS to [OpenClaw](https://openclaw.ai/) by adding it to the `mcpServers` section in your `openclaw.json` config file:
```json theme={null}
{
"mcpServers": {
"browseros": {
"url": "http://127.0.0.1:9239/mcp"
}
}
}
```
Replace the URL with your BrowserOS MCP URL from settings.
Open your Claude Desktop config file:
```
~/Library/Application Support/Claude/claude_desktop_config.json
```
Add BrowserOS:
```json theme={null}
{
"mcpServers": {
"browseros": {
"command": "npx",
"args": ["mcp-remote", "http://127.0.0.1:9239/mcp"]
}
}
}
```
Do not add BrowserOS to `claude_desktop_config.json` as a raw `{ "url": "..." }` entry. Claude Desktop local config expects a command wrapper here, so use `npx mcp-remote `.
Restart Claude Desktop to connect.
## Connect from a Remote Machine
The BrowserOS MCP server only listens on `127.0.0.1`, so by default only programs on the same computer can reach it. If your agent runs somewhere else — for example a [Hermes](https://github.com/NousResearch) or OpenClaw agent on a VPS controlling BrowserOS on your laptop — you need a reverse tunnel that forwards requests from the remote machine to the MCP server on your laptop.
Anyone who can reach this URL has full control of your browser, including every account you are signed into. Prefer a private tunnel like Tailscale over a public URL, and treat public tunnel URLs like passwords.
All commands below use port `9239` — replace it with the port shown on your `chrome://browseros/mcp` settings page.
Tailscale puts your laptop and VPS on a private network, so the MCP server is never exposed to the public internet and the URL never changes.
1. Install [Tailscale](https://tailscale.com/download) on both your laptop and the VPS, and sign in to the same tailnet on both.
2. On the laptop, share the MCP port with your tailnet:
```bash theme={null}
tailscale serve --bg 9239
```
3. Tailscale prints an HTTPS URL like `https://your-laptop.tailnet-name.ts.net`. On the VPS, point your agent at that URL with the `/mcp` path:
```bash theme={null}
claude mcp add --transport http browseros https://your-laptop.tailnet-name.ts.net/mcp --scope user
```
Run `tailscale serve reset` on the laptop to stop sharing.
On the laptop, start a quick tunnel:
```bash theme={null}
cloudflared tunnel --url http://127.0.0.1:9239
```
Cloudflare prints a URL like `https://random-words.trycloudflare.com`. On the VPS, connect your agent to `https://random-words.trycloudflare.com/mcp`.
Quick tunnels are public and unauthenticated — anyone who discovers the URL can control your browser. The URL also changes every time `cloudflared` restarts, so you must update your agent config after each restart. For anything long-running, use a [named tunnel](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) with Cloudflare Access in front, or use Tailscale instead.
On the laptop, start a tunnel:
```bash theme={null}
ngrok http 9239
```
ngrok prints a URL like `https://abc123.ngrok-free.app`. On the VPS, connect your agent to `https://abc123.ngrok-free.app/mcp`.
The URL is public — anyone who discovers it can control your browser — and it changes every time ngrok restarts unless you use a reserved domain. Use Tailscale instead for anything long-running.
The connection only works while your laptop is awake, BrowserOS is running, and the tunnel process is alive. If a remote agent that was working suddenly stops connecting, check those three first — and if you use ngrok or a Cloudflare quick tunnel, remember the URL rotates on every restart, so your agent may be pointing at a dead URL. Tailscale avoids this because its hostnames are stable.
## Example Prompts
Extract structured data from any page you're logged into — no scraping setup needed.
```
Open my LinkedIn profile in BrowserOS and extract my work experience as JSON
```
Test your web app end-to-end without leaving the terminal — Claude navigates, interacts, and reports errors back.
```
In BrowserOS, go to localhost:3000, click the login button, and check for console errors
```
Capture visual snapshots of any page for debugging, documentation, or design review.
```
Take a screenshot of the current page in BrowserOS and save it to screenshots/
```
Search through your real browsing history to find pages you visited earlier.
```
Search my BrowserOS history for "invoice" and list the recent matches
```
Access your email directly from the agent — read, search, and summarize without switching windows.
```
Read my latest Gmail messages and summarize them
```
Chain multiple services together in a single prompt — file issues, notify your team, and stay in flow.
```
Create a Linear issue for the bug I just found and post a summary to Slack
```
***
## Browser Automation Tools
BrowserOS exposes **53 browser automation tools** to MCP clients, organized into the following categories:
| Tool | Description |
| ----------------- | ----------------------------------------------------- |
| `get_active_page` | Get the currently focused page/tab |
| `list_pages` | List all open pages with title, URL, and tab ID |
| `navigate_page` | Navigate to a URL, or go back/forward/reload |
| `new_page` | Open a new tab (with optional background/hidden mode) |
| `new_hidden_page` | Open a hidden tab for background automation |
| `show_page` | Restore a hidden page to visible state |
| `move_page` | Move a tab to a different window or position |
| `close_page` | Close a tab |
| Tool | Description |
| ------------------------ | --------------------------------------------------------- |
| `take_snapshot` | Get accessibility tree with interactive element IDs |
| `take_enhanced_snapshot` | Detailed accessibility tree with structural context |
| `get_page_content` | Extract page as clean Markdown (headers, links, tables) |
| `get_page_links` | Extract all links from a page with deduplication |
| `get_dom` | Get raw HTML DOM with optional CSS selector scoping |
| `search_dom` | Search DOM by text, CSS selector, or XPath |
| `take_screenshot` | Capture page screenshot (PNG/JPEG/WebP, full-page option) |
| `evaluate_script` | Execute JavaScript in the page context |
| Tool | Description |
| --------------- | ---------------------------------------------------- |
| `click` | Click an element by ID from snapshot |
| `click_at` | Click at specific X,Y coordinates |
| `hover` | Hover over an element |
| `focus` | Focus an element (scrolls into view) |
| `fill` | Type text into an input (with optional clear) |
| `clear` | Clear text from input/textarea |
| `check` | Check a checkbox or radio button |
| `uncheck` | Uncheck a checkbox |
| `select_option` | Select a dropdown option by value or text |
| `press_key` | Press a key or key combination (Enter, Ctrl+A, etc.) |
| `drag` | Drag an element to another element or coordinates |
| `scroll` | Scroll page or element (up/down/left/right) |
| `upload_file` | Upload files to a file input element |
| `handle_dialog` | Accept or dismiss JavaScript dialogs |
| Tool | Description |
| ----------------- | -------------------------------------------------- |
| `save_pdf` | Print current page to a PDF file |
| `save_screenshot` | Capture and save a screenshot to disk |
| `download_file` | Click an element to trigger a download and save it |
| Tool | Description |
| ---------------------- | ------------------------------------------- |
| `list_windows` | List all browser windows |
| `create_window` | Create a new browser window |
| `create_hidden_window` | Create a hidden window for background tasks |
| `close_window` | Close a window by ID |
| `activate_window` | Focus and activate a window |
| Tool | Description |
| ------------------ | ------------------------------------------------ |
| `list_tab_groups` | List all tab groups |
| `group_tabs` | Create a tab group with optional title and color |
| `update_tab_group` | Update group title, color, or collapsed state |
| `ungroup_tabs` | Remove tabs from groups |
| `close_tab_group` | Close a group and all its tabs |
| Tool | Description |
| ------------------ | ------------------------------------- |
| `get_bookmarks` | List all bookmarks |
| `create_bookmark` | Create a bookmark or folder |
| `remove_bookmark` | Delete a bookmark or folder |
| `update_bookmark` | Update bookmark title or URL |
| `move_bookmark` | Move a bookmark to a different folder |
| `search_bookmarks` | Search bookmarks by title or URL |
| Tool | Description |
| ---------------------- | ------------------------------------ |
| `search_history` | Search browser history by text query |
| `get_recent_history` | Get the most recent history items |
| `delete_history_url` | Delete a specific URL from history |
| `delete_history_range` | Delete history within a time range |
***
## 40+ External App Integrations
BrowserOS connects your AI agent directly to the tools you already use — no separate MCP servers to install or configure. Everything is accessible through the same BrowserOS MCP connection.
### How It Works
Your AI agent calls a tool like `gmail_search_messages` through the BrowserOS MCP.
If this is your first time using that service, BrowserOS opens an OAuth login page in the browser. Log in and authorize access.
Once authenticated, the tool runs and returns results to your agent. Future calls to the same service work automatically — no re-authentication needed.
Your credentials are managed securely via OAuth and are **never stored in BrowserOS**. Tokens are refreshed transparently, and you can revoke access at any time from the service provider.
### Supported Services
| Service | What you can do |
| ---------------- | --------------------------------------------------- |
| **Gmail** | Send, read, search emails, manage drafts and labels |
| **Outlook Mail** | Send, read, and manage emails |
| **Resend** | Send transactional and marketing emails |
| Service | What you can do |
| -------------------- | ----------------------------------------------- |
| **Google Calendar** | Create events, find free time, manage calendars |
| **Outlook Calendar** | Schedule meetings, manage events |
| **Cal.com** | Schedule meetings, manage availability |
| Service | What you can do |
| ------------------- | ----------------------------------- |
| **Slack** | Post messages, manage channels |
| **Discord** | Send messages, manage servers |
| **WhatsApp** | Send messages, manage conversations |
| **Microsoft Teams** | Chat, meet, and collaborate |
| Service | What you can do |
| -------------- | ---------------------------------------- |
| **GitHub** | Manage repos, issues, and pull requests |
| **GitLab** | Manage repos, issues, and merge requests |
| **Vercel** | Deploy and manage web applications |
| **Postman** | Test and manage APIs |
| **Cloudflare** | Manage domains, DNS, and security |
| **Supabase** | Manage databases and backend services |
| Service | What you can do |
| ----------- | ----------------------------------------- |
| **Linear** | Create issues, manage cycles and projects |
| **Jira** | Create issues, manage sprints |
| **Asana** | Organize and track team projects |
| **Monday** | Manage work and team collaboration |
| **ClickUp** | Manage tasks, projects, and workflows |
| Service | What you can do |
| ----------------- | ----------------------------------- |
| **Notion** | Create pages, manage databases |
| **Google Docs** | Create and edit documents |
| **Google Sheets** | Create and edit spreadsheets |
| **Google Drive** | Upload, download, and manage files |
| **Google Forms** | Create and manage forms and surveys |
| **Confluence** | Create and manage documentation |
| **Airtable** | Manage bases, tables, and records |
| Service | What you can do |
| ------------ | ----------------------------------- |
| **Dropbox** | Store and share files |
| **OneDrive** | Store and sync files with Microsoft |
| **Box** | Manage and share enterprise files |
| Service | What you can do |
| --------- | ------------------------------ |
| **Figma** | Access and manage design files |
| **Canva** | Create and manage designs |
| Service | What you can do |
| -------------- | ----------------------------------------- |
| **Salesforce** | Manage leads, contacts, and opportunities |
| **HubSpot** | Manage contacts, deals, and marketing |
| Service | What you can do |
| ----------- | ---------------------------------- |
| **Shopify** | Manage products, orders, and store |
| **Stripe** | Manage payments and subscriptions |
| Service | What you can do |
| ------------ | ------------------------------------- |
| **PostHog** | Query analytics, manage feature flags |
| **Mixpanel** | Analyze user behavior and metrics |
| Service | What you can do |
| ------------ | ------------------------------------- |
| **Zendesk** | Manage support tickets and customers |
| **Intercom** | Manage customer messaging and support |
| Service | What you can do |
| ---------------- | ------------------------------ |
| **Brave Search** | Search the web privately |
| **Exa** | AI-powered semantic web search |
| **Mem0** | Store and retrieve AI memory |
| Service | What you can do |
| ------------- | --------------------------------- |
| **LinkedIn** | Post updates, manage connections |
| **YouTube** | Access video info and transcripts |
| **WordPress** | Manage websites and blog content |
***
## Demo Videos
### Agentic coding workflow
[](https://youtu.be/vcSxzIIkg_0)
### Browser automation with Claude Code
[](https://youtu.be/rPFx_Btajj0)
# Vertical Tabs
Source: https://docs.browseros.com/features/vertical-tabs
Move your tabs to the side for a cleaner, more organized browsing experience
BrowserOS supports vertical tabs — a side panel that lists all your open tabs along the left edge of the browser window. Instead of shrinking tab titles into a cramped horizontal strip, vertical tabs give each tab its own full-width row so you can read titles at a glance, even with dozens of tabs open.
## Why Vertical Tabs?
Modern screens are wide, not tall. A horizontal tab bar wastes vertical space you could use for content, and tabs quickly become unreadable as they shrink. Vertical tabs solve both problems:
Tabs stack vertically with full-width labels, so you always know what is open — no squinting at favicons.
Open 30, 50, or 100 tabs without the strip becoming unusable. The side panel scrolls naturally.
The horizontal tab bar disappears, giving web pages more room on widescreen monitors.
Combine vertical tabs with tab groups to visually separate work, research, and personal browsing.
## Enabling Vertical Tabs
Toggle vertical tabs on or off from the Customization settings page.
Go to `chrome://browseros/settings` in the address bar.
In the left sidebar, select **Customization**.
Flip the **Use Vertical Tabs** switch to on. The browser immediately moves your tabs to a side panel.
To switch back, return to the same setting and turn the toggle off. Your tabs move back to the horizontal strip instantly.
## How It Works
When vertical tabs are enabled, the tab strip relocates from the top of the window to a collapsible side panel on the left. Each tab is displayed as a row showing the page favicon and full title.
* **Click** a tab row to switch to it.
* **Right-click** a tab for the standard context menu (pin, mute, close, move to group).
* **Drag** tabs up or down to reorder them, or drag them into and out of tab groups.
* The panel can be **collapsed** to show only favicons, freeing up even more horizontal space.
## Vertical Tabs + Tab Groups
Vertical tabs pair naturally with tab groups. Groups appear as collapsible sections in the side panel, making it easy to keep projects separate and fold away tabs you are not actively using.
# BrowserOS
Source: https://docs.browseros.com/index
The open-source AI browser that turns your words into actions
BrowserOS is an AI-native browser that lets you automate any web task by describing it in plain English. Built on Chromium, it runs AI agents locally on your machine—keeping your data private while giving you superpowers for browsing.
**Open source. Privacy-first. The browser for the AI era.**
## Three Ways to Use AI
Ask questions about the page you're viewing. Summarize articles, extract data, translate content—without leaving the page.
Describe a task and watch AI execute it: clicking, typing, navigating. Automate form filling, data extraction, and multi-step workflows.
Build reliable, repeatable workflows as visual graphs. Edit steps, save, and run anytime. *Coming soon.*
## Quick Start
Get the latest release from [browseros.com](https://browseros.com) for macOS, Windows, or Linux.
Navigate to `chrome://settings/importData` and import your bookmarks, passwords, and settings in one click.
BrowserOS includes a default AI model with limited daily usage for testing. For the full experience, bring your own API keys.
Configure Gemini, Claude, OpenAI, or run models locally with Ollama
Open any webpage and press the **Assistant** button in the toolbar. Ask a question about the page, or describe a task to automate.
## Which AI Model Should I Use?
**Any model works great**, including local LLMs.
* **Ollama** or **LM Studio** — Free, runs locally, great for quick questions
* **Gemini Flash** — Fast and affordable
* **Claude or GPT-4** — Best quality responses
Chat Mode just needs to understand the page and answer questions—local models handle this well.
**Use Claude Opus 4.5 for best results.**
| Model | Speed | Quality |
| ----------------- | ------ | ------- |
| Claude Opus 4.5 | Slower | Best |
| Claude Sonnet 4.5 | Medium | Great |
| Claude Haiku 4.5 | Fast | Good |
| Gemini Flash | Fast | Good |
Local LLMs are not yet powerful enough for Agent Mode. The model needs strong reasoning to click the right elements and handle multi-step tasks.
## Why BrowserOS?
Run AI locally with Ollama, or bring your own API keys. Your browsing data never leaves your machine unless you choose.
100% open source under AGPL-3.0. Inspect the code, contribute features, or fork it for your needs.
Built-in MCP servers for Gmail, Calendar, Docs, Sheets, Notion. Connect to Claude Code or Gemini CLI for developer workflows.
All your Chrome extensions work. Import bookmarks, passwords, and settings in one click.
## Community
Get help and share feedback
Star us and contribute
Follow for updates
# n8n Integration
Source: https://docs.browseros.com/integrations/n8n
Build AI workflows that control your browser
Connect BrowserOS to n8n to build automated workflows. Your n8n AI agents can control the browser—open pages, click buttons, extract data, and fill forms.
## What You Can Build
* **Lead enrichment** — Pull a list of LinkedIn URLs from a spreadsheet and scrape each profile
* **Price monitoring** — Check product prices hourly and send a Slack alert when they drop
* **Form automation** — Auto-fill job applications using data from your CRM
* **Data extraction** — Scrape authenticated pages that require login
## Prerequisites
Before you start:
* BrowserOS running with MCP server enabled (Settings → BrowserOS as MCP)
* n8n running locally (`npx n8n` or install globally with `npm install -g n8n`)
## Setup
### 1. Install the MCP community node
In n8n, go to **Settings → Community Nodes** and install `n8n-nodes-mcp`:
### 2. Create a workflow
Build a workflow with these nodes:
1. Add a **Chat Trigger** node (receives your messages)
2. Add an **AI Agent** node and connect it to the trigger
3. Add a **Chat Model** under the AI Agent (e.g., OpenAI, Claude)
4. Add an **MCP Client Tool** under the AI Agent
### 3. Configure the AI Agent
In the AI Agent node, set **Source for Prompt** to **Connected Chat Trigger Node**.
### 4. Connect to BrowserOS
Click on the MCP Client node and configure:
* **Endpoint**: Your BrowserOS MCP URL (find it in Settings → BrowserOS as MCP)
* **Server Transport**: `HTTP Streamable`
### 5. Test it
Save the workflow, click **Open chat**, and try:
```
open google.com in BrowserOS
```
## Troubleshooting
If the connection fails:
* Make sure BrowserOS is running
* Check that MCP server is enabled in BrowserOS settings
* Verify the port number matches your BrowserOS MCP URL
# Audit and replay
Source: https://docs.browseros.com/neo/audit-and-replay
Every agent step is on your disk. Search, click through, and replay any session like a video. Nothing leaves your machine.
BrowserOS neo records everything your AI does in the browser so you can go back and see exactly what happened. All of it lives on your computer. Nothing goes to any server we control.
## The audit trail
Every session your AI runs shows up on the audit page. Search across all of them, filter by agent, status, or site, and click any row to open its full story.
Sessions land in one of three states:
* **Live**: the AI is still working.
* **Done**: it finished cleanly.
* **Failed**: something errored during the run.
## What each session shows you
Click any session and you get its full story: agent, timestamps, and every step the AI took, in order.
If the session used more than one tab, a tab strip lets you jump between them. Each tab has its own timeline of actions. Most steps include a screenshot of what the AI was looking at when it ran. Click one to open it full-size.
Sessions also carry a **View Session Replay** button that unlocks as soon as replay data lands.
## Replay like a video
Click **View Session Replay** to watch the whole session play back. The replay is the actual page the AI saw, not just a screenshot: DOM changes, scrolls, clicks, everything as it happened.
Use the scrubber to jump to any moment. Click any step on the right timeline to skip the replay straight to that action. If the session touched multiple tabs, switch between them at the top; each tab is its own recording with its own time origin.
## Where all of this lives
Everything you see on these pages sits in one folder on your computer: **`~/.browserclaw/`** in your home directory.
* `~/.browserclaw/browserclaw.sqlite` is the shared database for audit history, tasks, sessions, recording indexes, tab claims, and tab ownership.
* `~/.browserclaw/screenshots/` is a JPEG per screenshotted step.
* `~/.browserclaw/replays/` is the recording data per session.
That folder is spelled `.browserclaw`, not `.neo`. It keeps the product's old name so the rename doesn't orphan the history you already have. Type it exactly as written above.
The BrowserOS neo server that reads and writes these files only accepts requests from your own machine. It binds `127.0.0.1`, the local loopback, so nothing on your network can reach it. No account. No telemetry. No cloud sync.
If you want to delete a session or wipe everything, delete the files. That's it.
## What isn't recorded
* **Your personal tabs.** The recorder is only loaded into tabs your AI opened. Tabs you opened for your own work never get it. This isn't a policy on top of a general recorder; the recorder script is never even loaded there.
* **Passwords.** Any input marked as a password field is masked before it hits the recording.
* **Canvas and mouse jitter.** Canvas contents are not recorded. Cursor movements are not recorded either.
If you want the full picture, keep reading:
The full breakdown of what stays on your machine.
A guided walkthrough from install to your first AI-driven session.
# Your dashboard
Source: https://docs.browseros.com/neo/cockpit
The new-tab dashboard that shows what your AI is doing now and what it did before.
Open a new tab in BrowserOS neo and you land on your dashboard. It shows what your AI is working on right now and what it did before, so you always know what happened without pinging your AI to check.
## What you see
Two regions stack on the page:
* **Running now** shows a live card for every AI that is actively working. It only appears when at least one AI is running.
* **Recent activity** shows the sessions your AIs already finished, newest first. Click any of them to open the full story.
## Running now
Every live agent gets its own card at the top of the dashboard.
Each card carries:
* A live preview of the browser tab your AI is looking at right now, updating as it works.
* A **LIVE** chip and a pulsing dot so you can tell at a glance which agents are actually doing something.
* The site title, the AI's name, and a short trail of the last few actions it took (like `tabs → read → navigate`).
* A tab-count chip in the corner so you know how many tabs this AI has open.
* Two buttons at the bottom of the card:
* **Watch** switches your active tab to the one the AI is working in, so you can look over its shoulder.
* **Stop** ends the session. If your AI went off the rails, one click cancels the run.
## Recent activity
Once a session finishes, it moves down into Recent activity. The most recent (or any still-live) session takes the big lead tile on the left. Four supporting tiles show what's after that. Anything older stacks in a compact typographic list below.
Each tile is clickable and takes you straight to the full session view, where you can read every action step by step or hit **View Session Replay** to watch the whole run like a video.
The home page holds the twelve most recent sessions. To see everything, click **View all activity** at the bottom of the section and you'll land on the full audit list.
## Where to next
A guided walkthrough from install to your first AI-driven session.
What BrowserOS neo records, what it doesn't, and where everything lives.
# How BrowserOS neo works
Source: https://docs.browseros.com/neo/how-it-works
A step-by-step walkthrough from download to your first AI-driven browsing session.
This page walks you from a fresh download to your first AI-driven session. Six steps. About five minutes.
Head over to [browseros.com/agents](https://browseros.com/agents) and download BrowserOS neo for your operating system. Install it the way you'd install any other browser.
Once it's open, it works like Chrome or any other browser you've used. Bookmarks, extensions, keyboard shortcuts, all in the same places.
Use BrowserOS neo as your browser for a bit. Sign in to Gmail. Sign in to your calendar. Sign in to Notion, Linear, your CRM, your accounting tool, whatever you use for actual work.
There is nothing special about this step. You are just using a browser. But it matters, because every account you sign in to here becomes something your AI can use later.
Your AI cannot see your personal tabs unless you ask it to. It works in its own tabs, side by side with yours. Signing in to Gmail here means your AI can use Gmail when you ask it to. It does not mean your AI is reading your inbox while you're not looking.
Open a new tab in BrowserOS neo and click **MCP** in the sidebar. You'll see a list of AI tools you can connect with one click.
Find the AI tool you use: Claude Code, Cursor, Codex, Antigravity, VS Code, Zed, or another. Click **Connect** on its row. BrowserOS neo sets everything up for you.
Restart your AI tool once, and it now has a browser.
Using an AI tool that isn't listed? Copy the endpoint URL at the top of the page and paste it into your AI's own settings. See the [Connect page](/neo/mcp) for the manual setup.
Open your AI tool and give it a real task. Something you'd actually want done. To start, try this:
```text theme={null}
Find a good time next week for a 30-minute team meeting and send the invite.
```
Or something closer to your own work:
```text theme={null}
Summarize my important unread emails from the last two days.
```
```text theme={null}
Pull the numbers from the Q3 dashboard in Notion and put them in a summary at the top.
```
Whichever you pick, hit send.
Open a new tab in BrowserOS neo. Your AI's session shows up on the dashboard.
Two things to look at:
* **Running now**: the AI working on your task right now. You'll see the site it's on, how long it's been at it, and a live preview of what it's looking at.
* **Recent activity**: sessions that already finished. Click any tile to open the full story of what happened.
You don't have to sit and stare. Come back whenever you want; the dashboard shows you what's been going on.
When a session finishes, click its tile. Then click **View Session Replay**.
The replay plays back like a video. Hit rewind to see the exact moment things went off, or the exact moment something went well. On the right, every step your AI took is listed in order, and you can click any one to jump the replay to that moment.
Now you know what worked. Tell your AI, and it'll do the next task better.
## Where to next
Every part of the new-tab dashboard and what it tells you.
What BrowserOS neo records, what it doesn't, and where everything lives.
# BrowserOS neo
Source: https://docs.browseros.com/neo/index
The browser your AI can actually use. It's your browser, your logins, your control.
BrowserOS neo is a browser your AI can actually use. You install it and use it like any browser. Once you're signed in to the sites you use every day, your AI can use those same logins to get real work done. You watch every step on your new tab page, and replay anything it did like a video.
## The problem
Your AI is smart. But it can't press the buttons.
Ask it to book a flight, download an invoice, or send a message from your inbox. It stops at the login screen. Today's tools open a blank browser where nothing is signed in, or a browser running on some remote cloud. Neither one can do your real work.
## The idea
BrowserOS neo is a real browser you install and use. Because it's your browser, your logins are already there. Your email, your calendar, your bank, your work tools: all signed in.
When your AI drives BrowserOS neo, it can actually do things. Book a meeting on your calendar. Reply to an email from your inbox. Get the numbers from a Notion doc. File an expense. The 15-minute chores you keep meaning to get to just get done.
## Three things you get
Your Gmail, your calendar, your bank, your work tools. Already signed in. Your AI uses the logins you already have.
A dashboard on your new tab shows every AI working right now. Which site it's on, what it's doing, how far along.
Every session becomes a video you can replay. If your AI got something wrong, hit rewind and see where. If it went right, you know the recipe.
## See it in action
Three steps from asking your AI to replaying what it did.
One click connects BrowserOS neo to Claude Code, Cursor, Codex, and other AI tools. Nothing to set up.
In your AI chat, ask it to do something you actually need done. Something like: `Book me the cheapest morning flight from SFO to NYC next Friday.`
Open a new tab. Your AI's session shows up on your dashboard, live, with a preview of what it's doing. When it's done, you can replay the whole run like a video.
## Your stuff stays yours
Everything that happens in BrowserOS neo stays on your computer. Your sessions, your screenshots, your history: none of it goes anywhere. We don't have servers to store it, and no dashboard to peek at what you're doing.
The full breakdown of what stays on your machine.
## Get started
macOS, Windows, and Linux. Free and open source.
One-click setup for Claude Code, Cursor, Codex, VS Code, Zed, and more.
A guided walkthrough from install to your first task.
# Install BrowserOS neo
Source: https://docs.browseros.com/neo/install
Download and install BrowserOS neo on macOS, Windows, or Linux.
This page is landing in a follow-up release. Track the [BrowserOS neo docs rollout](https://github.com/browseros-ai/BrowserOS/issues) for progress.
Coming soon.
Continue with what is shipped today.
# Claude Desktop and Cowork
Source: https://docs.browseros.com/neo/mcp/claude-desktop
Give Claude Desktop, and Cowork inside it, a real browser via a one-file extension.
[Claude Desktop](https://claude.ai/download) and [Claude Cowork](https://claude.com/product/cowork) both run inside the same Claude app. A single BrowserOS neo extension gives them both a real browser to work in.
## Install
Download BrowserOS neo from [browseros.com/agents](https://browseros.com/agents) if you haven't already. Launch it at least once so the local server is running.
Head to the [releases page](https://github.com/browseros-ai/browserclaw-claude-desktop/releases) and grab the latest `browserclaw-.mcpb` file. This is the Claude Desktop extension package.
Open Claude Desktop's Settings window and drag the `.mcpb` file onto it. Claude Desktop registers the extension and starts using BrowserOS neo's tools right away.
The repo and the `.mcpb` file still carry the product's old name, BrowserClaw. Only the product was renamed, not the release artifacts, so download the file spelled exactly as above.
## Verify
Open BrowserOS neo, then in Claude Desktop ask:
```text theme={null}
Open browseros.com/agents in a new tab and tell me the page title.
```
Claude opens the page inside BrowserOS neo and replies with the title.
## Cowork gets it too
Cowork runs inside Claude Desktop, so the same extension unlocks it there as well. Ask Cowork to do a task that involves the web, and it uses BrowserOS neo the same way Claude Desktop does. No second install.
## Where the extension came from
The extension is a small forwarding wrapper: Claude Desktop talks to it locally, and it forwards every call to BrowserOS neo's local endpoint. Nothing goes to a server we control. Source, install file, and privacy policy live in the [browserclaw-claude-desktop repo](https://github.com/browseros-ai/browserclaw-claude-desktop).
## Troubleshooting
**Claude says `BrowserClaw is not running`.** Open BrowserOS neo. The local server starts with the app. The message uses the old product name because it comes from the extension, which still ships under it.
**The extension does not load.** Restart Claude Desktop. If it still fails, remove the extension from Settings and install the latest release again.
**Claude is not using the browser when it should.** Say `Use BrowserClaw for this` the first time and Claude picks up the tools. That is the name of the MCP entry, so it is the name Claude recognizes.
## Where to next
A guided walkthrough from install to your first AI-driven session.
The AI tools we support with one click today.
# Connect your agent
Source: https://docs.browseros.com/neo/mcp/index
One-click setup for the AI tools we support. A Claude Desktop extension. A copyable endpoint URL for everything else.
BrowserOS neo is one MCP server, at one URL, on your own machine. Any AI tool that supports MCP can use it. This page covers the one-click board for the tools we support today. For anything else, [set it up manually](/neo/mcp/manual) with the endpoint URL below.
## The endpoint URL
Open a new tab in BrowserOS neo and click **MCP** in the sidebar. The top of the page shows the endpoint URL:
```text theme={null}
http://127.0.0.1:9200/mcp
```
That address is local to your computer. Nothing crosses the network. Click **Copy** at the top of the page to grab it.
## One-click setup
Under the endpoint URL you'll see the list of AI tools we support out of the box. Find yours, click **Connect**, and restart the AI tool.
Today the supported AI tools are **Claude Code**, **Codex**, **Cursor**, **OpenCode**, **Antigravity**, **VS Code**, and **Zed**. Behind the scenes, BrowserOS neo writes a single entry named `browseros-neo` into the AI tool's own MCP config file, pointing at the endpoint URL above. Existing managed `BrowserOS neo` and `BrowserClaw` entries are recognized and migrated automatically.
The board updates as soon as your AI tool actually loads the config. If you don't see the row flip to **Connected**, restart the AI tool once and come back.
## Don't see your AI tool?
If your AI tool supports MCP but isn't on the one-click board, we'd love to add it. Head to [BrowserOS Discussions](https://github.com/orgs/browseros-ai/discussions) and open a new discussion. A short template that helps us move fast:
```text theme={null}
Title: Add one-click support for
- Name and link to the AI tool
- Which config file it uses for MCP servers (path + format)
- A link to that AI tool's MCP setup docs
- Whether you're already using BrowserOS neo with it via the manual setup
```
While you're waiting for one-click support, two other paths work with almost every AI tool.
Install the BrowserOS neo extension into Claude Desktop with a single file.
Guided setup for Hermes Agent, Vercel AI SDK, OpenClaw, and other MCP-compatible AI tools.
## Where to next
A guided walkthrough from install to your first AI-driven session.
Every part of the new-tab dashboard and what it tells you.
# Manual URL setup
Source: https://docs.browseros.com/neo/mcp/manual
Connect BrowserOS neo to any MCP-compatible AI tool with the copyable endpoint URL.
Any AI tool that speaks MCP over HTTP can use BrowserOS neo. The pattern is always the same: copy the endpoint URL, drop it into the tool's own MCP config, restart. The exact syntax varies by tool. Here are the ones we've documented so far.
First, grab the endpoint URL from BrowserOS neo. Open a new tab, click **MCP** in the sidebar, and click **Copy** at the top of the page. It looks like this:
```text theme={null}
http://127.0.0.1:9200/mcp
```
Now pick your AI tool below.
The examples name the server `browseros-neo`, matching the one-click setup. The name is yours to choose, but whatever you pick is the name your AI tool will know the browser by.
## Hermes Agent
[Hermes Agent](https://hermes-agent.nousresearch.com) from Nous Research supports connecting to external HTTP MCP servers via its YAML config. Full details in [Hermes' MCP docs](https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp).
Open `~/.hermes/config.yaml` and add a `mcp_servers` entry:
```yaml theme={null}
mcp_servers:
browseros-neo:
url: "http://127.0.0.1:9200/mcp"
```
Then reload Hermes:
* Inside an existing `hermes chat` session, run `/reload-mcp`.
* Or restart Hermes.
Hermes also has a CLI command that adds a server interactively: `hermes mcp add browseros-neo`. Either path works.
## Vercel AI SDK
The [Vercel AI SDK](https://ai-sdk.dev/) supports MCP tools via the `@ai-sdk/mcp` package. Full details in [the AI SDK MCP docs](https://ai-sdk.dev/docs/ai-sdk-core/mcp-tools). Point the client at BrowserOS neo's endpoint URL, pull the tools, and pass them into `streamText` or `generateText`.
```javascript theme={null}
import { createMCPClient } from '@ai-sdk/mcp';
import { streamText } from 'ai';
const mcpClient = await createMCPClient({
transport: {
type: 'http',
url: 'http://127.0.0.1:9200/mcp',
},
});
const tools = await mcpClient.tools();
const result = await streamText({
model: 'xai/grok-4.5',
tools,
prompt: 'Open the running BrowserOS neo tab and summarise what my agent just did.',
onFinish: async () => {
await mcpClient.close();
},
});
```
The AI SDK docs recommend closing the client once you're done. In streaming code that means `mcpClient.close()` inside `onFinish`. In non-streaming code, use a `try` / `finally` block.
## OpenClaw
[OpenClaw](https://openclaw.ai) is an open-source personal AI assistant that can act as an MCP client. Full details in [OpenClaw's MCP docs](https://docs.openclaw.ai/cli/mcp).
The fastest path is the CLI:
```bash theme={null}
openclaw mcp add browseros-neo --url http://127.0.0.1:9200/mcp --transport streamable-http
```
Or edit `~/.openclaw/openclaw.json` directly:
```json theme={null}
{
"mcp": {
"servers": {
"browseros-neo": {
"url": "http://127.0.0.1:9200/mcp",
"transport": "streamable-http"
}
}
}
}
```
Verify the connection with the built-in doctor:
```bash theme={null}
openclaw mcp doctor browseros-neo --probe
```
## Any other MCP-compatible AI tool
The pattern is the same: paste `http://127.0.0.1:9200/mcp` into the AI tool's own MCP server config, using whatever syntax that tool expects. BrowserOS neo's endpoint uses **Streamable HTTP** transport (per the current MCP spec), so any client that supports Streamable HTTP works.
If you get your AI tool talking to BrowserOS neo and want to help others do the same, please [open a discussion](https://github.com/orgs/browseros-ai/discussions) with the setup steps.
## Where to next
A guided walkthrough from install to your first AI-driven session.
The AI tools we support with one click today.
# Privacy and data
Source: https://docs.browseros.com/neo/privacy
Everything BrowserOS neo records about your work stays on your computer. Anonymous product events help us improve the app, and they're opt-out. This page walks through both.
Everything BrowserOS neo records about your work stays on your computer. No cloud sync, no account, no server-side history of what your agents did. This page walks through exactly what stays local, what leaves as anonymous product events, and what your AI's own provider handles.
## What stays on your machine
Your history, cookies, logged-in sessions, downloads, and every recording of what your agents did live in BrowserOS neo's local browser profile on your disk. Sessions and screenshots the [audit and replay](/neo/audit-and-replay) pages show you all live under `~/.browserclaw/`.
None of it uploads. There is no cloud sync, no server-side account, no shared history.
If you want to wipe any of it, delete the files.
## What we never see
The following never leaves your machine, not in any stream, not in any log:
* URLs your agents visit
* Page titles and page content
* Prompts you send your AI
* Tool arguments and tool results
* Screenshots
* File paths
* Passwords
* API keys
* Your email
## Anonymous product events
BrowserOS neo sends a small amount of anonymous usage data so we can see how the product is used and fix rough edges. It's on by default and off with one toggle in Settings.
Here's every field that goes out:
* Startup and shutdown
* Which AI tools connect and disconnect (the tool's name from a fixed list, plus session end times)
* BrowserOS neo version and your operating system
None of the fields in the "never leaves" list above are in this stream. There is no user identifier. There is no page content.
These events go to [PostHog](https://posthog.com), a product analytics service. They're subject to PostHog's own privacy policy. If you'd rather send nothing at all, open Settings and switch the toggle off.
## Your AI's own provider
When your AI works in BrowserOS neo, the AI itself (Claude Code, Cursor, Codex, and so on) talks to its own vendor with your prompts. What that vendor does with the data is governed by their privacy policy, not ours. BrowserOS neo does not intermediate that leg.
## The Claude Desktop extension
The [Claude Desktop extension](/neo/mcp/claude-desktop) (the `.mcpb` file you drop onto Settings) collects zero data. No analytics, no telemetry, no error reporting, no user identifiers.
The extension is a small forwarder: Claude Desktop asks it something, it hands the call to BrowserOS neo on your own machine, and passes the result back to Claude Desktop. It talks to no service on the internet on its own. Nothing kept, nothing sent.
## Read the full policies
Every field, every promise, in legal-clean wording.
The zero-data extension policy in full.
## Where to next
Every step your agents take, on your disk.
How BrowserOS neo sorts your tabs and your AI's tabs.
# Your tabs and agent tabs
Source: https://docs.browseros.com/neo/tabs-and-isolation
How BrowserOS neo groups your tabs and your AI's tabs so you always know what's what.
You use your browser for your own work. When an AI drives BrowserOS neo, it works in tabs of its own, right next to yours.
## Two kinds of tabs, one browser
* **Your tabs.** Pages you opened yourself.
* **The AI's tabs.** Pages your AI opened for the task you gave it.
Each AI's tabs land in their own colored tab group at the top of your tab strip, titled with the AI's name. Your tabs stay outside any group. One glance tells you what belongs to whom.
## Your AI knows the difference
BrowserOS neo tells your AI which tabs belong to you and which it opened itself. Your AI uses that to stay out of your workflow by default. It knows your tabs are there and can read their titles and URLs, so it has context, but it doesn't jump in.
If you want your AI to help with something you have open, reply to the email you're reading, extract the numbers from the doc on your screen, just ask. Your AI can work on the tab. That's your call.
## When an AI's session ends
Close an AI's session and its tab group closes with it. The tabs it opened go away in one step. Your tabs are never touched.
If you close one of an AI's tabs while it's still running, the AI notices right away. Nothing gets stuck.
## Where to next
What BrowserOS neo records, what it doesn't, and where everything lives.
A guided walkthrough from install to your first AI-driven session.
# Getting Started
Source: https://docs.browseros.com/onboarding
Set up BrowserOS in 2 minutes
Welcome to BrowserOS! Let's get you set up.
Bring your bookmarks, history, and passwords from Chrome.
1. Go to `chrome://settings/importData`
2. Select **Google Chrome** and click **Import**
3. Choose **Always allow** when prompted
This imports everything in one click — bookmarks, passwords, history, and extensions.
BrowserOS includes a default AI model with limited daily usage. For the best experience, add your own.
**Quick option:** Get a free Gemini API key from [aistudio.google.com](https://aistudio.google.com) — 20 requests per minute at no cost.
Set up Gemini, Claude, OpenAI, or run models locally with Ollama
Open any webpage and click the **Assistant** button in the toolbar.
* **Chat Mode:** Ask questions about the page
* **Agent Mode:** Describe a task and watch it execute
For Agent Mode, use Claude Opus 4.5 or Sonnet 4.5. Local models work great for Chat but aren't powerful enough for agents yet.
## You're all set!
**Block ads with uBlock Origin** — Chrome dropped support for the full uBlock Origin extension, but BrowserOS brought it back. [Install it from the Chrome Web Store](https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm) and browse ad-free. [Learn more →](/features/ad-blocking)
Explore what BrowserOS can do:
Hand off a multi-step task and combine browser automation with local files
Control BrowserOS from Claude Code or Gemini CLI
# Has Agent Crashed?
Source: https://docs.browseros.com/troubleshooting/connection-issues
How to fix connection issues when the BrowserOS agent is not responding
If you see **"Failed to Fetch"** or **"Unable to connect to BrowserOS agent"**, your agent has been killed.
## Windows: Did you allow the BrowserOS Agent?
When BrowserOS starts for the first time on Windows, a popup will ask if you want to allow **BrowserOS Agent** to access the network. Click **Allow** — the agent runs as a separate process alongside the browser and needs this permission to work. If you clicked **Cancel** or missed this prompt, the agent won't be able to connect.
To fix this, go to **Windows Security → Allow an app through your network settings**, and make sure **BrowserOS Agent** is enabled.
## Fix It
Open **Settings** from the sidebar, scroll to the MCP Server section, and click **Restart**. Wait a couple of minutes.
1. Open **Task Manager** — press `Ctrl + Shift + Esc` or right-click the taskbar and select **Task Manager**.
2. In the search bar at the top, type **browseros agent**.
3. Right-click **BrowserOS Agent** and select **End task**.
4. Reopen **BrowserOS** — the agent will restart automatically.
If the agent still doesn't reconnect, end both **BrowserOS** and **BrowserOS Agent** in Task Manager, then reopen the app.
Right-click BrowserOS in the Dock → **Quit**, then reopen the app.
## Still Not Working?
The agent runs on port `9100` by default. If another application is using this port, BrowserOS cannot start the agent.
Find the process:
```bash theme={null}
lsof -i :9100
```
Kill it (replace `PID` with the process ID from above):
```bash theme={null}
kill -9 PID
```
Find the process:
```powershell theme={null}
netstat -ano | findstr :9100
```
Kill it (replace `PID` with the process ID from above):
```powershell theme={null}
taskkill /PID PID /F
```
Then restart BrowserOS.
Some firewalls may block local connections. Make sure your firewall allows connections to `127.0.0.1:9100`.
**Windows users:** Antivirus software sometimes triggers a false positive. Try temporarily disabling your antivirus and restarting BrowserOS.
## Get Help
If you're still experiencing issues, reach out:
Get help from the community
Join our Slack
# Update BrowserOS
Source: https://docs.browseros.com/update/index
How to update to the latest version of BrowserOS
Select your platform for step-by-step update instructions:
Auto-updates with manual option
Download and install the latest version
Download and replace the binary