# How OpenWork's Plugin System Integrates with Anthropic‑Compatible Plugins

> Discover how OpenWork integrates Anthropic-compatible plugins using its three-layer architecture for seamless API handling. Learn more about marketplace seeding, creation APIs, and runtime patches.

- Repository: [Different AI/openwork](https://github.com/different-ai/openwork)
- Tags: how-to-guide
- Published: 2026-08-01

---

**OpenWork integrates Anthropic‑compatible plugins through a three‑layer architecture: marketplace seeding, plugin creation APIs, and runtime patches that automatically handle Anthropic‑specific API requirements.**

The OpenWork platform treats **Anthropic‑compatible plugins** as first‑class citizens by mirroring the official Anthropic knowledge‑work‑plugins repository in a pre‑seeded marketplace, then applying transparent runtime patches to ensure seamless API compatibility. This integration allows developers to import, create, and execute Claude‑powered skills without manual configuration of headers, schemas, or model flags.

---

## Marketplace Seeding: The Default Anthropic Marketplace

When an organization is created in OpenWork, the system automatically provisions the **"Anthropic‑Compatible Plugins" marketplace**. This seeding mechanism is implemented in [`default‑marketplaces.ts`](https://github.com/different-ai/openwork/blob/dev/ee/apps/den-api/src/routes/org/plugin-system/default-marketplaces.ts).

The seeding process inserts three key elements into the database:

- `DEFAULT_ANTHROPIC_MARKETPLACE_NAME` – the display name for the marketplace
- `DEFAULT_ANTHROPIC_MARKETPLACE_DESCRIPTION` and `DEFAULT_ANTHROPIC_MARKETPLACE_LOGO_URL` – branding assets
- `DEFAULT_ANTHROPIC_STARTER_PLUGINS` – a curated list of plugin entries matching the [anthropics/knowledge‑work‑plugins](https://github.com/anthropics/knowledge-work-plugins) repository

These rows populate the `plugin` and `plugin_config_object` tables, making the marketplace instantly discoverable to all org members.

---

## Plugin Creation and Skill Bundling

OpenWork's plugin system centers on **skills** – executable units that plugins wrap and expose to the Model Context Protocol (MCP). The integration with Anthropic‑compatible plugins leverages two core APIs in [`cloud‑plugins.ts`](https://github.com/different-ai/openwork/blob/dev/evals/packages/behaviors/src/cloud-plugins.ts):

1. **`createPluginWithSkill`** – creates a plugin object, attaches a skill definition, and prepares it for publication
2. **`assignPluginToMarketplace`** – associates the plugin with the Anthropic marketplace for org‑wide discovery

The server‑side implementation in [[`store.ts`](https://github.com/different-ai/openwork/blob/main/store.ts)](https://github.com/different-ai/openwork/blob/dev/ee/apps/den-api/src/routes/org/plugin-system/store.ts) provides `createPluginBundle`, which packages skill metadata into the format expected by the OpenWork runtime.

---

## Runtime Patches for Anthropic API Compatibility

The deepest layer of integration happens automatically at server startup. OpenWork ships two built‑in plugins that transparently adapt requests to Anthropic's API requirements:

| Plugin | Function | Source File |
|--------|----------|-------------|
| `openwork‑anthropic‑tool‑schema` | Intercepts fetch calls and rewrites tool schemas that Anthropic would otherwise reject | [[`openwork-anthropic-tool-schema.ts`](https://github.com/different-ai/openwork/blob/main/openwork-anthropic-tool-schema.ts)](https://github.com/different-ai/openwork/blob/dev/apps/server/src/opencode-plugins/openwork-anthropic-tool-schema.ts) |
| `openwork‑anthropic‑adaptive‑thinking` | Injects model‑level flags and the `anthropic‑version` header required by Claude‑5 family models | [[`openwork-anthropic-adaptive-thinking.ts`](https://github.com/different-ai/openwork/blob/main/openwork-anthropic-adaptive-thinking.ts)](https://github.com/different-ai/openwork/blob/dev/apps/server/src/opencode-plugins/openwork-anthropic-adaptive-thinking.ts) |

These plugins are registered in [[`openwork-runtime-config.ts`](https://github.com/different-ai/openwork/blob/main/openwork-runtime-config.ts)](https://github.com/different-ai/openwork/blob/dev/apps/server/src/openwork-runtime-config.ts) and activate for all plugin executions across the organization. Developers importing Anthropic‑compatible plugins never need to handle these concerns manually.

---

## End‑to‑End Workflow: Importing an Anthropic Plugin

The complete lifecycle of bringing an external Anthropic plugin into OpenWork follows this pattern:

```typescript
// Step 1: Seed the marketplace (automatic on org creation)
await db.insert('marketplace', {
  name: DEFAULT_ANTHROPIC_MARKETPLACE_NAME,
  description: DEFAULT_ANTHROPIC_MARKETPLACE_DESCRIPTION,
  logoUrl: DEFAULT_ANTHROPIC_MARKETPLACE_LOGO_URL,
});

// Step 2: Create a plugin wrapping an Anthropic skill
import { createPluginWithSkill } from '@/evals/packages/behaviors/src/cloud-plugins';

const mySkill = {
  name: "SummarizeMeeting",
  description: "Summarizes a meeting transcript using Claude",
  // skill definition follows OpenWork schema
};

const plugin = await createPluginWithSkill(adminSession, {
  name: "Anthropic Meeting Summarizer",
  description: "Uses Claude to turn raw notes into a concise summary.",
  skill: mySkill,
});

// Step 3: Publish to the Anthropic marketplace
import { assignPluginToMarketplace } from '@/evals/packages/behaviors/src/cloud-plugins';

await assignPluginToMarketplace(adminSession, marketplaceId, plugin.id);

```

Once published, the plugin appears in the org's Anthropic marketplace and executes with automatic schema patching and model flag injection.

---

## Runtime Initialization

The server ensures Anthropic compatibility before any plugin runs:

```typescript
import { OpenWorkAnthropicToolSchema } from '@/apps/server/src/opencode-plugins/openwork-anthropic-tool-schema';
import { OpenWorkAnthropicAdaptiveThinking } from '@/apps/server/src/opencode-plugins/openwork-anthropic-adaptive-thinking';

await Promise.all([
  OpenWorkAnthropicToolSchema(),
  OpenWorkAnthropicAdaptiveThinking(),
]);
// All subsequent Anthropic API calls from plugins are properly adapted

```

This initialization in [[`openwork-runtime-config.ts`](https://github.com/different-ai/openwork/blob/main/openwork-runtime-config.ts)](https://github.com/different-ai/openwork/blob/dev/apps/server/src/openwork-runtime-config.ts) guarantees that tool‑calling, adaptive thinking, and Claude‑5 model features work without per‑plugin configuration.

---

## Summary

- **Marketplace seeding** pre‑populates the "Anthropic‑Compatible Plugins" marketplace for every new organization via `default‑marketplaces.ts`
- **Plugin creation APIs** (`createPluginWithSkill`, `assignPluginToMarketplace`) allow developers to bundle and publish Anthropic skills through the same interface as native OpenWork plugins
- **Runtime patches** (`openwork‑anthropic‑tool‑schema`, `openwork‑anthropic‑adaptive‑thinking`) automatically handle Anthropic‑specific API requirements without developer intervention
- The integration treats external Anthropic plugins as first‑class citizens, enabling seamless import from the official knowledge‑work‑plugins repository

---

## Frequently Asked Questions

### How does OpenWork handle Anthropic's strict tool schema validation?

OpenWork's **runtime patch automatically intercepts and rewrites tool schemas** before they reach Anthropic's API. The `openwork‑anthropic‑tool‑schema` plugin patches the global fetch implementation to sanitize request bodies, ensuring compatibility without requiring changes to imported plugin code.

### Can I use Claude‑5 models with OpenWork plugins?

Yes. The **adaptive‑thinking runtime patch** detects model identifiers in outgoing requests and injects the required `anthropic‑version` header and model flags. This happens transparently in `openwork‑anthropic‑adaptive‑thinking.ts` whenever a plugin invokes a Claude‑5 family model.

### Where do Anthropic‑compatible plugins appear in the OpenWork UI?

They appear in the **pre‑seeded "Anthropic‑Compatible Plugins" marketplace** that is created automatically when your organization is provisioned. The marketplace entries mirror the official Anthropic knowledge‑work‑plugins repository and can be browsed, installed, and executed like any native OpenWork plugin.

### Do I need to modify code when importing plugins from the Anthropic repository?

No modifications are required. The **three‑layer integration** (marketplace seeding, standard plugin APIs, and runtime patches) ensures that plugins from `anthropics/knowledge‑work‑plugins` work out of the box. You connect the repository through the GitHub connector, and OpenWork handles schema translation and header management internally.