Cross-Platform Portability Landscape for AI Business Tools

Research question

Once you run a business out of a git repo with an AI coding agent reading it, one question follows: is it worth making the tool-specific layer portable across agents, or are the reference files and the issue tracker already the part that travels?

1. AI IDE Instruction Files — The Fragmentation and Convergence

Current State of Instruction Files

Every major AI coding tool now has its own instruction file format:

Tool	Instruction File	Format	Scope
Claude Code	`CLAUDE.md`	Markdown	Repo root + nested dirs
Cursor	`.cursor/rules/*.mdc` (new) / `.cursorrules` (legacy)	MDC with YAML frontmatter	Project root, glob-targeted
Windsurf	`.windsurf/rules/` + `global_rules.md`	Markdown	Workspace + global
GitHub Copilot	`.github/copilot-instructions.md`	Markdown	Repo root
Gemini CLI	`GEMINI.md`	Markdown	Repo root
Codex (OpenAI)	`AGENTS.md` / `codex.md`	Markdown	Repo root

Key Findings

Cursor has evolved from a single .cursorrules file to a .cursor/rules/ directory system supporting multiple rule files with YAML frontmatter, glob patterns for file-specific activation, and a rule priority hierarchy (Team > Project > User > Legacy). Character limits exist: 6,000 per rule file for Windsurf, no documented limit for Cursor’s new system.

Windsurf stores rules in .windsurf/rules/ with a 12,000 combined character limit across global and local rules. Simpler than Cursor’s system but the same concept: repo-level instructions consumed by an AI IDE.

The convergence point: All tools read Markdown from the repo. The file name differs but the content format is identical. A repo could ship CLAUDE.md, .cursorrules, .github/copilot-instructions.md, and AGENTS.md with overlapping content and each tool would consume its own file.

AGENTS.md — The Attempted Universal Standard

AGENTS.md is positioned as the unifying format. Key facts:

