OpenWorker Setup Guide: Andrew Ng's Desktop Agent Running in 10 Minutes

Andrew Ng just open-sourced OpenWorker on GitHub — a desktop AI agent under the MIT license, completely free. The positioning is blunt: it doesn’t keep you company, it does the work — across files, Slack, calendars, and GitHub, decomposing tasks, calling tools, and delivering a finished artifact you can use, edit, and share. This guide gets you running from zero.

What OpenWorker Is

In one line: an open-source, local-first, model-agnostic desktop AI agent. Not a browser extension, not a CLI tool — a real desktop application (Tauri + React + Python) running on your machine with direct access to local files, the terminal, and 25+ third-party tools (Slack, GitHub, Jira, Notion, Outlook, Gmail, Google Calendar…).

┌────────────────────────────────────────────────┐
│ OpenWorker Desktop App         Tauri + React   │
├────────────────────────────────────────────────┤
│ Python Agent Server         aisuite engine     │
├───────────────┬────────────────┬───────────────┤
│ local files / │ 25+ connectors │  any model    │
│ terminal      │                │               │
└───────────────┴────────────────┴───────────────┘

Key design decisions:

• Local-first: agent loops, conversation history, and tokens stay on your machine by default — no forced uploads.

• Model-agnostic: OpenAI, Anthropic, DeepSeek, Kimi, GLM, Ollama local models — bring your own API key and swap freely.

• Approval mechanism: sensitive actions — sending messages, editing calendars, running terminal commands — ask you first, and execute only on approval.

• Scheduled tasks: periodic automations, like a morning briefing assembled daily.

• MCP extension: any tool speaking Model Context Protocol can join.

Two setup philosophies exist, and picking the right one saves an hour. The prebuilt route — signed DMG on Apple Silicon, exe on Windows — gets you a working agent with zero toolchain fuss, and it is the right choice if your goal is to use OpenWorker rather than study it. The source route costs you a Rust toolchain install and a couple of builds but pays back immediately if you intend to modify connector behavior, swap the UI, or lift the orchestration layer into your own project. Start with the package either way; migrate to source only when you hit a wall the package cannot cross.

Environment Prep

Three dependencies:

# 1. Python 3.10+
python3 --version

# 2. Node.js 20+
node --version

# 3. Rust toolchain (builds the Tauri desktop shell)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Mac users should just grab the signed Apple Silicon DMG from openworker.com — the smoothest path. Windows users can download the exe installer; it isn’t code-signed yet, so SmartScreen will warn — expected behavior.

Developers who want to build and modify the code, read on.

Deploy From Source (the Developer Path)

# Clone the repo
git clone https://github.com/andrewyng/openworker.git
cd openworker

# One-shot Python venv initialization
bash packaging/setup_dev_env.sh

# Start the agent server
.venv/bin/openworker-server --cwd ~/some/project --port 8765

# In another terminal, launch the UI (browser version)
cd surfaces/gui
npm install
npm run dev

# For the full desktop build (Tauri window), substitute:
npm run tauri dev

Open the Vite port in your browser (usually localhost:5173) and the OpenWorker interface appears.

Configure a Model in Five Minutes

Model onboarding requires no config-file editing — it all happens in the UI:

2. Open OpenWorker.

3. Go to Settings → Models.

4. Pick your provider and paste the API key.

The preconfigured provider list:

• OpenAI: GPT-5.6 Sol and friends

• Anthropic: Claude Fable / Opus 5

• Google: Gemini 3.6

• Thinking Machines: Inkling

• DeepSeek / Kimi (Moonshot) / GLM (Z.ai) / Qwen / MiniMax / Mistral / Grok (xAI)

• Local models: any open-weight model via Ollama

Note that tool-calling capability varies by model — the UI marks which ones are verified.

One operational note before your first real task: connectors are the part of OpenWorker that touches the outside world, so authorize them deliberately — grant Slack read before you grant Slack send, and the same for mail. The approval gate will catch mistakes, but scopes chosen conservatively at setup time are the cheaper safety net. With connectors authorized and a verified model configured, you are ready for the fun part.

First Real Task

Type a natural-language task straight into the box, for example:

“Prepare a brief for client A’s meeting next Monday: pull the project docs from Notion, check the last week of commits on GitHub, and save the summary as a Markdown file on my desktop.”

OpenWorker will:

2. Decompose the task: find project materials → search GitHub → format output;

3. Call the connectors (after you’ve authorized each tool);

4. Pop a confirmation dialog before any sensitive send/write operation;

5. Deliver the finished file.

For scheduled work, open the Automations page and configure a trigger plus a task description.

Extend With MCP

// Register an MCP tool server in the config
{
  "mcpServers": {
    "my-db": {
      "command": "node",
      "args": ["path/to/mcp-server/index.js"],
      "env": {
        "DB_URL": "postgresql://..."
      }
    }
  }
}

Any MCP-compliant tool can register here, and OpenWorker discovers it automatically for later tasks.

The Project From a Developer’s Eyes

The structure is clean and worth mining:

• coworker/ — Python backend: agent engine, model adapters, connectors, MCP client, memory, and automation logic;

• surfaces/gui/ — React + Tauri: desktop UI and window management;

• stt/ — Rust sidecar for voice input;

• packaging/ — DMG/EXE build scripts;

• docs/ — design documents and decision records.

The engine layer builds on aisuite — if all you want is agent orchestration for your own project, you can lift the agents layer directly.

Practical Advice

2. Run the prebuilt package first, compile from source later — the DMG installs ready to use, and ten minutes genuinely suffices.

3. Prefer verified models — tool-calling stability differs noticeably on unverified ones.

4. Leave the approval mechanism on, especially early on — you don’t want to price out the cost of a misfired message or a wrong-directory write.

5. Start with simple tasks — reading files, writing documents — then climb to complex scheduling.

6. Digging deeper? Read the design documents in docs/ — there are architecture decision records in there.

Resources

• GitHub repo: github.com/andrewyng/openworker

• Official site: openworker.com

• aisuite (the underlying agent framework): github.com/andrewyng/aisuite

• MCP protocol docs: modelcontextprotocol.io