A local-first agent mesh.
Get started · The mesh · Documentation · Build status
Run persistent agents on your own devices, connect them through a mesh, and let them collaborate. Agents keep durable state and work in local workspaces. They communicate through chats and can delegate work to other agents and devices.
Use native desktop and Android clients to talk to your agents and manage the mesh. Model requests go to the providers you configure.
- Build an agent mesh. Connect stations and clients with invitations and explicit permissions. Let agents communicate and delegate across devices.
- Share capabilities across devices. Reuse skills, call another Station's MCP tools, access shared services and exchange files through the mesh.
- Work through conversations. Choose agents and models, send messages and files, follow progress, and manage work from a native client.
- Keep agents running. Each agent session has a durable mailbox and event history. A Station can run in the background independently of the client.
- Use your existing workspaces. Agents run tools in an explicitly selected directory. They can read and edit files, run shell commands and use configured MCP services and skills.
- Bring your own model connections. Profiles manage provider credentials and model access. Slack is optional; the native conversation entry works without it.
Zork is under active development. Start from source today; prebuilt node packages are available only when a complete release is published on the Releases page.
You need Rust, Node.js 22.15 or later and pnpm 10.33.0. Coding tools also use
git, gh and rg from PATH. Native desktop builds require the platform
toolchain described in the desktop README.
git clone https://github.com/HOOLC/zork.git
cd zork
pnpm install --frozen-lockfile
pnpm build
pnpm devpnpm dev starts the supervisor and Station with the default data directory
~/.zork. For an isolated node:
pnpm dev -- --data /absolute/path/to/node-dataOn macOS, start the desktop client from the same checkout:
python3 scripts/lib/build_env.py -- cargo run --locked -p zork-guiConfigure model connections and agents in Settings, then select an agent from the
conversation sidebar. The client can manage its local node or connect to other
devices. Product settings live in the node's config.json; local build settings
may use an ignored .env. See desktop setup and
Android development.
Install a published native node
Once a complete native release is available:
curl -fsSL https://github.com/HOOLC/zork/releases/latest/download/install.sh | shThe installer selects and verifies a native package and starts a persistent Station. Node.js and npm are not required on an installed node. To join a mesh, use the pinned invitation command from Settings → Device connections. Native release instructions cover offline installs, version pinning, service management and upgrades.
zork update restarts an existing node with already staged binaries.
zork upgrade --version X.Y.Z downloads and activates a complete release.
Neither a fresh install nor joining a mesh silently upgrades a running node.
- An agent runs a persistent session with a mailbox, tools and a local workspace. It can exchange messages and delegate tasks to other agents.
- A Station hosts agents on one device. It owns local state, conversations, skills, MCP connections, services and files, and participates in the mesh as a peer.
- A client connects to Stations to start conversations, configure agents and manage devices and resources. One client can connect to multiple Stations; a client and Station can also run on the same device. Stations can keep working after the client closes.
The mesh carries both agent collaboration and access to shared capabilities. Each owning Station checks the permissions it has granted:
| Resource | Across the mesh |
|---|---|
| Skills | Share a fixed package revision, then bind it to an agent on the target Station. |
| MCP | Discover and call tools on the Station that hosts the connection and credentials. |
| Services | Open explicitly shared applications through their hosting Station. |
| Files | Exchange selected attachments and artifacts; receivers keep their own snapshots. |
Each Station keeps its own state and workspace. Sharing is explicit; joining the mesh does not automatically replicate entire directories. See device and skill tools, Mesh MCP, service sharing and file sharing.
The zork supervisor starts one zork-station process, which embeds the agent
runtime. The standalone zork-agent binary is also available. Clients submit
business intents through zork-client-core and render its state. See the
agent architecture,
client boundary and
chat contracts.
This repository includes a macOS desktop client and Android client. Native node packaging targets macOS and Linux on ARM64 and x64; desktop app packaging and signing follow a separate workflow. The native design app is an interactive reference and component showcase. See native releases for platform requirements.
Repository map and validation commands
| Path | Responsibility |
|---|---|
crates/station |
Station: conversations, delivery, node APIs and orchestration |
crates/agent, crates/agent-http, crates/agent-server |
Durable agent runtime and optional HTTP host |
crates/zork |
Supervisor, installation, services and upgrades |
crates/zork-client-core, crates/zork-client-types |
Shared client operations, state, sync and contracts |
crates/zork-gui, crates/zork-ui |
Desktop application and reusable GPUI components |
apps/android, crates/zork-android |
Android application and Rust bridge |
crates/zork-mesh |
Device transport, enrollment and synchronization support |
crates/profile, crates/slack |
Model profiles and Slack integration |
apps/zork-design-pc, zork-design-pc |
Editable design sources and native component browser |
scripts, .github/workflows |
Development, packaging and validation |
benchmarks |
Independent benchmarks and experiments |
docs |
Architecture, contracts and operating guides |
Install local checks with pnpm hooks:install. Commit hooks run fast static and
boundary checks; push hooks run the affected test suites. Branches and PRs do not
start automatic CI. Main runs the shared runtime contracts and path-scoped
Cloudflare validation; native packaging and upgrade checks remain in tag releases.
pnpm format:check
pnpm lint
pnpm build # rebuild binaries before process tests
pnpm test # JS and process contracts
pnpm test:rust # backend Rust tests
bash scripts/check-runtime.sh # the same runtime suite used on main
pnpm test:desktop # native desktop tests
python3 scripts/check-client-boundary.pyNative design browser: pnpm design:pc or pnpm design:pc:verify. DeepSWE adapter tests: pnpm benchmark:deep-swe:test.
Functional tests and performance measurements have separate entry points; see
validation and repository content.
The documentation index groups Agent, Chat, client, Mesh, UI and engineering contracts and pending proposals. Implementation details stay with the source and generated help; test results belong to their run artifacts. The native design browser contains editable guidelines, curated assets and historical visual references.
MIT. Bundled third-party components retain their own license and attribution files alongside the source and assets.