OpenWorker: A Free, Open-Source AI Coworker That Actually Finishes the Task

TL;DR: OpenWorker is a free, MIT-licensed desktop AI agent from Andrew Ng's team (andrewyng/openworker) that runs on your machine, plugs into 25+ tools you already use (Slack, GitHub, Jira, Notion, Google Calendar, your terminal, your files), and delivers finished work rather than a to-do list. It crossed 10,000 GitHub stars in mid-2026, supports any model (OpenAI, Anthropic, Gemini, DeepSeek, or fully local via Ollama), and asks before it does anything consequential. The macOS build is signed and notarized. The Windows build works but isn't code-signed yet, so SmartScreen will complain. There is no monthly fee, and there never will be.

If you've used ChatGPT or Claude for real work, you've probably hit the same wall. The model can draft a Slack message, summarize a doc, or sketch a calendar plan, and then you do the work: copy the text, switch apps, paste it, fix the formatting, click send. The assistant hands you a to-do list. You are the executor.

OpenWorker is built around a different idea. Tell it the outcome you want, and it walks the task through to the end. "Prep me for the Northwind renewal call" returns a finished brief. "Untangle my calendar for tomorrow" returns a clean, updated schedule. "Triage my unread inbox and draft replies for the urgent ones" returns three drafts in your outbox, ready for one-click send.

It is not a chatbot. It is an agent that lives on your desktop, has access to the same tools you do, and checks in before it does anything that matters.

What OpenWorker Actually Does

OpenWorker is a native desktop app for macOS and Windows, with a Linux build possible from source. You give it a task in plain English. It breaks the task into steps, reads and writes your files (with permission), talks to your tools (Slack, GitHub, Jira, Notion, Linear, HubSpot, Outlook, monday.com, Gmail, Google Calendar, plus anything reachable over MCP), and runs commands in your terminal when it needs to. Then it asks before it sends anything, changes a calendar, or runs a shell command you haven't approved. You can approve, redirect, or kill the run at any point.

The end result is a real deliverable. A document you can open. A thread reply in Slack. A row in your spreadsheet. A new event on your calendar.

The Architecture

OpenWorker's backend is a Python agent server built on aisuite, Andrew Ng's lightweight chat-completions library with a unified API across providers and a native agents, tools, and MCP layer. The desktop shell is React + Tauri.

┌────────────────────────────────────────────────┐
│              OpenWorker desktop app            │  native shell + GUI
├────────────────────────────────────────────────┤
│           local agent server (Python)          │  engine, tools, connectors
├───────────────┬────────────────┬───────────────┤
│  your files   │   your tools   │  your model   │  everything runs with your keys,
│  & terminal   │ 25+ connectors │  any provider │  on your machine
└───────────────┴────────────────┴───────────────┘

The "your model" part is the headline. OpenWorker ships with verified support for OpenAI (GPT-5.x and GPT-4.x), Anthropic (Claude Opus, Sonnet, Haiku), Google Gemini, DeepSeek, Kimi, Qwen, GLM, Mistral, and Grok. It also works with open-weight models through Together and Fireworks, and with fully local models through Ollama (no API key, no cloud round-trip).

You paste your own key, point it at Ollama, or both. Switch any time. There is no OpenWorker-branded model you are forced to use, and there is no per-task token surcharge on top of what you already pay your provider.

Connectors, and Why MCP Is the Whole Story

OpenWorker talks to Slack out of the box, including @OpenWorker mentions in channels (a session opens on your desktop, the work happens with your tools, and the answer comes back as a thread reply), plus Gmail, Outlook, Google Calendar, GitHub, GitLab, Jira, Linear, Notion, monday.com, HubSpot, your local files, your terminal, and a Rust-based STT sidecar for voice input.

MCP is the part most people underestimate. The Model Context Protocol ecosystem is shipping new connectors every other week. Because OpenWorker accepts any tool reachable over MCP, you can add your own internal tools, your CRM, your ticketing system, your company wiki, or a custom data API by writing a small MCP server. The desktop UI gives you per-tool control over what OpenWorker is allowed to touch, which is the right default for a tool with this much reach.

Approval-Gating

An agent that can read your email, send Slack messages, and run shell commands without asking is a security incident waiting to happen. OpenWorker gates every consequential action behind a check-in. Writes and sends (Slack, email, calendar creates) need a confirm or redirect before they fire. Shell commands need a confirm before they run. Unattended runs park their asks in an inbox instead of acting on their own. And you can disable any connector you don't want OpenWorker to use.

