How does the Chrome extension connect to Nemo?

The Nemo Chrome extension connects to the Nemo desktop application through Chrome's Native Messaging protocol. When you install Nemo, it automatically registers a native messaging host on your computer. The extension connects to this host, which then communicates with Nemo's Python backend over a local TCP connection on port 18792. All communication is encrypted using ECDH P-256 key exchange with AES-256-GCM encryption. No data passes through external servers — the entire communication channel is local to your machine.

Is my browsing data safe?

Yes. The Nemo Chrome extension does not monitor, track, or record your browsing activity. It only reads page content when you explicitly ask Nemo to interact with a specific page. All communication between the extension and Nemo is encrypted with AES-256-GCM. Page content is processed locally by your LLM provider (or entirely on your machine if you use Ollama). Nemo does not operate any servers that receive your browsing data. The extension has no analytics, no tracking pixels, and no advertising. It activates only on demand when you give Nemo a task that requires browser interaction.

Can it fill any web form?

The Nemo extension can fill most standard HTML forms including text inputs, textareas, select dropdowns, checkboxes, and radio buttons. It works on government forms, job applications, registration pages, checkout forms, and most enterprise web applications. However, it has limitations with some modern web applications: heavily JavaScript-rendered forms that do not use standard HTML input elements may not be fully accessible, CAPTCHA-protected forms cannot be automated, and some sites with aggressive bot detection may block automated interactions. The extension reads the page's DOM to identify form fields, so any field visible in the HTML source can typically be filled.

Does it work on all websites?

The extension works on the vast majority of websites, including complex single-page applications built with React, Angular, and Vue. It reads pages by extracting the DOM content, which works regardless of the frontend framework used. However, there are some limitations: pages behind authentication require you to be logged in first (the extension does not store or handle login credentials for third-party sites). Some banking and financial sites have Content Security Policies that may restrict extension interactions. Sites that heavily rely on Shadow DOM or canvas-rendered interfaces may have limited accessibility. For the 95% of the web that uses standard HTML, the extension works reliably.

How is this different from Selenium?

Selenium is a developer tool for programmatic browser testing that requires writing code, setting up WebDriver, and managing browser binaries. It runs a separate browser instance and is designed for automated testing, not personal productivity. The Nemo Chrome extension is an AI-powered automation layer that works within your existing Chrome browser, controlled by natural language. You say 'fill out this job application with my resume data' and Nemo handles field detection, data mapping, and entry automatically. Selenium requires you to write code specifying each field's CSS selector and the exact value to enter. Additionally, Selenium is easily detected by anti-bot systems, while the Nemo extension operates like a normal Chrome extension, making it less likely to trigger bot detection.

Nemo Chrome Extension: Automate Any Website Without an API

The API Problem

The promise of automation has always bumped against a hard reality: most websites do not offer public APIs. And the ones that do often make them expensive, rate-limited, or restricted to enterprise customers. Want to automate filing a government form? No API. Want to auto-fill job applications across multiple career sites? No API, or a different API for each one. Want to extract data from your insurance company's dashboard? Definitely no API.

Traditional automation tools like Zapier and Make work by connecting to APIs. If a service has a Zapier integration, you can automate it. If it does not, you are stuck. This creates a frustrating divide where well-funded SaaS tools with developer teams get automated, but the everyday websites where people spend most of their time — government portals, HR systems, banking dashboards, insurance forms, university applications — remain entirely manual.

The developer approach has been tools like Selenium and Playwright, which can control a browser programmatically. These are powerful but require significant coding skill. You need to inspect the page's HTML, write CSS selectors or XPath expressions for every element, handle page loads and JavaScript rendering, manage browser sessions, and write retry logic for flaky interactions. For a single page, this might take an afternoon. For a workflow that spans multiple pages on multiple sites, it becomes a full development project.

Nemo's Chrome extension solves this problem differently. Instead of requiring an API or coding, it lets an AI agent interact with any website the same way you do: by reading what is on the page and filling in fields, clicking buttons, and navigating links. You describe what you want in plain English, and the AI handles the rest.

