What Are the Core Components of the OpenWork Monorepo? A Technical Breakdown

OpenWork is a monorepo-based AI-agent platform built from three main surfaces: a desktop app, an MCP gateway, and a Den control plane, all organized under apps/, ee/, and packages/ directories.

The OpenWork monorepo unifies local-first desktop tooling with cloud-backed orchestration for AI agents. Understanding its architecture helps developers extend the platform, deploy custom skills, or self-host the control plane. This guide maps each core component to its source location, explains its responsibilities, and shows how they interconnect.

Desktop App: Local-First Agent Workspace

The desktop app delivers the end-user experience where agents interact with files, browsers, and scheduled automations. It splits across two directories:

• apps/app — React-based web UI
• apps/desktop — Electron shell that wraps the web UI

According to [AGENTS.md](https://github.com/different-ai/openwork/blob/dev/AGENTS.md), this surface supports chat on files, skill execution, browser automation, scheduled automations, and Anthropic-compatible plugins.

Entry Point Implementation

The Electron shell launches from apps/desktop/scripts/electron-dev.mjs:

// apps/desktop/scripts/electron-dev.mjs
import { createWindow } from "./src-tauri/main.ts";
createWindow(); // launches the Electron shell that loads the web UI from apps/app

The web UI dependencies are defined in [apps/app/package.json](https://github.com/different-ai/openwork/blob/dev/apps/app/package.json), while the desktop wrapper configuration lives in [apps/desktop/package.json](https://github.com/different-ai/openwork/blob/dev/apps/desktop/package.json).

OpenWork MCP Gateway: Universal Skill Interface

The MCP gateway exposes organization capabilities through a single URL endpoint. Located in ee/apps/den-api, it transforms assigned skills, plugins, and external connections into standardized MCP tools.

As implemented in [ee/apps/den-api/src/mcp/agent.ts](https://github.com/different-ai/openwork/blob/dev/ee/apps/den-api/src/mcp/agent.ts), the gateway implements two core tools:

// ee/apps/den-api/src/mcp/agent.ts
export const SEARCH_CAPABILITIES_TOOL_NAME = "search_capabilities";
export const EXECUTE_CAPABILITY_TOOL_NAME = "execute_capability";

These tools enable Codex, Claude Code, Cursor, or any MCP-compatible client to discover and invoke capabilities. The gateway aggregates connections to Google Workspace, Microsoft 365, and other MCP servers behind the unified api.openworklabs.com/mcp/agent endpoint.

OpenWork Den: Organizational Control Plane

The Den handles organization-wide infrastructure: inference provisioning, team management, policy publishing, and the marketplace for skills and plugins. It spans multiple services under ee/apps/den-* directories.

The server initialization in ee/apps/den-web demonstrates the control plane startup:

// ee/apps/den-web/app/(den)/dashboard/_components/den-server.ts
import { startDenServer } from "./server.ts";
await startDenServer(); // runs the organization control‑plane APIs

This backend powers both the MCP gateway and the desktop client, serving as the central authority for resource allocation and access control.

Shared Infrastructure: Packages and Tooling

Three top-level directories bind the surfaces together:

• packages/ — Reusable UI components, state utilities, and type definitions shared between desktop and web apps
• ee/ — Enterprise-exclusive services (Den services, MCP API, background workers)
• apps/ — Concrete application implementations (apps/app for web UI, apps/desktop for Electron shell)

This structure enables code reuse while maintaining clear boundaries between open-source surfaces and enterprise features.

Summary

• Desktop app (apps/app + apps/desktop) provides the local-first workspace for agent interaction
• MCP gateway (ee/apps/den-api) exposes unified search_capabilities and execute_capability tools for external clients
• Den control plane (ee/apps/den-*) manages organizations, inference, teams, and the skills marketplace
• Shared libraries (packages/, ee/, apps/) enable cross-surface code reuse and clear architectural boundaries

Frequently Asked Questions

Where is the OpenWork desktop app source code located?

The desktop app splits between apps/app (React web UI) and apps/desktop (Electron wrapper). The Electron entry point is apps/desktop/scripts/electron-dev.mjs, which loads the web UI built from apps/app.

What does the OpenWork MCP gateway do?

The MCP gateway at ee/apps/den-api converts organization skills, plugins, and external connections into standardized MCP tools. It exposes search_capabilities and execute_capability endpoints that any MCP-compatible client can call.

Is OpenWork Den open source?

The Den control plane resides under ee/apps/den-* directories, indicating enterprise-only licensing. The ee/ prefix throughout the monorepo denotes features restricted from the open-source distribution.

How do OpenWork components communicate?

The desktop app connects to the Den control plane for organization data and policy enforcement. The MCP gateway queries the same Den backend to resolve capabilities. Shared packages/ provide common types and utilities across all surfaces.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}