Agents you can
read, fork, and ship.

An agent that perceives, judges, and acts on its own — at lightning speed. One codebase ships to Web, Desktop, and a Chrome extension that drives the user's already-logged-in browser.

JZ
HZ
ZZ
Open source & growing
View on GitHub Read the Docs
↗ Quick start guide

One run, four phases

Watch the API squad actually run

Same UI the agent renders in production — stepped through phase by phase. Click a phase to see the message stream and the tools fired at that moment.

Scaffold an API from a spec task #t_42af · lead + 3 members
0:47 elapsed
$0.14 cost
3 members
e2b sandbox
Primitives 14 calls
1 Skills
7 Tools
5 Teams
1 Memory
Context window 42K / 128K
33% used — compaction hasn't fired yet.
phase ① · plan
0:04 elapsed
Scaffold a REST API for /api/auth from this OpenAPI spec. Include migration, tests, and README.
reasoning · 4 thoughts
Four independent lanes let the team work in parallel. Schema first, migration + tests pivot off it, README trails.
Skills · view_skill rest-api loaded · 1,284 tokens
Four stages — each with an explicit dependency:
Plan · write_todos 4 items
fetch-schema—
write-migrationsafter fetch-schema
generate-testsafter write-migrations
draft-readmeafter write-migrations
await view_skill({
  skill_name: 'rest-api',
  version: '>=1.0',
  if_missing: 'skip',
})
await write_todos({
  todos: [
    { id: 'fetch-schema',     deps: [] },
    { id: 'write-migrations', deps: ['fetch-schema'] },
    // …
  ],
})
Skills primitive write_todos ref
phase ② · spawn
0:11 elapsed
Spawning three members. The DAG handles ordering — schema-sync ships first, the rest fan out from it.
Team · team_create build_api 3 members
lead · you
schema-sync agentType: code
tasks: fetch-schema → write-migrations
active
test-runner agentType: test
task: generate-tests · waits on write-migrations
blocked
doc-writer agentType: docs
task: draft-readme · waits on write-migrations
blocked 
await team_create({
  name: 'build_api',
  members: [
    { name: 'schema-sync', agentType: 'code' },
    { name: 'test-runner', agentType: 'test' },
    // …
  ],
})
await team_task({
  action: 'create',
  title: 'fetch-schema',
  assignedTo: 'schema-sync',
  description: 'Parse OpenAPI, emit schema.ts + migration.sql',
  dependencies: [],
})
Agent teams Task DAG
phase ③ · execute
streaming
from schema-sync · 19s
文件系统 · write_file migration.sql +142
migrations/001_auth.sql +142
CREATE TABLE users (
id UUID PRIMARY KEY,
email TEXT UNIQUE NOT NULL,
password_hash TEXT NOT NULL
);
Team · team_message → test-runner
from test-runner · claimed 0.1s ago
文件系统 · write_file auth.spec.ts writing… 
const result = await execute({
  command: 'pnpm prisma generate',
  timeout: 30_000,
})
await write_file({
  path: 'migrations/001_auth.sql',
  content: migration,
})
await team_message({
  to: 'test-runner',
  content: 'schema.ts ready at /tmp/out/schema.ts',
})
Tool system Sandbox providers
phase ④ · deliver
0:47 total
Memory · recall_memory auth-service pattern 1 hit
PROJECT Auth endpoints return 401 + WWW-Authenticate: Bearer — README must cite the token header. 8× · 3d
Pattern applied — opened PR #42:
complete delivered
PR #42 · Scaffold /api/auth
migrations/001_auth.sql+142
tests/auth.spec.ts+98
docs/auth.md+37
12 / 12 tests passing · 47 seconds wall-time 
const hits = await recall_memory({
  types: ['project'],
  query: 'auth header convention',
  limit: 3,
})
await complete({
  summary: 'Scaffolded /api/auth · 3 files · 12 tests pass',
  artifacts: [
    { kind: 'pr', url: 'github.com/acme/api/pull/42' },
  ],
})
Memory primitive Compaction

Ship anywhere

One codebase, everywhere the work happens

Same agent behavior across three surfaces and three sandbox providers. The only thing that changes is where data lives and where tools run.

① Surfaces where the user meets the agent
Web app Hono + React 19

PostgreSQL-backed, streaming SSE, resumable mid-run.

Desktop app Electron + SQLite

Local-first, keys encrypted via safeStorage, offline-capable.

Chrome extension MV3 + WXT

BUA drives your already-logged-in browser via CDP.

② Sandboxes where the tools actually run
Node local dev

Zero-setup loop — tools run in-process for fastest iteration.

Daytona managed VM

Persistent Linux workspace per task, stateful across rounds.

E2B firecracker

Fresh micro-VM per task, ~200ms cold start, ephemeral.

Dependency-inverted — swap a sandbox provider without touching agent code. Capability-gated tools hide what a sandbox can't do.

How it works

Autonomous by default, shaped by protocol

The same protocol — from a one-line answer to a multi-file refactor. Clarify and Plan activate only when Assess flags them as needed.

Assess

Triage against P0-P3 policies — direct answer, confirmation required, clarification needed, or plan first.

Clarify

optional

When context, goal, or constraints materially affect the outcome, ask the user before acting.

Plan

optional

Emit an explicit todo list — execution stages only, each with verifiable output and a delivery spec.

Execute

Run stages linearly, parallelize independent tool calls when safe, recover from errors openly.

Deliver

Synthesize outputs, verify against the delivery spec, return a direct response or persisted files.

FAQ

Answers before you fork it

The things people ask after five minutes with the repo.

Can I self-host?

Yes — Zapvol is open source end-to-end. Run the server + web stack on your own infra, or ship the desktop app straight to users. No phone-home, no mandatory cloud account.

Why TypeScript instead of Python?

The agent shares code with the UI — prompts, schemas, tool types, message shapes — and TypeScript lets us ship the same typed contract from the browser down to the sandbox. Python would force a protocol boundary we don't need.

How is this different from Mastra / Vercel AI SDK / LangChain?

Vercel AI SDK is the streaming primitive underneath — we build on it. Mastra is a peer framework; Zapvol goes further by shipping a full Web + Desktop + Extension product, not just a backend framework. Against LangChain, we favor typed, documented internals you can read in an afternoon.

Is the browser extension (BUA) safe?

BUA is an internal-only tool: silent execution by default, no consent prompts, but a full audit log, a global kill switch in the popup, and Chrome's non-removable yellow "debugger attached" bar. A domain blocklist lets ops carve out sensitive sites.

Which models are supported?

Anything Vercel AI SDK supports — Anthropic, OpenAI, Google, Bedrock, Azure, local Ollama. Model choice is per-tier; tier configs are stored in the DB and swappable without a deploy.

How does sandbox isolation work?

Every tool call resolves against a sandbox capability map. The agent never touches your host filesystem or shell directly — it calls a capability, the sandbox provider (Node / Daytona / E2B) executes it, and the result streams back as a typed tool output.

Is this production-ready?

Zapvol is used in production internally for coding, research, and browser automation. The stack — streaming, resumable rounds, 3-tier compaction, per-task SSE replay via Redis — is built for long-running agent work, not demos.

What's the license?

Source-available under a license that permits self-hosting and internal use. See the repo for the exact terms; commercial redistribution needs a separate agreement.

Ready to build?

Get started with Zapvol in minutes. Free and open source.

View on GitHub Read the Docs