Skip to content
Back to search

openwork

SkillWorks with Claude CodeGitHub

The open-source alternative to Claude Cowork (powered by opencode)

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/different-ai/openwork with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/different-ai/openwork'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/different-ai--openwork/badge.svg)](/listings/different-ai--openwork)

HTML

<a href="/listings/different-ai--openwork"><img src="/api/listings/different-ai--openwork/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Already use an AI agent? Copy this prompt and paste it into Claude Code, Cursor, Codex, ChatGPT, or any agent that can run commands on your computer.

Install OpenWork on my computer, set up my first workspace, and open it ready to use. Follow the steps in https://openworklabs.com/start.md?v=hero

1. Installs OpenWork 2. Creates your workspace 3. Opens it ready to run

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 231 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # OpenWork
  2. <p align="center">
  3. <img src="./docs/images/model-picker.png" width="560" alt="The OpenWork composer with its model picker open: pinned, recent and per-provider models from Anthropic, OpenAI, Google and a local Ollama model" />
  4. </p>
  5. OpenWork is the free, open-source alternative to Claude Cowork and Codex: a desktop app for macOS, Windows, and Linux where AI agents do real work on your own files. It is built on [OpenCode](https://opencode.ai), works with any model — 50+ providers, your own API keys, or local models via Ollama — and lets teams share skills and MCP servers.
  6. [**Download OpenWork**](https://openworklabs.com/download) · [GitHub releases](https://github.com/different-ai/openwork/releases) · [Docs](https://openworklabs.com/docs)
  7. Read this in: [简体中文](./translated_readmes/README_ZH.md) · [繁體中文](./translated_readmes/README_ZH_hk.md) · [日本語](./translated_readmes/README_JA.md)
  8. Add one OpenWork MCP to Codex, Claude Code, Cursor, or another compatible agent and reuse the same skills, MCPs, and connected services across your tools, teammates, and machines. Create something once, share it with coworkers or friends, or keep it for yourself.
  9. The desktop app is there when you want a dedicated workspace, but it is not required. You can use OpenWork from the agent you already have. For larger organizations, the admin interface lets you publish capabilities, manage access, and configure shared or per-user connections.
  10. <img width="1481" height="842" alt="OpenWork desktop app" src="https://github.com/user-attachments/assets/66a8dd9b-5260-488c-957d-e54331e78c1c" />
  11. ## Why OpenWork instead of Claude Cowork
  12. - **Free and open source.** The desktop app is MIT-licensed; no OpenWork account is required to use it locally.
  13. - **Any model.** Bring your own API key, sign in with ChatGPT, or run local models through Ollama or any OpenAI-compatible server. See [Add a custom LLM](https://openworklabs.com/docs/start-here/connect-your-stack/add-a-custom-llm).
  14. - **Runs on macOS, Windows, and Linux** as a desktop app — not a CLI.
  15. - **Your files stay local.** Cloud is optional.
  16. - **Share skills and MCP servers with your team.** See [Share skills with your team](https://openworklabs.com/docs/start-here/do-work-with-it/share-your-setup) and [Shared MCP connections](https://openworklabs.com/docs/cloud/share-with-your-team/shared-mcp-connections).
  17. - **Self-host** the team control plane on your own infrastructure. See [Self-host](https://openworklabs.com/docs/start-here/self-host).
  18. - **Bring your Cowork setup.** Skills, Claude-compatible plugins, and MCP servers carry over. See [Migrate from Claude Cowork](https://openworklabs.com/docs/start-here/migrate-from-claude-cowork).
  19. ## Install with your AI agent
  20. Already use an AI agent? Copy this prompt and paste it into Claude Code, Cursor, Codex, ChatGPT, or any agent that can run commands on your computer.
  21. ```text
  22. Install OpenWork on my computer, set up my first workspace, and open it ready to use. Follow the steps in https://openworklabs.com/start.md?v=hero
  23. ```
  24. 1. Installs OpenWork
  25. 2. Creates your workspace
  26. 3. Opens it ready to run
  27. ## Use OpenWork from any agent
  28. The OpenWork MCP brings your assigned skills, plugins, MCP connections, Google Workspace, and Microsoft 365 capabilities into any compatible agent.
  29. It exposes four tools: `search_capabilities` finds what you can use, `execute_capability` runs it, and `list_skills` / `get_skill` list your skills and read one SKILL.md directly. After adding the MCP, your client opens a browser so you can sign in and choose your OpenWork organization.
  30. ### Codex
  31. ```bash
  32. codex mcp add openwork --url https://api.openworklabs.com/mcp/agent
  33. ```
  34. ### Claude Code
  35. ```bash
  36. claude mcp add --transport http openwork https://api.openworklabs.com/mcp/agent
  37. ```
  38. ### OpenCode
  39. Add this to `opencode.json`:
  40. ```json
  41. {
  42. "mcp": {
  43. "openwork": {
  44. "type": "remote",
  45. "enabled": true,
  46. "url": "https://api.openworklabs.com/mcp/agent",
  47. "oauth": {}
  48. }
  49. }
  50. }
  51. ```
  52. ### Any MCP client
  53. Use this remote MCP server URL:
  54. ```text
  55. https://api.openworklabs.com/mcp/agent
  56. ```
  57. ## OpenWork Den
  58. OpenWork Den is the control plane for managing OpenWork across a team or organization.
  59. - Provision inference at scale and control which members and teams can use each model provider.
  60. - Invite teammates, create teams, and manage access from one place.
  61. - Set desktop policies, restrict local model access, and control which app versions your organization can use.
  62. - Publish skills and plugins through marketplaces, then assign them to the organization, a team, or specific people.
  63. - Import Agent Plugins or Anthropic-compatible plugins and make their supported skills and remote MCPs available through the OpenWork MCP.
  64. <img width="1546" height="915" alt="OpenWork Den organization control plane" src="https://github.com/user-attachments/assets/033dbbfe-5661-4f7c-869c-46278406d6cc" />
  65. ## Licensing
  66. This repository uses a directory-split license, similar to GitLab:
  67. - **Everything outside `ee/` is MIT** — the desktop app and core platform are open source, free for any use.
  68. - **Everything under `ee/` (OpenWork Den — the org control plane) is under the [OpenWork EE License](ee/LICENSE)**, a source-available license. The code is public so you can audit exactly what you deploy. Production use requires an [OpenWork subscription](https://openworklabs.com/pricing), except that it is **free for organizations with up to 5 users**, **free to evaluate for 30 days at any size**, and always free for development and testing. Each `ee/` release additionally converts to MIT two years after publication.
  69. Versions released before this license was adopted remain under their original license (FSL-1.1-MIT). See [pricing](https://openworklabs.com/pricing) and the [subscription terms](https://openworklabs.com/terms/subscription).
  70. ## Documentation
  71. [Read the OpenWork docs.](https://openworklabs.com/docs)
  72. ## Getting started (contributors)
  73. The fastest path from a fresh clone to a running dev build.
  74. ### Prerequisites
  75. - **Node 24** — pinned in [`.nvmrc`](./.nvmrc) (`nvm use` picks it up).
  76. - **pnpm 11** — pinned in `package.json` (`packageManager`); run `corepack enable` to use the pinned version automatically. Never use npm or yarn.
  77. ### First run
  78. ```bash
  79. git clone https://github.com/different-ai/openwork.git
  80. cd openwork
  81. corepack enable
  82. pnpm install
  83. pnpm dev # launches the Electron desktop app with hot reload
  84. ```
  85. Coding agents and tests should not open that window on your screen: they use
  86. the app in headless Chrome instead (see [Headless web](#headless-web-no-electron)
  87. and `AGENTS.md`).
  88. ### Repository layout
  89. | Path | What lives there |
  90. | --- | --- |
  91. | `apps/` | the desktop app: React UI (`apps/app`), Electron shell (`apps/desktop`), and `openwork-server` (`apps/server`) (MIT) |
  92. | `packages/` | shared core packages (MIT) |
  93. | `ee/` | OpenWork Den — the org control plane, MCP gateway, and inference (EE License, see [Licensing](#licensing)) |
  94. | `evals/` | executable test specs built on `@openwork/testkit` — see [`evals/README.md`](./evals/README.md) |
  95. | `worlds/` | declarative dev/test environment definitions for `pnpm world` |
  96. | `docs/` | operator, feature, and release docs |
  97. | `.opencode/skills/` | repository agent skills (verification, testing, feature flags, PRs) |
  98. ### Testing
  99. All executable coverage lives in `evals/specs/**/*.test.ts`; app-driving journeys use `.e2e.test.ts`.
  100. ```bash
  101. pnpm --dir evals install --frozen-lockfile # once
  102. pnpm evals:pr specs/<name>.test.ts # app-less PR-lane spec
  103. pnpm evals:e2e <name> --local # app-driving E2E journey, run locally
  104. ```
  105. Runtime-observable changes need test evidence on the PR. `AGENTS.md` and [`evals/README.md`](./evals/README.md) describe the verification contract and vocabulary.
  106. ### Sending a pull request
  107. 1. Branch from `dev` (the default branch) and open your PR against `dev`.
  108. 2. Keep the diff as small as possible, and include or update test evidence for runtime-observable changes.
  109. 3. Read [CONTRIBUTING.md](./CONTRIBUTING.md) for the licensing terms. By contributing you agree to the DCO, or under `ee/` to the [CLA](./legal/individual-contributor-license-agreement.md); there is nothing separate to sign.
  110. ## Local development
  111. For one checkout, keep using `pnpm dev`; with no extra environment variables it reuses the existing shared dev profile.
  112. To run multiple git worktrees at once, use:
  113. ```bash
  114. pnpm dev:worktree
  115. ```
  116. That sets `OPENWORK_DEV_PROFILE=auto`, derives a stable profile name from the worktree path, lets Electron choose a free CDP port, and asks Vite for a free dev-server port. You can also choose a named profile, for example `OPENWORK_DEV_PROFILE=my-feature OPENWORK_ELECTRON_REMOTE_DEBUG_PORT=0 PORT=0 pnpm dev`.
  117. `dev:worktree` also defaults `OPENWORK_ELECTRON_USE_MOCK_KEYCHAIN=1`. A brand-new profile has no stored credentials, so on macOS the real keychain prompts as soon as Chromium persists an authenticated cookie, and that modal blocks Electron's main loop until it is dismissed. Set `OPENWORK_ELECTRON_USE_MOCK_KEYCHAIN=0` if you specifically want the system keychain in an isolated profile.
  118. Dev startup prints a banner like `[openwork] dev profile=... cdp=http://127.0.0.1:9823`; use it to find the profile directory and pass the CDP URL to local tooling.
  119. If a second instance cannot get the profile lock it now says so and exits, instead of lingering with an open CDP port and no window.
  120. ### Headless web (no Electron)
  121. To run the OpenWork UI in a browser against a local `openwork-server` (no desktop shell):
  122. ```bash
  123. pnpm world up dev-app-web --detach
  124. pnpm world up dev-app-web --detach -- --browser # also opens it in headless Chrome and prints a cdp address
  125. ```
  126. `pnpm dev:headless-web` is a compatibility alias for the same script. The alias
  127. remains foreground by default and accepts `--detach`; `world up` is foreground
  128. unless `--detach` is explicit.
  129. This is an isolated launcher:
  130. - Writes `tmp/headless-server.json` and never reads `~/.config/openwork/server.json`
  131. - Authorizes the chosen workspace root automatically, and merges (never rewrites) that config on relaunch, so workspaces you add through the UI survive `--replace`
  132. - Starts Vite + `openwork-server` with a stable owner bearer forced into the UI. Crash-restarts keep open tabs working. The privileged host token stays on the server process and is never inlined into the Vite bundle.
  133. - Proxies Den Cloud calls same-origin: Vite serves `/api/den` (forwarded to the Den control plane) and the app pins its Den API there via `VITE_DEN_API_BASE_URL`, so Cloud calls are never CORS-blocked and stale `localStorage` base URLs are cleared on load
  134. - Publishes an owner-only runtime manifest at `tmp/dev-headless-web.json` (`0600`), and allows browser calls to the local server only from the web app's own origins — not every site you visit
  135. - Uses stable ports by default (web `5178`, server `8778`; falls back to free ports when taken, override with `OPENWORK_WEB_PORT` / `OPENWORK_PORT`)
  136. - Is single-instance as `dev-app-web`; stop it with `pnpm world down dev-app-web` before launching it again
  137. - Keeps Vite and the backend under one script lifecycle, so either sibling exiting stops the other instead of leaving an orphan
  138. - In detached mode, waits for health, prints non-secret outputs and receipt/log paths, and exits
  139. Script-specific options must follow `--`:
  140. ```bash
  141. pnpm world up dev-app-web --detach -- --replace
  142. pnpm world up dev-app-web --detach -- --replace --keep-tokens
  143. ```
  144. `--replace` restarts the headless runtime with fresh tokens; add
  145. `--keep-tokens` to retain the previous tokens. `--rotate-tokens` is also
  146. accepted by this script. These are not generic `world` options.
  147. Open the printed Web URL. Cloud sign-in in headless web uses the **copy/paste** handoff (hosted Den cannot redirect session grants back to `http://127.0.0.1`):
  148. 1. Account → Sign in (opens Den; the paste field opens in Settings)
  149. 2. Sign in on Den
  150. 3. Copy the OpenWork link / one-time code Den shows
  151. 4. Paste it under **Paste sign-in code** → Finish sign-in
  152. Point Den at a local stack with `OPENWORK_DEV_DEN_PROXY_TARGET=http://127.0.0.1:3005` while `pnpm dev:web-local` is running. Set `OPENWORK_DEV_HEADLESS_WEB_DEN_PROXY=0` to disable the Den wiring.
  153. The other checked-in scripts include `worlds/live-app-web.ts` and
  154. `worlds/live-desktop.ts`. Both intentionally share installed production
  155. state and require their script-specific opt-in after `--`, for example
  156. `pnpm world up live-desktop -- --allow-shared-state`. List scripts and
  157. running receipts with `pnpm world list`. The headless
  158. production world is hard-limited to loopback; remote-access/public-host settings
  159. are refused because its browser session uses production credentials.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.