The default is conservative. You can loosen it once you trust the workflow, but you start with the brakes on.

Scheduled Automations

OpenWorker runs recurring work on a schedule, on top of the one-off tasks. A morning brief that pulls your calendar, your unread inbox, and your top Jiras into a single doc before you sit down. A weekly report that posts a summary to a Slack channel every Friday. A standing watch over a channel that surfaces anything that needs your input.

Automations land back in the app with full transcripts, so you can audit what the agent actually did. The transcripts are useful for debugging, and they are useful for handing the workflow off to a teammate who can see exactly what happened.

How OpenWorker Compares to the Alternatives

The "AI coworker" space is small but crowded. Here is how OpenWorker stacks up against the tools people usually try first:

What separates OpenWorker from the pack. It is local-first with BYO model (your data stays on your machine, you pick the model, you pay your provider directly, no token surcharge). It is MCP-native (the connector list is not fixed, anything on MCP plugs in). And it is a real desktop app rather than a web tab (native shell, system hotkeys, system tray, file system access that does not fight a sandbox).

Where OpenWorker Falls Short (Honestly)

It is beta, and it shows. A few honest caveats.

macOS is the smooth path. The macOS build is signed and notarized, auto-updates cleanly, and gets the features first. Windows works but is not code-signed yet, so SmartScreen warns on first launch and you have to click through. Linux runs from source only.

Some polished workflows are still rough. This is v0.1.6 in late July 2026, and the README explicitly says the team is "actively polishing rough edges." Expect some workflows to need a second prompt.

Connector coverage is uneven. The 25+ connectors are real, but the depth varies. GitHub, Slack, Gmail, Google Calendar, Jira, and Notion are first-class. HubSpot, monday.com, and Linear work, but expect to verify the first few runs.

Approval prompts can get noisy. Ask OpenWorker to send five Slack messages and you will get five approval prompts. You can batch them, but the default is conservative, which is the right default.

The community is small. 10K stars is small for a tool this ambitious. The Discord and GitHub Discussions are active, but you will not find a Stack Overflow answer for every error yet.

How to Get Started (5 Minutes)

On macOS: download from openworker.com. It is signed and notarized and auto-updates. Open the app, paste a model key (or point it at a running Ollama instance), and ask it something real. "Prep me for my 2pm call: pull the latest from the shared Drive folder, summarize the last 10 Slack messages in #acme-renewal, and draft three discovery questions I should ask." Watch the steps. Approve the consequential actions. Open the deliverable.

On Windows: download the installer. SmartScreen will warn. Click "More info" then "Run anyway." Same flow as macOS, just slower on first run while the app unpacks. The team is actively working on code-signing Windows builds.

From source (any platform):

git clone https://github.com/andrewyng/openworker
cd openworker
bash packaging/setup_dev_env.sh   # creates the Python venv at .venv
.venv/bin/openworker-server --cwd ~/some/project --port 8765
# In a second terminal, start the UI:
cd surfaces/gui
npm install
npm run dev        # browser UI on the Vite dev port
# Or, for the full desktop app:
npm run tauri dev

Prerequisites: Python 3.10+, Node 20+, and (for the desktop shell) the Rust toolchain via rustup.

Who's Behind It

OpenWorker is built by Andrew Ng's team, the same group behind aisuite and the broader DeepLearning.AI ecosystem. The project is MIT-licensed, takes contributions on GitHub, and updates itself, so fixes pushed to main land on installed copies quickly.

The README is candid about the roadmap: "We are actively developing based off an internal list and goal, so we may not approve PRs that add features that are already under-development or deviates from our vision." That is a feature, not a bug. It means the project is not a kitchen sink.

The Bottom Line

OpenWorker is the most credible open-source "AI coworker" shipping in 2026. Local-first, BYO-model, MCP-native, MIT-licensed, approval-gated, and ships as a real desktop app on macOS and Windows. It is beta, the connector coverage is uneven, and the Windows build still trips SmartScreen. For a free, open-source agent that talks to your tools and delivers finished work, nothing else in this space is close.

If you have been looking for a free OpenAI Operator alternative, a free Manus alternative, or a free Devin alternative that runs on your machine with your keys, this is the one to try.

GitHub: github.com/andrewyng/openworker (10K+ stars, MIT) Website: openworker.com Built on: github.com/andrewyng/aisuite

Looking for other free AI tools? Check out our coverage of pxpipe for cutting Claude Code token costs, FluidVoice for free on-device dictation, and Voicebox for local AI voiceovers.