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

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.

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 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:

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/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/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/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/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:

// 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:

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/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.

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