Export formats

phyla turns one agent configuration into ready-to-use files for 11 agent platforms across the Claude, OpenAI, and Microsoft ecosystems. Configure your agents, skills, commands, rules, hooks, and MCP servers once — then export to any target below.

Supported platforms

Exports come in two shapes:

Repo files — committable files (like CLAUDE.md or .cursor/rules/*.mdc) you drop into your project and your tool picks up automatically.
Config artifacts — for cloud, portal, and API products, phyla generates the manifest, API payload, or SDK code you paste into a portal, POST to an API, or run as a script.

Platform	Vendor	Export shape	What you get
Claude Code	Anthropic	Repo files	`CLAUDE.md` + a full `.claude/` tree (agents, skills, commands, rules, settings) and `.mcp.json`
Claude Cowork	Anthropic	Plugin bundle	A Claude Code plugin: `plugin.json`, `marketplace.json`, agents, skills, commands, hooks, and MCP
Claude Managed Agents	Anthropic	API payload	A `POST /v1/agents` JSON body for Anthropic’s hosted agents, plus a deploy guide
Cursor	Cursor	Repo files	A native `.cursor/` tree: skills, commands, `rules/*.mdc`, `hooks.json`, and `mcp.json`
ChatGPT (Custom GPT)	OpenAI	Manual paste	A Custom GPT manifest plus an Actions OpenAPI schema for the GPT editor
OpenAI Agents SDK	OpenAI	SDK code	A runnable Python agent (with tools, handoffs, and MCP) and `requirements.txt`
OpenAI Responses API	OpenAI	API payload	A Responses API request payload plus a ready-to-run cURL command
OpenAI Codex	OpenAI	Repo files	An `AGENTS.md` plus a `.codex/` tree: subagents, skills, prompts, and a `config.toml` with your model and MCP servers
Azure AI Foundry	Microsoft	Config + SDK	A declarative agent YAML and an `azure-ai-projects` SDK snippet
M365 Agents Toolkit	Microsoft	App package	A `declarativeAgent.json` + `manifest.json` app package for Microsoft 365 Copilot
Copilot Studio	Microsoft	Import bundle	A `declarativeAgent.json` import bundle for Microsoft Copilot Studio

What maps where

Different platforms support different building blocks. Where a platform has no native concept for one of phyla’s entity types, phyla flattens it into the platform’s instruction file (or the closest equivalent) so nothing is silently lost.

Legend: ✅ native · 🔁 flattened or adapted · ❌ not supported

Platform	Agents	Skills	Commands	Rules	Hooks	MCP
Claude Code	✅	✅	✅	✅	✅	✅
Claude Cowork	✅	✅	✅	🔁	✅	✅
Claude Managed Agents	✅	🔁	❌	🔁	❌	🔁
Cursor	✅	✅	✅	✅	✅	✅
ChatGPT (Custom GPT)	✅	🔁	🔁	🔁	❌	🔁
OpenAI Agents SDK	✅	🔁	🔁	🔁	🔁	✅
OpenAI Responses API	✅	🔁	🔁	🔁	❌	✅
OpenAI Codex	✅	✅	✅	🔁	❌	✅
Azure AI Foundry	✅	🔁	🔁	🔁	❌	✅
M365 Agents Toolkit	✅	🔁	🔁	🔁	❌	🔁
Copilot Studio	✅	🔁	🔁	🔁	❌	🔁

A few things worth knowing:

Full fidelity: Claude Code and Cursor support every entity type natively, including hooks and MCP. They’re the best targets if you want a 1:1 export.
Hooks only exist on Claude Code, Cursor, and Claude Cowork. Hosted and API-based agents have no client-side hook lifecycle, so hooks are dropped (the OpenAI Agents SDK gets a commented guardrail scaffold instead).
MCP maps natively wherever a platform has a tool or MCP concept. On API-only targets it narrows to remote (URL) MCP servers; on instruction-only targets it becomes a tool reference or an OpenAPI/Actions stub.

Format details

Claude Code — `CLAUDE.md` + `.claude/`

The richest target. phyla writes a CLAUDE.md at your project root plus a .claude/ directory with separate files for each agent, skill, command, and rule, a settings.json for hooks, and a .mcp.json for MCP servers.

CLAUDE.md
.claude/
  agents/<name>.md
  skills/<name>/SKILL.md
  commands/<name>.md
  rules/<name>.md
  settings.json
.mcp.json

Cursor — `.cursor/`

A native Cursor workspace. Rules become .mdc files with frontmatter and glob scoping; skills, commands, hooks, and MCP each map to their own .cursor/ artifact.

.cursor/
  skills/<name>/SKILL.md
  commands/<name>.md
  rules/<name>.mdc
  hooks.json
  mcp.json

OpenAI Codex — `AGENTS.md` + `.codex/`

A native Codex workspace, read by the Codex CLI, IDE extensions, desktop app, and cloud runner alike. Your main agent and rules become an AGENTS.md at the project root; subagents, skills, and commands each map to their own .codex/ artifact; and your model and MCP servers land in config.toml.

AGENTS.md
.codex/
  agents/<name>.toml
  skills/<name>/SKILL.md
  prompts/<name>.md
  config.toml

Cloud & API targets

For ChatGPT, the OpenAI Agents SDK and Responses API, Azure AI Foundry, the M365 Agents Toolkit, and Copilot Studio, phyla generates the manifest, payload, or code artifact each product expects. Because these aren’t committable repo files, phyla surfaces them in-app with explicit guidance on where to paste, POST, or run them.

Choosing a format

Working in an editor or CLI? Use Claude Code or Cursor for full fidelity.
Shipping a reusable Claude plugin? Use Claude Cowork.
Building on OpenAI? Use Codex for a native repo-file setup (its CLI, IDE, and cloud all read it), the Agents SDK for runnable code, the Responses API payload for a direct API call, or Custom GPT for the ChatGPT UI.
In the Microsoft stack? Use Azure AI Foundry, M365 Agents Toolkit, or Copilot Studio.