Peerd brings the first AI agent native to your browser, no cloud needed

peerd is the first AI agent browser extension that runs a full agent loop natively inside Chrome and Firefox—not just driving tabs or scraping pages, but managing sandboxed compute (JavaScript notebooks, WebAssembly Linux VMs, even full client-side apps) and sharing results directly over peer-to-peer WebRTC links. It ships with zero backend, zero telemetry, and lets you bring your own API keys for model access—meaning your prompts, data, and results never leave your machine unless you explicitly share them. This isn’t another cloud-tethered assistant or half-baked local wrapper; this is a new substrate for client-side AI agents and peer-to-peer computing, designed around privacy, user control, and the hard-won security guarantees already baked into modern browsers. In this deep dive, I’ll break down how peerd builds on hardened browser primitives, how its agent loop and data partitioning model work, where it’s strong (and rough), and how to use the developer preview in your own browser right now.

What is peerd? An overview of the AI agent browser extension

peerd is an experimental browser extension for Chrome and Firefox that runs a full AI agent harness entirely in your browser. Unlike server-dependent AI tools, peerd's core loop operates within your active tabs, using your local sessions to drive automation and computation with zero cloud in the loop. Its core innovation is a BYOK (Bring Your Own Key) architecture: you provide the API key for your preferred model provider, keeping credential management local and under your control.

Where most agents operate via APIs or cloud orchestration, peerd hosts the agent loop on your desktop, reading and driving your own tabs, spinning up compute sandboxes on demand, and (if you opt in) sharing code and artifacts peer-to-peer—no central coordination, no forced cloud. The extension promises no telemetry or backend data collection, a hard departure from almost every contemporaneous AI tool.

peerd’s current status is "0.x, experimental beta" and the initial feature buildout is available now for developer preview. It’s not a polished product: breaking changes are expected, the UI and capabilities are still evolving, and you should treat it like any early-stage OSS beta—use with eyes open, but this is the first real look at a privacy-respecting, browser-native AI agent running on the open web.

How does peerd work? The technology behind the browser-native AI agent

The guts of peerd are a browser extension running a full agent loop inside the tab context. This loop can read pages, interact with the DOM, and control browser automation—everything from filling forms to running agent code inside an isolated VM. What sets peerd apart is where and how it handles code execution, data partitioning, and networking.

Sandboxed compute environments:
peerd can spin up JavaScript notebooks or even entire Linux VMs compiled to WebAssembly, running directly inside your browser. These sandboxes are isolated from your main agent via well-established browser primitives:

• V8 isolates: Used to ensure compute tasks run in strictly partitioned memory areas.
• WebCrypto: Handles secure credential storage (your API keys) in a vault-like fashion.
• WebAuthn passkeys: Used to enable your vault, piggybacking on what browsers already do well.
• Opaque-origin iframes & Subresource Integrity: Sandboxing runner VMs and agent code, verifying integrity of fetched assets, and fencing off code that originates outside your direct control.

Partitioning sensitive data and actions:
peerd’s model deliberately separates the agent (that holds your API keys and logic) from disposable runners (that execute code, process untrusted content, or scrape pages). These runners:

• Never have access to your keys or network directly.
• Can’t read the page except through brokered, strictly delimited interfaces.
• Produce output that’s always fenced as untrusted—subject to verification before any further action.

Each automation step is checked against the live page before peerd considers it "done," reducing the danger of silent failure or injection.

Peer-to-peer WebRTC networking:
peerd’s experimental dweb (decentralized web) preview enables agent-to-agent communication directly over encrypted WebRTC. This lets you share artifacts, code, or even agent state directly between browsers, sidestepping any server dependency. It’s not the default install on web stores, but included in research previews and signed GitHub releases.

All told, peerd builds on decades of browser security architecture rather than inventing risky cryptography or process isolation: no rolling your own crypto, no naive sandboxing. The tradeoff is that you get hardened pathways, with the browser’s own patch cadence and security history as your defense.

What are the benefits of using peerd? Privacy, control, and flexibility

peerd’s foundational advantage is that nothing leaves your browser unless you say so. There’s no backend, telemetry, or forced cloud syncing—not in the agent loop, not in the data path, not buried in a “diagnostics” toggle.

• Privacy: All agent computation, prompt handling, and model usage run on your machine, within your browser context.
• Security: The extension rides on the security model already enforced in Chrome and Firefox—sandboxed execution, WebCrypto vaults, and passkey enabling.
• Flexibility: With BYOK, you choose your model provider—no vendor lock-in, no dubious cloud costs or restrictions.
• Peer-to-peer collaboration: The preview mode enables direct WebRTC-based artifact sharing with no central node, pushing toward a truly decentralized AI agent environment.
• Open source: The code is auditable, the extension is experimental by design, and nothing is hidden.