What the Nemo Chrome Extension Does

The Nemo Chrome extension gives Nemo's AI agent the ability to interact with your web browser. It is a Manifest V3 Chrome extension that connects to the Nemo desktop application and acts as the agent's "hands" in the browser. Here is what it can do:

Read page content: Extract the text, structure, and form fields from any web page. The agent sees what you see, including dynamically rendered content from JavaScript frameworks like React, Angular, and Vue.
Fill form fields: Enter text into input fields, select options from dropdowns, check checkboxes, and select radio buttons. The agent maps your personal data to form fields using AI reasoning, not hardcoded selectors.
Navigate between pages: Follow links, submit forms, and move between pages in a multi-step workflow. The agent can handle sequences like "go to the careers page, click Apply, fill the application, and submit."
Extract structured data: Pull specific information from a page into a structured format. For example, extracting product names, prices, and availability from an e-commerce page into a comparison table.
Submit forms: After filling fields, submit forms with a single confirmation from you (all form submissions require draft consent — you always approve before anything is sent).

All of this is controlled through natural language in Nemo's chat interface. You do not write code, inspect HTML, or configure selectors. You say "fill out this form with my information" and the agent handles field detection, data mapping, and entry.

Architecture: How It Works

The Chrome extension communicates with Nemo through a carefully designed architecture that prioritizes security and privacy. Here is how the pieces fit together:

Native Messaging (Manifest V3)

Chrome extensions have strict security boundaries. They cannot directly communicate with arbitrary local applications. Chrome provides a mechanism called Native Messaging that allows extensions to communicate with registered native applications through stdin/stdout pipes. When you install Nemo, it registers a native messaging host (com.nemo.agent) with Chrome. This registration is automatic — you do not need to edit registry keys or configuration files manually.

The communication chain is: Chrome Extension connects to native_host.py (a lightweight Python process) via Chrome's Native Messaging protocol. The native host then connects to Nemo's BrowserRelay server running on localhost port 18792 via TCP. The BrowserRelay is part of Nemo's Python backend and integrates with the agent's skill system.

End-to-end encryption

All commands between the extension and Nemo are encrypted. When the extension first connects to the native host, they perform an ECDH P-256 key exchange. This generates a shared secret that is never transmitted. The shared secret is then fed through HKDF with SHA-256 (using the salt "nemo-relay-v1") to derive an AES-256-GCM encryption key. Every subsequent message is encrypted with this key, including a unique nonce for each message to prevent replay attacks.

