Alpha — shipping, and still moving fast

Your data. Your devices.
Your rules.

xNet is a local-first platform for apps that work offline, sync peer-to-peer, and keep your data under your control. It’s like Lego for the web.

xNet
The xNet workbench in light mode: a Q3 Launch Plan document with a launch checklist, tabbed pages, and the Explorer sidebar showing spaces, folders, and tags

The app is built on the SDK. The SDK implements the protocol. Start anywhere.

Your whole workspace. One app.

A keyboard-first workbench that works offline, syncs across your devices, and keeps your data private. No account. Free forever.

Documents

Write together in real time. Slash commands, blocks, formatting — synced across devices.

Databases

Track anything with 15 field types. Tables, boards, galleries, calendars.

Canvas

An infinite whiteboard for visual thinking. Draw connections, embed documents.

Tasks

Projects with status, priority, assignees, and due dates — editable on any surface.

Chat & Calls

Channels, DMs, and peer-to-peer video calls on the same local-first sync.

AI assistant

Answers grounded in your own knowledge graph, with optional on-device search. AI content is always badged, never passed off as yours.

…and eight more surfaces — dashboards, notifications, instant search, CRM, finance, experiments, maps, and labs. All 14 in one workbench →

Desktop

Electron — full features, plugins

Web

PWA — any browser, installable

Mobile

Expo — iOS and Android (coming soon)

Try the App

Free forever. Self-hostable. Every feature is open source.

For Developers

Build local-first apps with three React hooks — storage, crypto, and networking handled for you.

App.tsx
import { defineSchema, text, person } from '@xnetjs/data'
import { allow, role } from '@xnetjs/data/auth'
import { useIdentity, useQuery, useMutate, useNode } from '@xnetjs/react'

// Schema with built-in authorization
const TaskSchema = defineSchema({
  name: 'Task',
  namespace: 'xnet://my-app/',
  properties: {
    title: text({ required: true }),
    assignee: person()
  },
  authorization: {
    roles: { owner: role.creator() },
    actions: { read: allow('owner', 'assignee'), write: allow('owner') }
  }
})

// 1. useQuery — read data
const { did } = useIdentity()
const { data: tasks } = useQuery(TaskSchema, {
  where: { assignee: did }
})

// 2. useMutate — write data
const { create, update, remove } = useMutate()
create(TaskSchema, { title: 'New task' })

// 3. useNode — real-time collaboration
const { doc, peerCount } = useNode(PageSchema, id)
  • Full TypeScript inference from schemas
  • Offline-first by default
  • P2P sync with no server code
  • No backend, auth service, or database to run

Sync peer-to-peer with no server at all, through a managed Hub, or against your own backend — same hooks either way. Not on React? @xnetjs/runtime drives the same client anywhere.

Built for agents

AI agents are first-class users of your workspace — through the filesystem they already know, not a wall of tool definitions.

terminal
# An agent working in a workspace checkout
$ xnet checkout --query "q3 roadmap"
Pages/q3-planning.md
Databases/tasks.rows.jsonl

$ grep -l "launch" Pages/ # files are just files
$ xnet query tasks --where status=open --format tsv

# edits become validated mutation plans
$ xnet commit --apply

Files first, safe by construction

Agents already read, grep, and edit files brilliantly. xNet checks out a scoped slice of the workspace as Markdown and JSONL — edits become schema-validated mutation plans, so a malformed write can’t corrupt anything.

~9x cheaper than MCP tools

One ~500-token SKILL.md teaches Claude Code, Codex, Gemini CLI, or Cursor the whole workflow. On a 15-task benchmark, files+CLI used 0.11x the tokens of an MCP toolset with equal success.

Bring your own agent

OpenClaw, Hermes, Buzz, Claude Code — xNet is not a competing harness. Every agent gets its own key and a narrowly scoped grant, and every change it makes lands in a signed log you can export and verify without trusting us.

Built to be left.

xNet keeps no behavioral surplus and has no ad model — you are not the product. Six commitments hold us to it, several enforced by a CI gate that fails the build on regression.

  • Own You hold the master copy.
  • Exit Leaving is your right, and it loses nothing.
  • Calm We compete for your wellbeing, not your time.
  • Consent Nothing leaves without permission.
  • Agency AI makes you more capable, not less.
  • Commons You own your audience and your space.

The long game: an open data layer where all your apps share data — offline, private, yours. See where this is going →

47
packages
9,600+
tests
21
devtools panels
MIT
open source

Alpha software, honestly labelled. See the open metrics →

Get Started

Choose your path

Use the App

Try xNet as a productivity tool

No install needed. Works offline.

Build with xNet

Add local-first superpowers to your React app

terminal
$ pnpm add @xnetjs/react @xnetjs/data

Join the Movement

Contribute to the open protocol

Good first issues waiting for you.

Requires Node.js 22+ and pnpm for development.