OpenWork Developer Documentation: Official Guides, Repository README, and Architecture References

OpenWork developer documentation is organized across three main sources—the official website for user-facing guides, the repository README for quick-start installation, and the /docs folder for architectural deep-dives and internal design specs.

The different-ai/openwork repository provides extensive resources for developers building on or contributing to the OpenWork platform. Whether you are connecting an AI agent via the MCP, deploying the OpenWork Den control plane, or developing modular skills, the project’s documentation covers the full stack from high-level tutorials to low-level implementation details.

Official OpenWork Developer Documentation Website

The primary entry point for users and developers is the official website. It hosts the full user-facing guide, installation steps, tutorials, and API reference.

Key contents include:

• Getting started guides and UI walkthroughs.
• Feature overviews and product updates.
• Links to the OpenWork Den control-plane documentation.
• The up-to-date version for the dev branch.

Repository README and Quick-Start Guides

The README.md at the root of the different-ai/openwork repository delivers a concise project overview. It is the fastest way to understand the project scope, install locally, and connect an external AI agent.

What you will find:

• Project description and download badges.
• Instructions for installing via an AI agent.
• Quick-start command: pnpm dev.
• MCP registration examples, including the opencode.json configuration snippet.

Deep-Dive Architecture Docs in /docs

For developers who need internal design specifications, the /docs directory in the repository contains architectural notes, deployment guides, and extension manifests. These files explain the runtime flow, data models, and release processes that power OpenWork.

Notable documents include:

• docs/memory-bank-architecture.md – Deep dive into the persistent storage model used by the Memory Bank.
• docs/marketplace-capabilities-architecture.md – Design of the marketplace and capability publishing pipeline.
• docs/extensions-manifest-foundation.md – Schema for extension manifests that power plugins and skills.
• docs/mcp-ui-control-profile.md – Profile creation, keychain mocking, and MCP UI interaction details.

Core Architectural Components

OpenWork is composed of several interconnected systems. The documentation maps each component to specific source files and design documents.

Desktop Application

The desktop client is an Electron-based application that runs the UI, stores the workspace locally, and communicates with the OpenWork Den via the MCP. According to the different-ai/openwork source code, the entry point is located in packages/app/src/main.ts within the packages/app workspace.

OpenWork Den Control Plane

The OpenWork Den is the control plane for multi-user, organization-wide management, covering model provisioning, skill and plug-in publishing, and access policies. The design is documented in docs/memory-bank-architecture.md and docs/marketplace-capabilities-architecture.md, which detail the data model and runtime flow.

MCP (Multi-Capability Provider)

The MCP provides a remote-procedure-call surface that agents such as Claude Code, Codex, Cursor, and OpenCode use to invoke OpenWork capabilities. The README includes an opencode.json example showing how to register the MCP endpoint.

Skills and Plugins

Skills and plugins are modular pieces written in TypeScript, Rust, or other languages. They expose specific functionalities like Google Workspace OAuth or Azure AKS provisioning. The /.warden/skills directory holds skill definitions, and docs/extensions-manifest-foundation.md outlines the manifest schema.

Profiles and Keychain Handling

Each developer worktree receives an isolated profile via the OPENWORK_DEV_PROFILE environment variable. Developers can optionally use a mock keychain for credential-free testing. These mechanics are explained in docs/mcp-ui-control-profile.md.

Developer Code Examples

The OpenWork developer documentation includes practical, copy-paste-ready snippets for common integration tasks.

Adding the OpenWork MCP to an OpenCode Agent

{
  "mcp": {
    "openwork": {
      "type": "remote",
      "enabled": true,
      "url": "https://api.openworklabs.com/mcp/agent",
      "oauth": {}
    }
  }
}

(This snippet is provided in the repository README.)

Starting a Local Development Instance

To launch a single worktree with the shared dev profile:

pnpm dev

To start with an explicit profile name and debugging ports:

OPENWORK_DEV_PROFILE=my-feature \
OPENWORK_ELECTRON_REMOTE_DEBUG_PORT=0 \
PORT=0 pnpm dev

(The command and its effects on profile handling are described in the README.)

Invoking a Capability from an AI Agent

For Codex CLI:

codex mcp add openwork --url https://api.openworklabs.com/mcp/agent

(Installation instructions are maintained in the README.)

Essential Developer Files

File	Purpose	Location
README.md	Project overview, install prompts, MCP registration examples.	README.md
AGENTS.md	Describes how OpenWork interacts with external agents and the MCP workflow.	AGENTS.md
packages/app/src/main.ts	Entry point of the Electron desktop client.	main.ts
docs/memory-bank-architecture.md	Persistent storage model and Memory Bank design.	Memory Bank Architecture
docs/marketplace-capabilities-architecture.md	Marketplace design and capability publishing pipeline.	Marketplace Capabilities Architecture
docs/extensions-manifest-foundation.md	Extension manifest schema for plugins and skills.	Extensions Manifest Foundation
docs/mcp-ui-control-profile.md	Profile creation, keychain mocking, and MCP UI details.	MCP UI Control Profile

Summary

OpenWork developer documentation spans three tiers of depth:

• Official website – Best for user-facing guides, UI tutorials, and the latest dev branch API references.
• Repository README – Ideal for quick installation, local development with pnpm dev, and AI agent MCP registration.
• /docs folder – Required reading for architecture decisions, deployment scripts, skill manifests, and profile handling.

Frequently Asked Questions

What are the main sources of OpenWork developer documentation?

The primary sources are the official website at openworklabs.com/docs, the repository README.md, and the /docs directory inside the different-ai/openwork repository. Each layer targets a different level of detail, from high-level user guides to internal architectural specifications.

How do I start local development after reading the documentation?

Run pnpm dev from the repository root to launch the Electron desktop client with the shared development profile. You can also set OPENWORK_DEV_PROFILE to isolate your worktree, as documented in the README and docs/mcp-ui-control-profile.md.

Where is the OpenWork desktop application entry point documented?

The Electron desktop client entry point is packages/app/src/main.ts inside the packages/app workspace. The README references this structure under the local development section, and runtime details are covered in the architecture docs.

Which document explains how to register an AI agent with OpenWork?

The repository README.md contains MCP registration examples, including the opencode.json configuration and the codex mcp add CLI command. For deeper integration workflows, see AGENTS.md at the repository root.

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