Do Computer

An open-source personal agent that is always on, and that you can host yourself.

Website · Self-hosting guide ·
Desktop app ·
Reference

A chat with an agent called Juniper, whose creature sits beside the conversation

Do Computer gives you agents that each have a name, a face, a memory and computers to work on.
An agent keeps working after you close the tab, runs things on a schedule, learns skills, and
can work on your own machines. It can be yours alone or shared with a team.

One codebase runs on plain Node and on Cloudflare Workers. Models are called through
OpenRouter or a provider you sign in to, and the agent loop is
pi-durable.

Status: early. The core works on both runtimes and is covered by tests.
PLAN.md says what is built and what is not.

What an agent can do

Keep working. A reply carries on when you close the tab. Side chats and sub-agents let it
do several things at once.
Use a computer. It runs commands and edits files on a machine of its workspace: a
built-in shell, a Linux machine on Daytona, Modal or Cloudflare Containers, or a computer of
your own.
Run on a schedule. Ask for something later or regularly, and it reports back in the chat
you asked in.
Remember. It keeps a personality, a profile of you and its own notes, all of which you
can read and edit.
Learn skills. Saved instructions it loads when a task calls for them, writes for itself,
or installs from GitHub.
Reach your services. Add any remote MCP server as a
connector, or connect your apps (Gmail, Calendar, Notion, GitHub and
hundreds more) with one sign-in.
Write and share. Documents, charts and web pages go in a library its workspace shares,
and anything there can be shared with a link.
Search the web, and answer with sources.
Use your browser and screen. On a computer you paired, it can drive a browser, and work
in a window behind yours while you carry on.
Work with a team. Several people share agents, chats, files and computers. An agent can
also be a bot in Slack.
Ask first. Each thing an agent can do is set to Allow, Ask first or Never.
Think with the model you choose. Any OpenRouter model that can call tools, or a
subscription or key of your own.
Be a creature. Every agent hatches from an egg and looks like no other. It earns treats
as it works, and finds things to wear.

What an agent can do has the long version.

Documents open beside the chat	Automations run on a schedule
You decide what it may do without asking	Every agent starts as an egg

Quick start

You need Node 22.19 or newer.

git clone https://github.com/SawyerHood/do-computer
cd do-computer
corepack enable
pnpm install
pnpm build
pnpm start     # http://127.0.0.1:3000

Open the address, create an account and say hello to your agent. The first account needs no
invitation.

Without a model key the app runs on a built-in echo model, which repeats what you say. Set
OPENROUTER_API_KEY to give your agent a real one.

Hosting it

	A machine of yours	Cloudflare
Runs on	Node, on a laptop, a home server or a VPS	Workers and Durable Objects
Your data	A folder of SQLite files	D1, Durable Objects and R2
Costs	Nothing besides the models	The Workers Paid plan
Good for	Trying it, one person, a home network	An address anyone can reach, a team

The self-hosting guide covers both, a step at a time: a model key,
other devices and https, keeping it running, and deploying to Cloudflare.

You can also hand the guide to a coding agent and have it do the setting up:

Follow https://raw.githubusercontent.com/SawyerHood/do-computer/main/docs/self-hosting.md and set up Do Computer for me.

Where you use it

The web app. It works on a phone too, can be added to the home screen, and sends
notifications. See Notifications.
The desktop app, for macOS, Windows and Linux. It shows your deployment in a window of
its own and lets your agents work on that computer. Download it from the
latest release, or see
Desktop app.
The mobile app, an Expo app for iOS and Android that you build from source. See
Mobile app.

Documentation

Guides, which every deployment also serves under /docs:

Reference, for whoever runs a deployment:

Configuration: every environment variable
Computers: the kinds of machine an agent can work on
Models: the deployment's models and a workspace's own
Security and trust: what an agent can reach, and what limits it
Teams, Slack and
Apps
Doods and the waiting list

Development

pnpm dev                 # Node target, http://localhost:3000
pnpm dev:cloudflare      # the same app inside the Workers runtime (copy apps/web/.dev.vars.example)
pnpm check               # type-check everything, both targets
pnpm test                # unit and integration tests, on Node and in the Workers runtime
pnpm test:e2e            # browser tests against the built Node server
scripts/smoke.sh http://localhost:3000     # end-to-end check of any running deployment

pnpm dev does not serve the WebSocket that a paired computer connects over. To work on
pairing, use pnpm build && pnpm start or pnpm dev:cloudflare.

apps/web            the web app (TanStack Start): UI, API, and the server entry for each runtime
apps/desktop        the Electron app: the deployment in a window, with the daemon inside it
apps/mobile         the Expo app
apps/daemon         the daemon someone runs on their own computer
packages/agent      the agent: pi-durable harness, identity, chats, schedules, skills, connectors
packages/runtime    one actor host (SQLite, alarm, blobs, sockets) over Durable Objects and Node
packages/sandbox    the computers an agent works on: built-in shell, Daytona, Modal, Cloudflare
packages/computers  the daemon protocol, and the actor that holds a paired computer's connection
packages/protocol   types and reducers shared by the server and the clients
packages/client     the API client the web and mobile apps share
packages/mascot     the creature

Anything that touches a runtime is implemented for both and held to one conformance suite.
HANDOFF.md is the running record of what was built and why.

License

MIT. Third-party work and its terms are listed in
THIRD_PARTY_NOTICES.md.