The upshot: peerd gives you fine-grained control over where your data, compute, and agent code run.

How do I use peerd today? Step-by-step guide

1. Get the extension:
The current (0.x) developer preview requires manual installation from the GitHub repo. Browser store submissions (Chrome Web Store, Firefox Add-ons) are pending approval—once live, those versions will be the recommended install for most users.

2. Install in your browser:

• Manual for developers: Clone/download the repo, then load it as an unpacked extension inside Chrome or Firefox.
• Store installers (coming soon): Will be listed on peerd.ai and in the README.

3. Activate the extension:

• Enable the extension in your browser settings.
• Open the peerd UI via the browser button.

4. Configure your key (BYOK):

• In the peerd setup flow, provide the API key from your preferred large language model provider (e.g., OpenAI, Cohere, others as supported).
• Your keys are vaulted locally using WebCrypto and only unlocked with a per-browser WebAuthn passkey; they never leave your machine.

5. Run a sandboxed compute environment:

• Choose between launching a JS notebook or spinning up a full WebAssembly Linux VM.
• Code and computation run entirely within the sandboxed environment of your browser tab.
• For notebooks: type and execute JavaScript on your data directly.
• For WASM Linux VM: experiment with more advanced workflows or apps, entirely in-browser.

6. Try peer-to-peer artifact sharing (optional):

• If you use the research preview, the dweb layer is enabled.
• Open the peer sharing UI. peerd will use WebRTC to discover and connect to other peerd instances (browsers) and can share code, artifacts, or VM snapshots directly—no relay server, no cloud dependency.

7. Safety tip:

• peerd is "0.x experimental beta" software. It drives tabs and holds credentials, so review the source and only use it in environments you control.
• Expect breaking changes, evolving APIs, and migration risks—this is not production-ready by default.

# Example: Developer install
git clone 
# Load as 'unpacked extension' in Chrome/Firefox (see browser docs)

What are the current limitations and future roadmap for peerd?

peerd is firmly in the "experimental beta" (0.x) phase. There’s no guaranteed backward compatibility—storage formats, APIs, and surface features can shift between minor releases. If you start using it seriously, expect to keep up with changelogs and deal with migrations or breaking changes.

Known limitations:

• No "V1" stability guarantee yet: features are complete for initial testing, but there’s a high chance of reorgs and API shifts.
• Some advanced capabilities (like the dweb peer layer, full dweb apps) are only available in signed preview builds, not in web store releases.
• Agent sandboxes are limited to JS notebooks and WASM Linux VMs for now—more types may arrive, but the focus is on reliability before breadth.
• Security reviews are ongoing; peerd deliberately avoids writing its own isolation or crypto, but until adoption expands, expect a fast-moving surface.

Roadmap highlights:

• Polished install paths via Chrome/Firefox store
• Additional compute sandbox formats and richer agent-to-agent interaction
• Automatic migration tooling for user data and agent state when the APIs stabilize
• Broader security/community auditing as usage grows

The bet is that a browser-native agent harness can keep up with the surface changes, run under real browser defenses, and stay nimble alongside the cloud-native agent world.

How does peerd compare to other AI agent platforms?

peerd’s decisive break with most agents is running 100% inside the browser, with no backend and no telemetry by default.

† Only in preview/dweb builds

Compared to purely-cloud services, peerd wins on privacy, inspection, and user control—nothing gets sent server-side unless you explicitly use the P2P path, and even then it’s only with other explicit peerd users, device-to-device.

Privacy and Trust: The agent loop never leaves your machine. There are no third-party analytics, session replays, or data harvesting embedded by default.

Compute Power and Breadth: You’re capped by the browser sandbox—no GPU offload, raw compute is what your desktop offers, and the isolation is what your browser enforces. For heavy jobs, peerd is not your cloud replacement; for flexible, private agenting, it’s a real platform.

Peer-to-peer: Very few (if any) established AI browser agents support direct, serverless peer artifact/code sharing over WebRTC. This is where peerd pushes out the frontier.

Proprietary tools often ship more user-friendly UIs and stitch together deep cloud integrations. peerd picks the opposite trade—open, hackable, secure by architecture, and tuned for users who want to own the stack.

The bottom line: browser AI agents with privacy and power, in your hands

peerd is an early but decisive move toward putting AI agent power wholly inside your browser—no cloud, no centralized telemetry, and full end-user control over keys, data, and compute. The tech is real, the boundaries are clear, and—while rough at the edges—this is the first time a developer can run agent loops, spin up Linux VM sandboxes, and share results peer-to-peer, all local-first and open source. If you want to experiment with the future of browser-native, privacy-respecting AI agents, grab the peerd beta and see how far local-first can go.