Primary question: Are you comfortable routing agent capability lookups and executions through a remote MCP server hosted by Different AI, Inc.?
RepoDaily adoption score
RepoDaily rates this as 91/100 (strong) for adoption: evidence, installation path, production risk, differentiation, license clarity, and AI/agent fit are scored from the article sources and adoption notes.
5 source(s) across 4 source category/categories, plus a RepoDaily-specific evidence module when available.
5 workflow step(s), 5 next-action step(s), and 4 command/install signal(s) were detected.
Trending momentum is +702 stars, with maintenance/release/issue signals counted when present.
Risk is marked medium, with 5 security note(s) and 3 explicit skip condition(s).
3 opportunity lens item(s), 4 alternative(s), and 3 type-specific section(s) support differentiation.
License source or license wording is present.
8 AI/agent-related signal(s) were detected in the article text and metadata.
Project overview
OpenWork is a free, open-source desktop application built in TypeScript that positions itself as an alternative to Claude Cowork and Codex for macOS, Windows, and Linux. Rather than replacing your AI coding agent, it sits alongside it: you add a single OpenWork MCP server to your existing agent — Claude Code, Cursor, Codex, ChatGPT, or any MCP-compatible client — and your assigned skills, MCP connections, Google Workspace, and Microsoft 365 capabilities become available across every tool and machine you use.
The desktop app provides a dedicated workspace for managing those capabilities, but it is explicitly optional. The README states: '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.' This agent-first design means a developer can be productive with OpenWork without ever launching the Electron GUI.
For organizations, OpenWork Den serves as a control plane. Administrators can publish skills and plugins, manage team access, set desktop policies, restrict local model access, provision inference at scale, and import Anthropic-compatible plugins. Den is packaged separately under the /ee directory and carries the Fair Source License, distinguishing it from the MIT-licensed core application.
The repository earned 702 stars during the trending period of 2026-08-02, placing it at rank 4. The project is published by Different AI, Inc., with its homepage at openworklabs.com and source code on GitHub under different-ai/openwork.
Why it is trending now
- 702 period stars on 2026-08-02 at trending rank 4, driven by demand for an open-source counterpart to the recently launched Claude Cowork.
- Single-MCP integration model: adding one remote MCP URL to any compatible agent immediately exposes all assigned skills, plugins, and service connections.
- Cross-platform Electron desktop app covering macOS, Windows, and Linux from one TypeScript codebase.
- OpenWork Den adds enterprise-grade access management — desktop policies, per-user model-provider routing, and marketplace-published plugins — which few open-source agent tools offer.
- Fair Source / MIT hybrid licensing lets individuals use the core app freely while giving Different AI a commercial path through Den.
Problem it solves
- AI coding agents like Claude Code, Cursor, and Codex each maintain their own skill and plugin configurations, so switching tools means reconfiguring capabilities from scratch.
- Sharing a reusable set of skills — say, a Slack integration or a custom data lookup — with a teammate requires manual duplication across each person's agent setup.
- Organizations lack a centralized control plane for governing which AI agent capabilities employees can invoke, which model providers they can access, and which app versions are permitted.
- Existing commercial offerings such as Claude Cowork are closed-source, platform-specific, and do not expose their capability-sharing layer for inspection or self-hosting.
How it works
- Install the OpenWork desktop app from openworklabs.com/download, or skip the GUI entirely and add the remote MCP server URL directly to your agent.
- Add the OpenWork MCP to your agent: for Codex run `codex mcp add openwork --url https://api.openworklabs.com/mcp/agent`; for Claude Code run `claude mcp add --transport http openwork https://api.openworklabs.com/mcp/agent`; for OpenCode add a remote MCP block to `opencode.json` with the same URL.
- When the agent first calls the MCP, the client opens a browser window for OAuth sign-in and organization selection.
- The MCP exposes two tools: `search_capabilities` finds what you can use, and `execute_capability` runs a selected capability within your agent session.
- For team deployments, an administrator uses OpenWork Den to publish skills, assign them to teams or individuals, set desktop policies, and control model-provider access — all of which propagate to every member's agent via the same MCP connection.
Command Surface and MCP Integration Points
- Codex integration: `codex mcp add openwork --url https://api.openworklabs.com/mcp/agent`
- Claude Code integration: `claude mcp add --transport http openwork https://api.openworklabs.com/mcp/agent`
- OpenCode integration: add a JSON block to `opencode.json` with `type: remote`, `enabled: true`, `url: https://api.openworklabs.com/mcp/agent`, and an empty `oauth: {}` object.
- Generic MCP client: use the remote server URL `https://api.openworklabs.com/mcp/agent` directly.
- Two MCP tools are exposed: `search_capabilities` (discovery) and `execute_capability` (execution).
- Prompt-based install for any command-capable agent: paste the prompt directing the agent to follow steps at `https://openworklabs.com/start.md?v=hero`.
Repository Architecture and Package Layout
OpenWork is a pnpm-managed TypeScript monorepo. The root `package.json` declares the workspace as `@different-ai/openwork-workspace` with version `0.0.0` and scripts that filter into sub-packages: `@openwork/desktop` for the Electron app, `@openwork/app` for the web UI, `@openwork-ee/den-db` and `@openwork-ee/den-api` for the Den control plane, and `@openwork-ee/enterprise-mock-lab` plus `@openwork-ee/diagnostics` for enterprise testing.
Local development uses `pnpm dev` for a single checkout with the default shared dev profile. For multiple git worktrees, `pnpm dev:worktree` sets `OPENWORK_DEV_PROFILE=auto`, derives a stable profile name from the worktree path, lets Electron pick a free CDP port, and asks Vite for a free dev-server port. The worktree mode also defaults `OPENWORK_ELECTRON_USE_MOCK_KEYCHAIN=1` to prevent macOS keychain prompts from blocking Electron's main loop during fresh-profile development.
Den's local development stack requires Docker Compose for MySQL (`docker compose -p openwork-den-local -f packaging/docker/docker-compose.web-local.yml up -d --wait mysql`), a database push step with configurable `DATABASE_URL` and `DEN_DB_ENCRYPTION_KEY`, and separate API and inference-proxy processes that read `BETTER_AUTH_SECRET`, `CORS_ORIGINS`, and `PROVISIONER_MODE` environment variables.
Security Policy and Disclosure Practices
OpenWork publishes a SECURITY.md with concrete SLA commitments. The team pledges to acknowledge vulnerability reports within 3 business days and provide an initial triage status within 7 business days. Reports are directed to `ben@openworklabs.com` with the subject prefix `[OpenWork security]`, and the policy explicitly instructs reporters not to open public GitHub issues for security vulnerabilities.
Supported versions are limited to the latest release and the current `dev` branch. The disclosure guidance requests that reporters keep vulnerability details private until a fix or mitigation is available and maintainers confirm public disclosure timing.
On the development side, the mock-keychain default in `dev:worktree` mode reveals that the Electron app stores authenticated cookies via Chromium and interacts with the native OS keychain — a relevant surface for security reviewers evaluating credential handling.
Who should pay attention?
Good fit if
- You switch between two or more AI coding agents (Claude Code, Cursor, Codex) and want to reuse the same skills and service connections across all of them.
- You lead a team that needs centralized governance over which AI capabilities and model providers members can access.
- You want to inspect, self-host, or extend the capability-sharing layer rather than relying on a closed-source commercial product.
- You already use OpenCode and want to add OpenWork as a remote MCP entry in your existing `opencode.json`.
Skip for now if
- You use a single AI agent and have no need to share capabilities across tools or teammates.
- Your compliance requirements prohibit routing capability discovery or execution traffic through a third-party-hosted remote MCP server.
- You need a fully self-hosted solution today — the remote MCP endpoint at api.openworklabs.com is the primary integration path documented in the README.
Risks and cautions
The MIT-licensed core app is straightforward to adopt for individual developers, but organizational use depends on the Fair Source-licensed Den, and all documented MCP integration routes through Different AI's hosted endpoint.
- The remote MCP server URL `https://api.openworklabs.com/mcp/agent` is the sole documented integration endpoint; no self-hosted MCP alternative is described in the README.
- OpenWork Den (the /ee directory) is licensed under the Fair Source License, not MIT, which may restrict redistribution or modification for some organizations.
- The project is at package version 0.0.0 in the root package.json, indicating early-stage development.
- OAuth-based organization selection requires a browser sign-in flow, introducing an external identity dependency.
- The security policy supports only the latest release and `dev` branch, meaning organizations running pinned older versions will not receive fixes.
- SECURITY.md specifies a 3-business-day acknowledgment SLA and a 7-business-day triage SLA for vulnerability reports.
- Vulnerability reports are accepted exclusively via private email to `ben@openworklabs.com`; public GitHub issues are explicitly discouraged for security disclosures.
- The Electron app interacts with the native OS keychain for credential storage; the `dev:worktree` mode defaults to a mock keychain to avoid blocking during development.
- Den's local development configuration includes a placeholder `DEN_DB_ENCRYPTION_KEY` (`local-dev-db-encryption-key-please-change-1234567890`) and a placeholder `BETTER_AUTH_SECRET`, both marked as not for production use.
- Den administrators can set desktop policies, restrict local model access, and control which app versions the organization can use — providing layered access governance.
Alternatives to compare
| Approach | When to use | Trade-off |
|---|---|---|
Claude Cowork (Anthropic) | You are fully embedded in the Anthropic ecosystem and do not need cross-agent capability sharing or self-hosting. | Proprietary, subscription-based |
| You want a command-line coding agent without a separate capability-sharing layer. | Proprietary | |
Cline | You want an open-source VS Code extension that acts as an autonomous coding agent with MCP support. | Free, open-source (Apache 2.0) |
OpenCode | You want the underlying agent framework that powers OpenWork and prefer to manage MCP connections yourself. | Free, open-source |
What this trend reveals
Team capability marketplaces
Den's marketplace model — publish a skill, assign it to an organization, team, or individual — creates a natural internal store where teams can package domain-specific agent skills (e.g., a custom Jira lookup or a proprietary API client) and distribute them without modifying each teammate's agent config.
Read the Den section of the README and test skill publishing with a small team using the `demo:den` script, which boots a local multi-org instance.
Anthropic-compatible plugin bridge
Den can import Anthropic-compatible plugins and expose their skills and remote MCPs through the OpenWork MCP. This lets organizations standardize on OpenWork as a single gateway even when their plugins originate from different vendors.
Import one existing Anthropic-compatible plugin into a local Den instance and verify that its skills appear via `search_capabilities`.
Inference provisioning for cost control
Den's ability to control which members and teams can use each model provider opens a path for organizations to route inference traffic through budget-capped, centrally provisioned endpoints rather than individual API keys.
Inspect the `dev:den:inference` script and the `INFERENCE_ADMIN_TOKEN` and `INFERENCE_PROXY_BASE_URL` variables in package.json to understand the proxy architecture.
RepoDaily verdict
OpenWork delivers a well-structured, MIT-licensed approach to sharing AI agent capabilities across multiple tools and team members. Its agent-first MCP design means you can evaluate the core value proposition in minutes without installing the desktop app. The real differentiator is Den — the Fair Source-licensed control plane that adds organizational governance — but its remote-hosted MCP dependency and early version numbers warrant careful evaluation before production deployment.