Created by: Sourcegraph, now stewarded by the Agentic AI Foundation under the Linux Foundation.
Adoption: 60,000+ open-source projects. Supported by OpenAI Codex, Google Jules, Cursor, GitHub Copilot, Windsurf, Gemini CLI, Aider, Zed, Warp, Devin, and 20+ tools.
Format: Plain Markdown, no required fields, no YAML frontmatter required. Closest file in directory tree takes precedence.
Claude Code support: Does NOT support AGENTS.md as of March 2026. Feature request exists (anthropics/claude-code#6235). Prediction market gives 62% chance of adoption in 2026. Workaround: reference AGENTS.md from within CLAUDE.md.
The gap: Claude Code is the only major tool that has not adopted AGENTS.md. Every competitor has rallied behind it.

2. MCP as Portability Layer

MCP Cross-Tool Support

The Model Context Protocol (MCP) has achieved genuine cross-platform status:

Tool	MCP Support	Notes
Claude Code	Full	Lazy loading via Tool Search (95% context savings)
Claude Desktop	Full	Original MCP client
Cursor	Full	Loads all tools at session start (no lazy loading)
Windsurf	Full	Standard MCP client
JetBrains IDEs	Full	Plugin-based
OpenAI (ChatGPT)	Full	Adopted March 2025
VS Code (Copilot)	Full	Via extensions

Key finding: An MCP server written once works across all these tools with minimal configuration differences. The protocol is genuinely portable.

Could Main Branch Skills Be MCP Tools?

There is an active ecosystem for converting between skills and MCP:

MCP-to-Skill converter exists (github.com/GBSOSS/-mcp-to-skill-converter) — converts MCP servers to Claude Skills with 90% context savings via progressive disclosure.
Claude Code as MCP server exists (steipete/claude-code-mcp) — lets Claude Code act as an MCP server so other tools can call it.
Skills vs MCP distinction: Skills are proactive (Claude knows when to apply them) and persistent across conversations. MCP tools are reactive (called when explicitly needed). Skills are better for workflows; MCP is better for tool access.

The honest assessment: Main Branch’s skills (e.g., /think, /ads, /vsl) are workflow orchestrators, not tool calls. They read multiple reference files, apply domain logic (voice, audience, proof), and produce structured outputs. This is fundamentally different from an MCP tool that exposes a single function. Repackaging /ads as an MCP tool would lose the orchestration — the skill needs to read soul.md, offer.md, audience.md, voice.md, and proof/testimonials.md in sequence, apply the ads framework, and produce output in the correct format. An MCP server could expose the individual steps but would require the calling tool to understand the orchestration.

Theoretical path: Skills could be decomposed into MCP servers that expose reference-reading and framework-application as tools, but the orchestration intelligence would need to live somewhere. In Claude Code, CLAUDE.md provides that orchestration context. In Cursor, .cursorrules or AGENTS.md would need to replicate it. The skill instructions themselves would need to be duplicated into each tool’s instruction format.

3. Anthropic Plugin Marketplace

Current State

Anthropic shipped a plugin/marketplace system with these characteristics:

marketplace.json in .claude-plugin/ directory defines available plugins and skills.
Skills format: A folder with a SKILL.md file containing YAML frontmatter (name + description) and Markdown instructions, plus optional scripts and reference folders.
Installation: /plugin marketplace add owner/repo — one command.
Works in: Claude Code and Cowork.
Private repos: Supposed to work via git credential helpers (“if git clone works, it works in Claude Code”). Reality: known authentication bugs. Workaround: clone locally and register the local path.
Enterprise marketplace: Anthropic launched department-specific plugins and custom plugin development tools for enterprise customers.
Community marketplace: anthropics/claude-plugins-official is the official directory. Submissions reviewed, “Anthropic Verified” badge for quality-checked plugins.

Cross-Platform Implications

The plugin marketplace is Claude Code-specific. The SKILL.md format, the marketplace.json registry, the /plugin marketplace add command — none of this works in Cursor, Codex, or Copilot. A plugin published to Anthropic’s marketplace is accessible only within the Anthropic ecosystem (Claude Code + Cowork).

However, the underlying skills are just Markdown + scripts in a Git repo. If Cursor or Codex adopted SKILL.md parsing (unlikely — they have their own systems), the same repo could serve both. More realistically, the repo is the portable unit: the instructions can be adapted for each tool, while the reference files and scripts remain shared.

4. Context Engineering as Industry Trend

The Convergence on Structured Markdown

“Context engineering” has become the dominant framing for what Main Branch has been doing since inception. Key developments:

Industry definition: Context engineering is the practice of deliberately designing and managing everything that flows into an AI model’s context window — instruction framing, state management, tool definitions, memory selection, and output shaping. This goes beyond “prompt engineering” (single-turn optimization) to encompass entire session and workflow design.

Multiple competing formats, same underlying idea:

Format	Creator	Purpose	Status
AGENTS.md	Sourcegraph / Linux Foundation	AI coding agent instructions	60K+ repos, broad adoption
SKILL.md	Anthropic	Teachable agent capabilities	Claude Code ecosystem
Agent-Flavored Markdown (AFM)	WSO2	Framework-agnostic agent definitions	Academic paper at ACM IUI 2026
Markdown for Agents	Cloudflare	Web content optimized for agents	Shipped Feb 2026, edge conversion

AFM (Agent-Flavored Markdown) is particularly relevant: it uses Markdown with structured YAML frontmatter to define agents in a platform-agnostic way. Presented at ACM IUI Workshops in March 2026. It separates instructions (natural language Markdown) from configuration (YAML frontmatter) — essentially what Main Branch’s reference files already do.

Cloudflare’s “Markdown for Agents” solves a different problem (web content to Markdown conversion, 80% token reduction) but reinforces the thesis: Markdown is the lingua franca for AI systems.

Codified Context as research topic: An arXiv paper (“Codified Context: Infrastructure for AI Agents in a Complex Codebase,” February 2026) formalizes the pattern of storing instructions and context in repo files for agent consumption.

Is There a De Facto Standard?

Yes, partially. The convergence is on:

Markdown as the format — universal agreement.
Git repos as the storage layer — universal agreement.
YAML frontmatter for metadata — widely adopted but not required by all formats.
Directory-scoped instructions — most tools support closest-file-wins traversal.

No convergence on: file naming (CLAUDE.md vs AGENTS.md vs GEMINI.md), skill/plugin packaging (SKILL.md vs custom formats), or orchestration (each tool handles multi-step workflows differently).

Main Branch’s Reference Architecture Is Already the Standard

Main Branch’s reference files (soul.md, offer.md, audience.md, voice.md) are structured Markdown in a Git repo with YAML frontmatter. This IS the emerging standard pattern for context engineering. The only thing that is NOT standard is the skill orchestration layer (the vip engine that reads these files and applies them through slash commands).

5. GitHub Issues as Universal Execution Layer

The Evidence Is Strong

GitHub issues have become a genuinely cross-platform execution primitive:

GitHub Copilot Coding Agent: Assign an issue to Copilot, and it plans the work, opens a PR, writes code, runs tests, and asks for review. Works like assigning to a teammate.

GitHub Agent HQ: You can now assign issues to Copilot, Claude, Codex, or multiple agents to compare approaches. Claude and Codex are available for Copilot Business and Pro users as of February 26, 2026.

GitHub Agentic Workflows (Technical Preview, Feb 2026): Automated, intent-driven repository workflows authored in plain Markdown, executed with coding agents in GitHub Actions. Workflows can respond to issue events, PR events, schedules, or manual dispatch. Support Copilot CLI, Claude Code, or OpenAI Codex as the execution engine. Security-first: read-only by default, sandboxed execution, network isolation.

OpenAI Codex: Functions as an autonomous agent that works independently in isolated environments. GitHub integration allows Pro+ and Enterprise users to assign issues directly to Codex agents. Performance: 1,500 PRs merged over five months with three engineers, averaging 3.5 PRs per engineer per day.

The Issues-as-Execution Pattern

The pattern that is emerging:

Decision/Intent → GitHub Issue → Agent picks up issue → PR created → Review → Merge

This works across:

Claude Code (reads issues via gh CLI or MCP)
OpenAI Codex (native GitHub integration)
GitHub Copilot (native issue assignment)
GitHub Agentic Workflows (issue events as triggers)
Any tool that can read a Git repo

Security concern: Attackers can craft hidden instructions inside GitHub issues that AI agents process, giving silent control of the agent (prompt injection via issues). This is an active security research area.

6. Synthesis — The Portability Map

What Is Genuinely Cross-Platform

Layer	Portable?	Evidence
Reference files (Markdown in Git)	YES — fully portable	Every AI tool reads Markdown from repos. This is the universal format.
GitHub issues (execution primitive)	YES — fully portable	Copilot, Claude, Codex, Agentic Workflows all consume issues.
MCP servers (tool access)	YES — broadly portable	Works across Claude Code, Cursor, Windsurf, JetBrains, ChatGPT.
Instruction files (CLAUDE.md)	PARTIALLY — name differs	Same content, different filenames per tool. Trivial to maintain multiple.
Skills (vip engine slash commands)	NO — Claude Code-specific	The orchestration layer, progressive loading, slash command routing are all Claude Code.
Plugin marketplace	NO — Anthropic ecosystem only	SKILL.md, marketplace.json, /plugin commands are Claude Code + Cowork.

The Two-Layer Architecture

The research reveals a clean two-layer split:

Layer 1: The Brain (Portable)

Reference files (soul.md, offer.md, audience.md, voice.md)
Research files (dated Markdown investigations)
Decision files (dated choices with rationale)
GitHub issues (execution tasks)
Git history (the audit trail)

Any AI tool — Claude Code, Cursor, Codex, Copilot, a future tool that does not exist yet — can read these files and understand the business. The reference architecture IS the portability layer. It always has been.

Layer 2: The Skills (Platform-Specific)

Slash command routing (/think, /ads, /vsl)
Progressive reference loading (tier system)
CLAUDE.md as orchestration context
Plugin marketplace distribution
vip engine skill discovery

This layer is Claude Code-specific and there is no practical path to making it work identically in Cursor or Codex. However, the underlying instructions in SKILL.md files are Markdown — they could be adapted into AGENTS.md or .cursorrules for other tools.