<div align="center">

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="docs/assets/banner-dark.svg">
  <source media="(prefers-color-scheme: light)" srcset="docs/assets/banner-light.svg">
  <img src="docs/assets/banner-dark.svg" width="100%" alt="EdgePilot banner: let AI agents drive Microsoft Edge over MCP, with an agent cursor moving between labelled tab-group workspaces">
</picture>

# EdgePilot: AI browser automation for Microsoft Edge over MCP

**EdgePilot is an MCP server and Microsoft Edge extension that lets AI agents control your browser on Windows: each chat gets a labelled tab-group workspace or its own Edge profile, you can talk to the agent from the Edge side panel, and sign-in goes through the Edge password manager without the agent ever seeing a password.**

[![Latest release](https://img.shields.io/github/v/release/AndrasBogdanAndrei/EdgePilot?color=6d5efc)](https://github.com/AndrasBogdanAndrei/EdgePilot/releases/latest)
[![Downloads](https://img.shields.io/github/downloads/AndrasBogdanAndrei/EdgePilot/total?color=4f8bff)](https://github.com/AndrasBogdanAndrei/EdgePilot/releases)
[![License: PolyForm Noncommercial](https://img.shields.io/badge/license-PolyForm%20Noncommercial%201.0.0-6d5efc)](LICENSE.md)
![Platform: Windows 10 | 11](https://img.shields.io/badge/platform-Windows%2010%20%7C%2011-4f8bff)
![Browser: Microsoft Edge](https://img.shields.io/badge/browser-Microsoft%20Edge-22c3d6)
![Protocol: MCP](https://img.shields.io/badge/protocol-MCP-8b7dff)
[![GitHub stars](https://img.shields.io/github/stars/AndrasBogdanAndrei/EdgePilot?style=flat&color=22c3d6)](https://github.com/AndrasBogdanAndrei/EdgePilot/stargazers)

[**Project page**](https://andrasbogdanandrei.github.io/EdgePilot/) ·
[**Download the latest release**](https://github.com/AndrasBogdanAndrei/EdgePilot/releases/latest) ·
[Quick start](#quick-start) ·
[MCP tools](#mcp-tools) ·
[FAQ](#faq)

</div>

<p align="center">
  <img src="docs/assets/demo.svg" width="100%" alt="Animated EdgePilot demo built from real screenshots: labelled tab-group workspaces in Microsoft Edge, the side panel chat, workspaces and activity views, the sign-in approval window and the on-page indicator">
</p>

<p align="center">
  <img src="docs/screenshots/panel-chat-dark.png" width="250" alt="EdgePilot side panel: chat with the AI agent working in the research workspace (dark theme)">
  <img src="docs/screenshots/panel-workspaces-light.png" width="250" alt="EdgePilot side panel: list of agent workspaces with live and idle state (light theme)">
  <img src="docs/screenshots/panel-activity-dark.png" width="250" alt="EdgePilot side panel: activity timeline of every agent action (dark theme)">
</p>

## Contents

- [Features](#features)
- [Quick start](#quick-start)
- [Workspaces and accounts](#workspaces-and-accounts)
- [Chat with your agent](#chat-with-your-agent)
- [Sign in with Edge's password manager](#sign-in-with-edges-password-manager)
- [On-page indicator](#on-page-indicator)
- [MCP tools](#mcp-tools)
- [Configuration](#configuration)
- [How it works](#how-it-works)
- [Privacy and safety](#privacy-and-safety)
- [FAQ](#faq)
- [How EdgePilot compares to other browser MCP servers](#how-edgepilot-compares-to-other-browser-mcp-servers)
- [Troubleshooting](#troubleshooting)
- [Development](#development)
- [Contributing, security and support](#contributing-security-and-support)
- [License](#license)

<p align="center"><img src="docs/assets/divider.svg" width="100%" alt=""></p>

## Features

| | |
|---|---|
| <img src="docs/assets/icon-workspaces.svg" width="44" alt=""><br>**Workspaces that stay** | Every chat works in its own Edge tab group, labelled with the chat's name. The label survives Edge restarts, so tomorrow's chat in the same project picks up the same tabs. Rename a group in Edge and the workspace follows. |
| <img src="docs/assets/icon-profiles.svg" width="44" alt=""><br>**Accounts your way** | Keep every chat in one Edge with your usual sign-ins (**labels** mode), or give a chat its own **separate Edge profile** with separate cookies, accounts and history, started automatically. Several chats can share one profile and stay signed in to the same account at the same time. |
| <img src="docs/assets/icon-chat.svg" width="44" alt=""><br>**Talk to your agent from Edge** | The side panel has a chat per workspace. Messages reach the agent live as channel events (where your client supports them) or with its next action; the agent answers back into the panel and as an Edge notification. |
| <img src="docs/assets/icon-password.svg" width="44" alt=""><br>**Edge passwords, never exposed** | `autofill_credentials` asks you in an Edge window first; then Edge's own password manager fills the login. Password values are masked in everything the agent can read. |
| <img src="docs/assets/icon-stop.svg" width="44" alt=""><br>**You stay in control** | Pause all agents, stop a single workspace, or press **Stop** on the glowing on-page indicator. Block sites entirely. Every action is in the activity timeline. |
| <img src="docs/assets/icon-light.svg" width="44" alt=""><br>**Light on your PC** | The debugger detaches from idle tabs after 45 s so Edge throttles them normally again; the UI uses short, one-shot animations and honours "reduce motion". |
| <img src="docs/assets/icon-tools.svg" width="44" alt=""><br>**38 tools** | Trusted mouse/keyboard input, screenshots (viewport, full page, element), accessibility tree with stable refs, tables and links extraction, console and network capture, device/dark-mode/network emulation, PDF export, dialogs, downloads, favorites, history, and more. |
| <img src="docs/assets/icon-plug.svg" width="44" alt=""><br>**Any MCP client** | A standard stdio MCP server (protocol versions 2024-11-05, 2025-03-26 and 2025-06-18) with no npm dependencies, only Node.js 22 or newer. |
| <img src="docs/assets/icon-languages.svg" width="44" alt=""><br>**English and Romanian** | The extension interface is localized in English and Romanian. |

<p align="center"><img src="docs/assets/divider.svg" width="100%" alt=""></p>

## Quick start

**Requirements:** Windows 10/11, Microsoft Edge, [Node.js](https://nodejs.org) 22 or newer (the installer offers to install it with winget).

### 1. Get EdgePilot

Either run the one-line installer in PowerShell:

```powershell
irm https://raw.githubusercontent.com/AndrasBogdanAndrei/EdgePilot/main/install.ps1 | iex
```

or download `EdgePilot-<version>.zip` from [Releases](https://github.com/AndrasBogdanAndrei/EdgePilot/releases), unzip it and **double-click `install.cmd`**.

The installer registers the bridge for Edge (current user only), connects the MCP clients it finds, copies the extension folder path to your clipboard and waits until Edge connects.

> **Run the installer yourself, from Explorer or a normal terminal.** Some desktop apps run their terminals in a packaged (MSIX) sandbox with a private copy of the registry, and Edge would not see a bridge registered from there.

### 2. Load the extension in Edge

In every Edge profile you want agents to use:

1. Open `edge://extensions`
2. Turn on **Developer mode**
3. **Load unpacked** → paste the path (<kbd>Ctrl</kbd>+<kbd>V</kbd>) → **Select folder**

Separate-profile mode needs nothing else: EdgePilot starts those profiles with the extension already loaded.

### 3. Connect your MCP client

The installer adds EdgePilot to the Claude Code CLI automatically when it finds it. For other clients (Cursor, VS Code, Windsurf, …) add a stdio server:

```json
{
  "mcpServers": {
    "edgepilot": {
      "command": "node",
      "args": ["C:\\Users\\you\\EdgePilot\\mcp\\server.js"]
    }
  }
}
```

Start a new chat and ask it to use Edge.

To remove EdgePilot later, run `uninstall.cmd` and remove the extension in `edge://extensions`. Settings and separate profiles stay in `%USERPROFILE%\.edgepilot` unless you run `uninstall.cmd --purge`.

<p align="center"><img src="docs/assets/divider.svg" width="100%" alt=""></p>

## Workspaces and accounts

<img src="docs/screenshots/window-workspaces.png" alt="Three AI agent chats working in one Microsoft Edge window, each in its own labelled tab group: research, docs-site and shop-checkout">

*Three chats in one Edge window: `research`, `docs-site` and `shop-checkout` each own a labelled tab group. The pill at the bottom right shows which chat is using the page.*

| You want | Do this |
|---|---|
| Every chat in your normal Edge, each in its own labelled tab group | Default (**labels** mode). The label is the project folder name; a second chat in the same folder gets `name 2`. |
| A specific label | `EDGEPILOT_LABEL=client-x` in the MCP server environment, or ask the agent to call `workspace` with `use {name}`. |
| A chat with its own cookies and accounts | Set **New chats → Separate profile** in the panel's settings, or `EDGEPILOT_MODE=profile`, or `workspace use {name, mode: "profile"}`. The profile lives in `%USERPROFILE%\.edgepilot\profiles\<name>` and keeps its sign-ins for next time. |
| The same account in several chats at once | Use labels mode on one Edge profile. All chats share its sign-ins. |
| A different regular Edge profile (e.g. Work) | Load the extension there, then `select_browser` or `launch_edge_profile`, or set `EDGEPILOT_PROFILE=Work`. |
| A throwaway, signed-out context | `tabs_create` with `inprivate: true` (enable *Allow in InPrivate* for EdgePilot). |

## Chat with your agent

Open the panel (click the EdgePilot icon or press <kbd>Alt</kbd>+<kbd>Shift</kbd>+<kbd>E</kbd>), pick a workspace and write.

- **Live delivery.** EdgePilot declares the `claude/channel` capability, so clients that support MCP channel events receive your message immediately as a `<channel source="edgepilot" workspace="…" message_id="…">` event. In Claude Code this is a research preview and is enabled per session with:
  ```
  claude --dangerously-load-development-channels server:edgepilot
  ```
- **Always works.** Messages the agent has not seen yet are attached to its next tool result, and it can call `chat_read`.
- **Replies.** The agent answers with `chat_send`; you see it in the panel and as an Edge notification.

## Sign in with Edge's password manager

<p>
  <img src="docs/screenshots/approval-dark.png" width="300" alt="EdgePilot sign-in approval window: allow or deny the agent filling a saved login from the Edge password manager">
  <img src="docs/screenshots/ask-light.png" width="300" alt="EdgePilot ask_user window: the agent asks you a question with buttons and a text box">
</p>

1. The agent calls `autofill_credentials`. EdgePilot finds the username and password fields.
2. You approve in an Edge window the agent cannot click, choosing the first saved login or picking the account yourself.
3. Edge fills the fields from its password manager. If Edge asks for Windows Hello or your PIN, you confirm there.
4. The agent only learns *that* the fields were filled. Password values are masked in `read_page`, `javascript_tool`, console, network and storage output.

For CAPTCHAs, 2FA codes or decisions, the agent uses `ask_user`, which shows a question with buttons and/or a text box.

## On-page indicator

<img src="docs/screenshots/indicator.png" width="720" alt="EdgePilot on-page indicator: a glowing frame and a Stop button on the web page the AI agent is controlling">

While an agent acts on a page, a soft glow in the workspace's color and a pill with a **Stop** button appear for a few seconds, then disappear completely.

<p align="center"><img src="docs/assets/divider.svg" width="100%" alt=""></p>

## MCP tools

EdgePilot exposes 38 MCP tools (defined in [`mcp/tools.js`](mcp/tools.js)):

| Area | Tools |
|---|---|
| Workspaces & browsers | `workspace`, `list_connected_browsers`, `select_browser`, `list_edge_profiles`, `launch_edge_profile`, `browser_batch` |
| Tabs & navigation | `tabs_context`, `tabs_create`, `tabs_select`, `tabs_close`, `navigate` |
| Input & vision | `computer` (clicks, typing, keys, drag, scroll, screenshot, full-page/element screenshot, zoom, wait), `highlight` |
| Reading | `read_page`, `find`, `get_page_text`, `get_links`, `extract_tables` |
| Forms & scripting | `form_input`, `javascript_tool`, `page_storage`, `file_upload`, `wait_for`, `handle_dialog` |
| Debugging & testing | `read_console_messages`, `read_network_requests`, `block_urls`, `emulate`, `performance_metrics`, `resize_window`, `save_pdf` |
| Edge features | `autofill_credentials`, `downloads`, `bookmarks`, `history_search` |
| Talking to you | `ask_user`, `chat_send`, `chat_read` |

<details>
<summary>What each tool does</summary>

| Tool | Description |
|---|---|
| `workspace` | This chat's workspace: info, list, use `{name, mode}`, rename, close tabs. `mode` is `labels` (tab group in a shared profile) or `profile` (its own Edge profile). |
| `list_connected_browsers` | Edge profiles that have EdgePilot connected, and which one this chat uses. |
| `select_browser` | Choose which connected Edge profile this chat drives. |
| `list_edge_profiles` | Every regular Edge profile on the computer plus EdgePilot's per-chat profiles, with connection state. |
| `launch_edge_profile` | Open a regular Edge profile, wait for EdgePilot to connect there and select it. |
| `browser_batch` | Run several tool calls in sequence in one round trip; stops on the first error. |
| `tabs_context` | List the tabs of this workspace (optionally open one if there is none). |
| `tabs_create` | Open a tab in this workspace, optionally in an InPrivate window. |
| `tabs_select` / `tabs_close` | Make a tab current and show it / close a tab of this workspace. |
| `navigate` | Go to a URL, or back, forward, reload (optionally bypassing the cache). Waits for the load. |
| `computer` | Trusted mouse and keyboard input and screenshots: clicks, hover, drag, type, key chords, scroll, zoom, wait, full-page and element screenshots. |
| `highlight` | Highlight an element for a few seconds to point something out. |
| `read_page` | Accessibility-style tree with `[ref_N]` ids for interactive elements. Password values are never shown. |
| `find` | Find up to 20 elements by role, name or text. |
| `get_page_text` | Visible text of the page, main or article content first. |
| `get_links` | Visible links (text, URL, ref), optionally filtered. |
| `extract_tables` | HTML tables as Markdown. |
| `form_input` | Set an input, textarea, select, checkbox, radio or contenteditable by ref. |
| `javascript_tool` | Run JavaScript in the page; top-level `await` works. Password values are masked. |
| `page_storage` | Read or change `localStorage` / `sessionStorage` of the page's origin. |
| `file_upload` | Put local files into a file input. |
| `wait_for` | Wait for text, a visible selector, a URL substring and/or network idle (or for them to disappear). |
| `handle_dialog` | Accept or dismiss alert, confirm, prompt and beforeunload dialogs. |
| `read_console_messages` | Console output and uncaught exceptions of a tab. |
| `read_network_requests` | Network requests of a tab, or one response body. |
| `block_urls` | Block requests that match URL patterns, such as ads or analytics. |
| `emulate` | Emulate a device size, dark or light color scheme, network speed or offline, geolocation, timezone or locale. |
| `performance_metrics` | Load timing (TTFB, FCP, LCP, CLS), resource counts and runtime metrics. |
| `resize_window` | Resize the window of a tab. |
| `save_pdf` | Save the page as a PDF file. |
| `autofill_credentials` | Sign in with a login saved in the Edge password manager, after your approval. The values never reach the agent. |
| `downloads` | List recent downloads, start one or wait for one. |
| `bookmarks` | Search, list or add Edge favorites. |
| `history_search` | Search the Edge browsing history of this profile. |
| `ask_user` | Ask you something in an Edge popup (buttons and/or free text) and wait for the answer. |
| `chat_send` / `chat_read` | Send a message to the side panel chat of this workspace / read new messages you wrote there. |

</details>

## Configuration

Set these in the environment of the MCP server (for example in your MCP client's server config) when you need them:

| Variable | Effect |
|---|---|
| `EDGEPILOT_LABEL` | Workspace label for this chat. Default: the name of the current folder. |
| `EDGEPILOT_MODE` | `labels` (default) or `profile` for a separate Edge profile per chat. |
| `EDGEPILOT_PROFILE` | Which connected Edge profile to use when several are connected (name, folder or account). |
| `EDGEPILOT_HOME` | EdgePilot's data folder. Default: `%USERPROFILE%\.edgepilot`. |
| `EDGEPILOT_EDGE_USER_DATA` | Edge's user data folder, used to list your Edge profiles. Default: `%LOCALAPPDATA%\Microsoft\Edge\User Data`. |

The default mode for new chats can also be set in the side panel under **Settings → New chats**.

<p align="center"><img src="docs/assets/divider.svg" width="100%" alt=""></p>

## How it works

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="docs/assets/how-it-works-dark.svg">
  <source media="(prefers-color-scheme: light)" srcset="docs/assets/how-it-works-light.svg">
  <img src="docs/assets/how-it-works-dark.svg" width="100%" alt="How EdgePilot works: AI chat to MCP server over stdio, MCP server to bridge over a named pipe with a token, bridge to the Edge extension over native messaging, extension to labelled tab groups over the DevTools protocol; the side panel chat sends your messages to the extension">
</picture>

<details>
<summary>The same diagram as text</summary>

```mermaid
flowchart LR
  A1[Chat 1] -- stdio --> M1[MCP server]
  A2[Chat 2] -- stdio --> M2[MCP server]
  M1 -- named pipe + token --> B[Bridge<br/>one per Edge profile]
  M2 -- named pipe + token --> B
  B -- native messaging --> E[EdgePilot extension]
  E -- DevTools protocol<br/>scripting, tabs --> T[Tabs in labelled<br/>tab groups]
  P[Side panel chat] --> E
```

</details>

- Each chat starts its own MCP server ([`mcp/server.js`](mcp/server.js)); each Edge profile with the extension starts its own bridge ([`bridge/host.js`](bridge/host.js), registered as the native messaging host `com.edgepilot.bridge`).
- The extension ([`extension/`](extension)) is a Manifest V3 extension that uses the `chrome.debugger` (DevTools protocol), `scripting`, `tabs` and `tabGroups` APIs.
- Bridges listen on a local named pipe protected by a random token stored in `%USERPROFILE%\.edgepilot`. No network ports are opened. The only exception: when a separate profile is created, a local DevTools port is open for a few seconds to turn on developer mode in that profile, then closed with that browser.
- Nothing leaves your computer except the pages you visit.

## Privacy and safety

- Password values are never returned to the agent. Approvals and questions appear in Edge windows the agent cannot click.
- Blocked sites cannot be read or controlled, including their subdomains and history entries.
- **Pause** stops all agents; **Stop** stops one workspace; Edge's "is being debugged" bar shows which tabs are attached.
- Internal pages (`edge://`, the add-ons store, the PDF viewer) cannot be controlled.
- EdgePilot itself sends nothing to a server, but page content the agent reads is passed to your MCP client, which sends it to the AI model it uses. Block sites you never want an agent to see.

<p align="center"><img src="docs/assets/divider.svg" width="100%" alt=""></p>

## FAQ

### How do I let an AI agent control Microsoft Edge?

Install EdgePilot (run `install.cmd` or the one-line PowerShell installer), load the `extension` folder in `edge://extensions` with **Developer mode → Load unpacked**, and add EdgePilot to your MCP client as a stdio server. Then start a new chat and ask the agent to use Edge. It opens its own labelled tab group and works there.

### Which AI agents and MCP clients work with EdgePilot?

Any client that can start a local stdio MCP server, for example Cursor, VS Code, Windsurf or a command-line coding agent. EdgePilot answers MCP protocol versions 2024-11-05, 2025-03-26 and 2025-06-18.

### Does the AI agent see my passwords?

No. `autofill_credentials` asks for your approval in an Edge window the agent cannot click, and then Edge's own password manager fills the fields. The agent only learns that the fields were filled. Password values are masked in page reads, scripts, console, network and storage output.

### Can each AI chat use a different Edge profile or account?

Yes. In **profile** mode every chat gets its own Edge profile with separate cookies, accounts and history, stored under `%USERPROFILE%\.edgepilot\profiles\<name>`. In **labels** mode chats share one Edge profile and its sign-ins, each in its own tab group. You can also point a chat at one of your regular Edge profiles with `select_browser` or `launch_edge_profile`.

### Do workspaces survive an Edge restart?

Yes. A workspace is a labelled Edge tab group, and the label stays in Edge after restarts. The next chat with the same label picks up the same tabs.

### How do I stop an agent?

Press **Stop** on the on-page indicator, stop one workspace in the side panel, or **Pause all agents**. You can also block sites in **Settings → Blocked sites** so agents cannot read or control them.

### Does EdgePilot work with Google Chrome, macOS or Linux?

No. EdgePilot is built for Microsoft Edge on Windows 10 and 11: the installer registers the bridge in Edge's native messaging registry key and the bridge uses Windows named pipes.

### Does EdgePilot send my data anywhere?

EdgePilot opens no network ports and talks to the MCP server over a local named pipe protected by a token. What the agent reads from a page goes to your MCP client and the AI model it uses, as with any browser tool for agents.

### Is EdgePilot free?

It is free for any noncommercial use under the [PolyForm Noncommercial License 1.0.0](LICENSE.md). For commercial use, [open an issue](https://github.com/AndrasBogdanAndrei/EdgePilot/issues) to ask for a license.

## How EdgePilot compares to other browser MCP servers

There are several ways to give an AI agent a browser. General-purpose projects such as [Playwright MCP](https://github.com/microsoft/playwright-mcp) and [Chrome DevTools MCP](https://github.com/ChromeDevTools/chrome-devtools-mcp) are cross-platform MCP servers built on Playwright or the Chrome DevTools Protocol, and are a good fit for testing and scripted automation; see their documentation for their current features.

EdgePilot is narrower and focuses on using your everyday Microsoft Edge on Windows:

| EdgePilot | |
|---|---|
| Browser | Microsoft Edge only, through an Edge extension and a native messaging bridge |
| Platform | Windows 10 and 11 |
| Where the agent works | In your own Edge profiles, in a labelled tab group per chat, or in a separate Edge profile per chat |
| Several chats at once | Yes, each in its own workspace, with a pill on the page showing which chat is using it |
| Sign-in | Approved autofill from the Edge password manager; password values are masked from the agent |
| Talking to the agent | Side panel chat per workspace, `ask_user` popups, Edge notifications |
| License | PolyForm Noncommercial 1.0.0 |

## Troubleshooting

| Problem | Fix |
|---|---|
| Panel says *Offline* or `native messaging host not found` | Run `install.cmd` yourself (double-click), then reload the extension. |
| A chat says *Several Edge profiles are connected* | Call `select_browser`, or set `EDGEPILOT_PROFILE`. |
| Screenshots time out | The window is minimized. EdgePilot brings covered windows forward, but not minimized ones. |
| `file_upload` fails | Enable *Allow access to file URLs* for EdgePilot in `edge://extensions`. |
| A separate profile does not connect | EdgePilot repairs it automatically once; if it still fails, delete `%USERPROFILE%\.edgepilot\profiles\<name>`. |

## Development

```
node installer/install.js --no-mcp   # register the bridge only
node test/e2e.js                     # 63 checks against a running Edge with EdgePilot
node installer/package.js            # build dist/*.zip
```

Run the tests against a throwaway profile:

```
msedge --user-data-dir=%TEMP%\edgepilot-test --load-extension=<repo>\extension --disable-sync --no-first-run
```

Without `--disable-sync`, a new Edge profile signs in with your Windows Microsoft account and syncs your real passwords.

Project layout:

| Folder | Contents |
|---|---|
| [`extension/`](extension) | The Manifest V3 Edge extension: service worker, side panel, approval and question windows, page agent |
| [`bridge/`](bridge) | Native messaging host that connects Edge to the MCP servers |
| [`mcp/`](mcp) | The stdio MCP server and its tool definitions |
| [`shared/`](shared) | Paths, names and instance discovery shared by all parts |
| [`installer/`](installer) | Install, uninstall, icon and release packaging scripts |
| [`test/`](test) | End-to-end tests |

<p align="center"><img src="docs/assets/divider.svg" width="100%" alt=""></p>

## Contributing, security and support

- [Contributing guide](CONTRIBUTING.md): how to report bugs, propose changes and test safely.
- [Security policy](SECURITY.md): how to report a vulnerability privately.
- [Support](SUPPORT.md): where to ask for help.
- [Code of conduct](CODE_OF_CONDUCT.md).

If EdgePilot is useful to you, a star on GitHub helps other people find it.

## License

EdgePilot is © 2026 Andras Bogdan Andrei and licensed under the [PolyForm Noncommercial License 1.0.0](LICENSE.md). You may use, study and modify it for any noncommercial purpose. For commercial use, [open an issue](https://github.com/AndrasBogdanAndrei/EdgePilot/issues) to ask for a license.

Microsoft Edge is a trademark of Microsoft Corporation. EdgePilot is an independent project and is not affiliated with or endorsed by Microsoft or any AI vendor.

---

### Pe scurt, în română

EdgePilot lasă agenții AI să controleze Microsoft Edge prin MCP. Fiecare chat are un grup de tab-uri etichetat, care rămâne permanent în Edge. Opțional, fiecare chat poate primi un profil Edge separat, cu conturi separate. Din panoul lateral poți vorbi cu agentul. Autentificarea folosește managerul de parole Edge, cu aprobarea ta, iar parola nu ajunge niciodată la agent. Instalare: rulează `install.cmd`, apoi încarcă folderul `extension` din `edge://extensions` (Modul dezvoltator → Încărcare despachetată).