[opensourcedex]

openbrowserclaw is a free, open source ai interaction & interfaces project written in TypeScript and released under MIT. It has 604 GitHub stars, 82 forks and 11 open issues, and was last pushed 8 months ago. On this registry it ranks #147 of 156 tracked projects in AI Interaction & Interfaces, with 5 head-to-head comparisons available. It gained 2 stars over the last 30 tracked days.

What is openbrowserclaw?

OpenBrowserClaw is an MIT-licensed TypeScript personal AI assistant that runs entirely inside a browser tab, built for a single user who wants an AI agent without operating any server infrastructure.

What it is

OpenBrowserClaw is a personal AI assistant that lives in a Progressive Web App. The chat UI, settings, and task manager all run in one browser tab, with an orchestrator on the main thread handling the message queue, routing, a three-state machine (idle, thinking, responding), and a cron task scheduler. A Web Worker runs the Claude API tool-use loop. IndexedDB holds messages, sessions, tasks, and configuration, while OPFS provides per-group file storage. Stored credentials are encrypted with AES-256-GCM.

The README describes the project as a browser-only reimagination of NanoClaw: the same philosophy, small enough to understand, built for one user. The concrete problem it solves is infrastructure. Instead of provisioning a host, a database, a filesystem, and a process supervisor for an agent that serves one person, OpenBrowserClaw replaces that stack with browser primitives: IndexedDB for persistence, OPFS for files, a Web Worker for the agent loop, and a v86-emulated Alpine Linux in WebAssembly for sandboxed shell execution. The browser is the server.

Key capabilities

  • Two message channels: a built-in browser chat and an optional Telegram Bot API channel that works purely over HTTPS, with no WebSockets or special protocols.
  • Tool set exposed to Claude covers bash, javascript, read_file, write_file, list_files, fetch_url, update_memory, and create_task.
  • The bash tool runs commands in a v86-emulated Alpine Linux in WASM through the WebVM wrapper in src/vm.ts.
  • Persistent context is written to CLAUDE.md through update_memory and reloaded on every conversation.
  • Recurring work is scheduled with create_task using cron expressions, evaluated in src/task-scheduler.ts.
  • Credentials are encrypted at rest with AES-256-GCM in src/crypto.ts.
  • The interface ships as an installable PWA, so the assistant can be launched from the desktop or home screen.

Who uses it and how

  • Individual operators who want a personal agent but do not want to rent a VPS or run a container platform; the whole deployment is a browser tab.
  • People who want to reach the same assistant from a phone: messages sent to a bot created with @BotFather are processed identically to browser chat, with the chat ID added in Settings.
  • Anyone who needs scheduled agent work, such as recurring fetches or file updates, driven by cron tasks while the tab is open.
  • Users handling more than one working context, since OPFS file storage is scoped per group.

Getting started

Install and run locally with npm install and npm run dev, then open http://localhost:5173 and paste an Anthropic API key in Settings. A hosted instance is available at https://openbrowserclaw.com.

How it compares

The facts name one comparable project: NanoClaw, which OpenBrowserClaw reimagines as a browser-only build. Where NanoClaw needs a machine to run on, OpenBrowserClaw confines the same single-user assistant model to a browser tab. No other similar project is named in this registry entry.

When to use it — and when not to

There is no database, object store, or SMTP server to operate, but the trade-offs are real: the tab must stay open for the Telegram bot to respond, with messages queueing on Telegram's side until it is reopened; fetch_url is subject to CORS; and the optional bash sandbox requires manually downloading the v86 WASM binary and an Alpine rootfs image into public/assets/. Anyone who needs an always-on agent, multiple users, or a server-side agent loop should not pick this, because the design targets one user and stops when the tab closes. The README also carries a disclaimer that the project is not affiliated with any cryptocurrency, token, or social media account claiming association with it.

project readme (upstream, from github) — read inline

OpenBrowserClaw

Disclaimer: OpenBrowserClaw is a personal, open-source project. It is not affiliated with any cryptocurrency, meme coin, token, or social media account. If you see coins, tokens, or social media profiles claiming association with this project, they are not legitimate and are not endorsed by the author(s). Stay safe and do your own research.

Browser-native personal AI assistant. Zero infrastructure — the browser is the server.

Built as a browser-only reimagination of NanoClaw. Same philosophy, small enough to understand, built for one user, but running entirely in a browser tab.

Quick Start

cd openbrowserclaw
npm install
npm run dev

Open http://localhost:5173, paste your Anthropic API key, and start chatting.

Architecture

┌──────────────────────────────────────────────────────────┐
│  Browser Tab (PWA)                                       │
│                                                          │
│  ┌──────────┐  ┌──────────┐  ┌────────────────────────┐  │
│  │ Chat UI  │  │ Settings │  │ Task Manager           │  │
│  └────┬─────┘  └─────┬────┘  └───────┬────────────────┘  │
│       └──────────────┼───────────────┘                   │
│                      ▼                                   │
│              Orchestrator (main thread)                  │
│              ├── Message queue & routing                 │
│              ├── State machine (idle/thinking/responding)│
│              └── Task scheduler (cron)                   │
│                      │                                   │
│          ┌───────────┼───────────┐                       │
│          ▼           ▼           ▼                       │
│     IndexedDB      OPFS    Agent Worker                  │
│     (messages,   (group    (Claude API                   │
│      tasks,       files,    tool-use loop,               │
│      config)     memory)    WebVM sandbox)               │
│                                                          │
│  Channels:                                               │
│  ├── Browser Chat (built-in)                             │
│  └── Telegram Bot API (optional, pure HTTPS)             │
└──────────────────────────────────────────────────────────┘