This means that even if another local application could intercept the communication between the extension and the native host (which Chrome's sandboxing makes difficult), the data would be indecipherable without the session key. The key is ephemeral — it is regenerated every time the extension connects.

Heartbeat and reconnection

The extension sends a heartbeat ping every 20 seconds. The relay responds with a pong. If the relay does not receive a heartbeat for 45 seconds, it considers the extension disconnected and cleans up the session. If the extension loses its connection, it uses exponential backoff (starting at 1 second, capped at 30 seconds) to reconnect, with a maximum of 10 attempts before giving up. This ensures that temporary interruptions (like Nemo restarting) are handled gracefully without losing state.

Content size limits

Chrome's Native Messaging protocol has a hard limit of 1MB per message. To stay well within this limit, the extension caps HTML content at 500KB. For most web pages, this captures the full page content. For extremely large pages (some enterprise dashboards can render massive DOM trees), the extension intelligently truncates by removing script tags, style blocks, and deeply nested elements that are typically not relevant to form fields or readable content.

Form Filling Deep Dive

Form filling is the Chrome extension's most sophisticated capability. Nemo's form_filler skill uses a multi-phase approach that combines AI reasoning with a learned strategy system to fill forms accurately and efficiently.

Phase 1: Scan and ask

When you ask Nemo to fill a form, the agent first sends a browser.read_fields command to the extension. This returns a structured list of all form fields on the page: their names, types (text, select, checkbox, etc.), current values, and any label text or placeholder text. The agent then analyzes these fields against your saved profile data to create a fill plan.

If the form has fields that the agent cannot map to your profile data, it triggers the ask-for-missing pattern. Instead of guessing or leaving fields blank, the agent explicitly asks you: "This form has a field labeled 'Employee ID Number' that I don't have in your profile. What should I enter?" This happens before any data is entered into the form, so you have full visibility and control.

Phase 2: Save and fill

After you confirm the fill plan (and provide any missing values), the agent enters data into each field using browser.fill_field commands. Each field fill is a separate command, allowing the agent to handle errors and unexpected page behavior on a per-field basis. If a field triggers a dynamic page change (like selecting a country that loads a new set of state options), the agent detects this and adapts.

Any new information you provided (like that Employee ID) is optionally written back to your profile for future use. This means the agent learns your data over time, and the second time you fill a similar form, it will not need to ask for those values again.

Strategy Knowledge Base

One of Nemo's most powerful features is the Form Strategy Knowledge Base. After successfully filling a form, the agent saves a complete recipe for that form's domain. The recipe maps each form field to the profile key it was filled from (e.g., 02frstname = profile.name.first) and records any derived transformations (e.g., profile.dob = extract month).

The next time you or any Nemo user fills a form on the same domain, the agent can follow this recipe directly instead of reasoning through every field mapping from scratch. This dramatically reduces the number of LLM calls needed (from 7+ to 1–2) and improves accuracy because the recipe was verified by a successful previous fill. The Strategy Knowledge Base is part of Nemo's Collective Intelligence system, so recipes are shared (anonymized) across all Nemo users.

Submission safety

Form submission always uses draft consent. The agent prepares the submission and shows you exactly what will be submitted, but nothing is sent until you explicitly approve. Additionally, the agent blocks submission attempts when less than 50% of the form fields are filled, returning an error that lists the unfilled fields. This prevents accidental submission of incomplete forms.

Page Reading and Data Extraction

Beyond form filling, the Chrome extension allows Nemo to read and understand web page content. When the agent sends a browser.read command, the extension extracts the page's DOM content, strips non-essential elements (scripts, styles, hidden elements), and returns a cleaned HTML representation capped at 500KB.

The AI model then processes this content to understand the page's structure and extract relevant information. This is fundamentally different from traditional web scraping:

Traditional scraping requires you to write CSS selectors or XPath expressions for each piece of data. Change the website's HTML structure and your selectors break.
AI-powered reading understands the semantic meaning of content. "Find the price of this product" works regardless of whether the price is in a <span class="price">, a <div data-price>, or a table cell. The AI understands context, not selectors.

This makes the extension resilient to website redesigns. A traditional scraper breaks when a website changes its CSS classes. Nemo's AI-powered reading adapts automatically because it understands what information looks like, not where specific HTML elements are.

Structured data extraction

You can ask Nemo to extract specific data from a page in a structured format. For example: "Extract all product names, prices, and star ratings from this page and list them in order of price." The agent reads the page, identifies the relevant data points using AI comprehension, and presents the results in a clean, structured format. This works on pages the agent has never seen before, without any preconfiguration.

Real web automation rarely involves a single page. Job applications span multiple pages. Government forms have multi-step wizards. E-commerce checkout flows go through cart, shipping, and payment pages. Nemo's Chrome extension supports multi-step workflows through its browser.navigate command.

The agent can navigate to URLs, follow links on the current page, and handle page transitions. Because Nemo is a multi-turn skill, the conversation persists across multiple pages. The agent remembers what it has done on previous pages and uses that context to inform its actions on subsequent ones.

Multi-step form sequences

For multi-page forms (common in government and enterprise applications), the agent fills the current page, submits it (with your approval), waits for the next page to load, reads the new form fields, and continues filling. The entire sequence is managed as a single task. You see the progress in Nemo's chat interface and approve each submission step.

Login flows

The extension can interact with login pages, but with an important distinction: Nemo does not store your third-party website passwords. If you need to access a page behind authentication, you log in manually first, and then ask Nemo to work with the authenticated page. This is a deliberate security decision — storing passwords for arbitrary websites would create a significant security risk that the convenience does not justify.

For sites where Nemo has OAuth integration (currently Google and GitHub), the authentication is handled through the Connections page with proper OAuth token management. For everything else, the browser extension approach (you log in, then Nemo automates within your authenticated session) provides the best balance of functionality and security.

Security and Privacy

Browser extensions have a complicated reputation when it comes to privacy. Many popular extensions have been caught selling browsing data, injecting ads, or tracking user behavior. Nemo's extension is designed from the ground up with the opposite approach.

What the extension does NOT do

No browsing history tracking: The extension does not monitor, record, or transmit which pages you visit. It has no background scripts that run when you are not actively using Nemo.
No data collection: There are no analytics, telemetry, or tracking pixels. The extension does not communicate with any external servers, ever.
No advertising: No ads, no affiliate links, no monetization of your browsing behavior.
No always-on monitoring: The extension only activates when Nemo sends it a command. Between commands, it sits idle. It does not read pages proactively or in the background.

What the extension DOES do for security

End-to-end encryption: Every message between the extension and Nemo uses AES-256-GCM encryption with an ephemeral session key derived from ECDH P-256 key exchange.
Local-only communication: The extension communicates exclusively with the Nemo desktop application on your local machine via Chrome's Native Messaging protocol. No data is sent to external servers.
On-demand activation: The extension only reads page content when explicitly commanded by Nemo as part of a task you initiated. It never proactively accesses your browser data.
Sentinel integration: All data received from the extension passes through Nemo's Sentinel safety layer before any action is taken. PII detection, consent enforcement, and audit logging apply to all browser interactions.

Use Cases

The Chrome extension unlocks automation for tasks that were previously impossible without writing code or paying for expensive RPA software. Here are the most common use cases:

Filling government forms

Government websites are notorious for long, repetitive forms that require entering the same personal information repeatedly. Tax forms, DMV renewals, permit applications, immigration paperwork — all require manually filling dozens of fields. With Nemo, you say "fill this form with my information," review the filled fields, and submit. Your profile data is mapped to form fields automatically. The Strategy Knowledge Base means the second time you fill the same type of government form, it is even faster.

Applying to jobs

Job applications are a particularly painful form-filling problem because every company uses a different application system. Greenhouse, Lever, Workday, Taleo, and custom ATS platforms all have different form layouts. Traditional automation breaks because selectors differ across platforms. Nemo's AI-powered form filling adapts to each platform automatically. You load the application page and say "fill this application with my resume data." The agent figures out the field mapping for each unique platform.

Extracting data from dashboards

Many business tools present data in web dashboards without export functionality. Insurance portals, HR systems, analytics dashboards, and project management tools often make you manually copy data. With the Chrome extension, you can ask Nemo to extract specific data from these dashboards and present it in a structured format, or even summarize it.

Comparison shopping

Looking for the best price across multiple retailers? Ask Nemo to read product pages on different sites and compile a comparison. The agent navigates to each page, extracts the relevant information (price, availability, shipping cost, ratings), and presents a unified comparison. No APIs needed for any of the retailers.

Automating enterprise web tools

Many enterprises run on web-based tools that have no API access for individual employees: time tracking systems, expense reporting, internal wikis, project management tools. The Chrome extension lets Nemo automate routine tasks in these systems. "Submit my timesheet for this week" or "file an expense report for this receipt" become one-sentence commands.

Comparison: Nemo Extension vs Selenium vs Playwright vs Manual

Here is how Nemo's Chrome extension stacks up against traditional browser automation approaches:

Feature	Nemo Extension	Selenium	Playwright	Manual
Coding required	None	Python/Java/JS	Python/JS/C#	None
AI-powered	Yes	No	No	No
Natural language control	Yes	No	No	N/A
Setup time	2 minutes	30+ minutes	15+ minutes	None
Adapts to site changes	Automatically	Breaks (selectors)	Breaks (selectors)	You adapt
Uses your existing browser	Yes	Separate instance	Separate instance	Yes
Bot detection risk	Low	High	Medium	None
Privacy	Encrypted, local	Local	Local	N/A
Speed (per form)	30–60 seconds	<5 seconds	<5 seconds	5–15 minutes
Cost	Free	Free (OSS)	Free (OSS)	Free (your time)

Getting Started

Setting up the Nemo Chrome extension takes about two minutes. Here is the step-by-step process:

Install Nemo if you have not already. Download from nemoagent.ai and run the installer. Nemo automatically registers the native messaging host with Chrome during installation.
Install the Chrome extension. Open the Connections page in Nemo's sidebar. Click "Connect" next to Browser Extension. This opens Chrome with the extension installation prompt. Click "Add to Chrome."
Verify the connection. Once installed, the Connections page should show "Connected" next to Browser Extension. Nemo polls the extension for status automatically.
Try your first form fill. Navigate to any web form in Chrome. Open Nemo and type "Fill out this form with my information." The agent will read the form fields, map them to your profile data, and show you a fill plan. Approve it, and watch the fields fill automatically.

If the connection does not establish, check that Chrome is running and that the extension is enabled (puzzle piece icon in the Chrome toolbar). If you see a "Native host not found" error, try restarting Nemo, which re-registers the native messaging host. Detailed troubleshooting steps are available in Nemo's Settings under Connections.

First form fill walkthrough

For your first form fill, we recommend trying a simple form like a newsletter signup or a contact form. Navigate to the form in Chrome, switch to Nemo, and type "fill this form." The agent will:

Read the page and identify all form fields.
Match fields to your profile data (name, email, phone, etc.).
Show you the fill plan with each field and its proposed value.
Ask about any fields it cannot fill automatically.
Enter the data into the form after your approval.

The entire process takes about 30–60 seconds for a typical form. More complex forms (government applications with 50+ fields) take proportionally longer but still save 10–15 minutes compared to manual filling.

Limitations and Roadmap

The Chrome extension is powerful but not without limitations. Here is an honest assessment of what it cannot do today and what we are working on:

Current limitations

CAPTCHA: The extension cannot solve CAPTCHAs. When a form includes a CAPTCHA challenge, the agent pauses and asks you to complete it manually before continuing with the rest of the form.
Heavy JavaScript SPAs: Some single-page applications render form elements using non-standard patterns (custom components, Shadow DOM, canvas-rendered inputs) that are not visible in the standard DOM. The extension works with React, Angular, and Vue components that render standard HTML inputs, but fully custom rendering engines may not be accessible.
Anti-bot protection: Some websites (particularly banking and financial sites) use aggressive bot detection that may block or interfere with the extension's interactions. This is less common than with Selenium because the extension operates within your normal Chrome session, but some advanced detection systems can identify extension-based interactions.
File uploads: The extension can detect file upload fields but cannot directly upload files from your computer. This requires the Electron file dialog, which is handled separately. The agent will ask you to select files manually for upload fields.
iframes: Content inside cross-origin iframes is not accessible to the extension due to Chrome's security policies. Some forms use iframes for payment processing or embedded third-party content, which the extension cannot read or fill.

What is on the roadmap

Shadow DOM support: Reading and interacting with Web Components that use Shadow DOM encapsulation.
Firefox extension: A Firefox version using the same Native Messaging architecture, expanding browser support beyond Chrome.
Recording mode: A "watch me do it once" mode where the extension records your manual interactions and creates a reusable recipe, useful for complex workflows where AI reasoning alone is not enough.
Multi-tab workflows: Coordinating actions across multiple browser tabs simultaneously, enabling workflows like "compare prices on these three tabs."

The web was built for humans, not APIs. The Nemo Chrome extension lets your AI agent interact with the web the same way you do — by reading what is on the page and acting on it. No APIs required. No code required. Just tell it what you want.