Key Files

File Purpose
src/index.ts Entry point, bootstraps UI
src/orchestrator.ts State machine, message routing, agent invocation
src/agent-worker.ts Web Worker: Claude API tool-use loop
src/tools.ts Tool definitions (bash, read/write files, fetch, etc.)
src/vm.ts WebVM wrapper (v86 Alpine Linux in WASM)
src/db.ts IndexedDB: messages, sessions, tasks, config
src/storage.ts OPFS: per-group file storage
src/router.ts Routes messages to correct channel
src/channels/browser-chat.ts In-browser chat channel
src/channels/telegram.ts Telegram Bot API channel
src/task-scheduler.ts Cron expression evaluation
src/crypto.ts AES-256-GCM encryption for stored credentials
src/ui/ Chat, settings, and task manager components

How It Works

  1. You type a message in the browser chat (or send one via Telegram)
  2. The orchestrator checks the trigger pattern, saves to IndexedDB, queues for processing
  3. The agent worker (a Web Worker) sends your message + conversation history to the Anthropic API
  4. Claude responds, possibly using tools (bash, file I/O, fetch, JavaScript)
  5. Tool results are fed back to Claude in a loop until it produces a final text response
  6. The response is routed back to the originating channel (browser chat or Telegram)

Tools

Tool What it does
bash Execute shell commands in a sandboxed Linux VM (Alpine in WASM)
javascript Execute JS code in an isolated scope (lighter than bash)
read_file / write_file / list_files Manage files in OPFS per-group workspace
fetch_url HTTP requests via browser fetch() (subject to CORS)
update_memory Persist context to CLAUDE.md (loaded on every conversation)
create_task Schedule recurring tasks with cron expressions

Telegram

Optional. Works entirely via HTTPS — no WebSockets or special protocols.

  1. Create a bot with @BotFather on Telegram
  2. Open Settings in OpenBrowserClaw, paste the bot token
  3. Send /chatid to your bot to get the chat ID
  4. Add the chat ID in Settings
  5. Messages from Telegram are processed the same as browser chat

Caveat: The browser tab must be open for the bot to respond. Messages queue on Telegram's side and are processed when you reopen the tab.

WebVM (Optional)

The bash tool runs commands in a v86-emulated Alpine Linux. To enable:

  1. Download the v86 WASM binary and Alpine rootfs image
  2. Place them in public/assets/:
    • public/assets/v86.wasm
    • public/assets/v86/libv86.js
    • public/assets/alpine-rootfs.ext2
  3. The VM boots automatically on first use (~5-15 seconds)

Without these assets, the bash tool returns a helpful error. All other tools work without the VM.

Comparison with NanoClaw

NanoClaw OpenBrowserClaw
Runtime Node.js process Browser tab
Agent sandbox Docker/Apple Container Web Worker + WebVM
Database SQLite (better-sqlite3) IndexedDB
Files Filesystem OPFS
Primary channel WhatsApp In-browser chat
Other channels Telegram, Discord Telegram
Agent SDK Claude Agent SDK Raw Anthropic API
Background tasks launchd service setInterval (tab must be open)
Deployment Self-hosted server Static files (any CDN)
Dependencies ~50 npm packages 0 runtime deps

Development

npm run dev        # Vite dev server with HMR
npm run build      # Production build → dist/
npm run preview    # Preview production build
npm run typecheck  # TypeScript type checking

Deploy

npm run build
# Upload dist/ to any static host:
# GitHub Pages, Cloudflare Pages, Netlify, Vercel, S3, etc.

No server needed. It's just HTML, CSS, and JS.

Security

OpenBrowserClaw is a proof of concept. All data stays in your browser, nothing is sent to any server except the Anthropic API. Here's an honest look at the current security posture:

What it does:

  • API keys are encrypted at rest with AES-256-GCM using a non-extractable CryptoKey stored in IndexedDB. JavaScript cannot export the raw key material.
  • All storage (IndexedDB, OPFS) is same-origin scoped by the browser.
  • The agent runs in a Web Worker, separate from the UI thread.

What it doesn't do (yet):

  • The encryption protects against casual inspection (DevTools, disk forensics) but not a full XSS attack on the same origin, an attacker with script execution could call the encrypt/decrypt API.
  • The javascript tool runs eval() in the Worker, which has access to fetch(). This means Claude can make arbitrary HTTP requests through the JS tool regardless of any fetch_url restrictions.
  • Outgoing HTTP requests (via fetch_url or the JS tool) have no user confirmation step.
  • The Telegram bot token is currently stored in plaintext.

This is a single-user local tool, not a multi-tenant platform. Contributions to improve the security model are welcome.

Frequently asked questions

Is openbrowserclaw free to use?

openbrowserclaw is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does openbrowserclaw do?

Browser-native personal AI assistant. Zero infrastructure, the browser is the server.

What is openbrowserclaw written in?

openbrowserclaw is primarily written in TypeScript. Its source is publicly available at https://github.com/wexare-ai/openbrowserclaw, and it has 604 GitHub stars.