Supported AI Tool Formats

Relevant source files

The following files were used as context for generating this wiki page:

• packages/webapp/src/app/blog/format-specifications-guide/page.tsx
• packages/webapp/src/app/blog/agents-md-deep-dive/page.tsx
• packages/webapp/src/app/blog/json-schemas-for-ai-prompts/page.tsx
• packages/converters/schemas/README.md
• packages/webapp/src/app/blog/write-once-distribute-everywhere/page.tsx
• packages/webapp/src/app/blog/distributable-intelligence/page.tsx
• packages/webapp/src/app/blog/copilot-deep-dive/page.tsx
• packages/webapp/src/app/blog/kiro-deep-dive/page.tsx
• packages/webapp/src/app/blog/openskills-cross-ide-compatibility/page.tsx
• packages/cli/src/commands/init.ts
• packages/converters/src/tests/from-agents-md.test.ts
• packages/webapp/src/app/blog/format-specifications-guide/linkedin.txt

The AI coding tool landscape is fragmented, with each IDE and assistant adopting its own proprietary format for prompts, rules, and skills. Some require strict YAML frontmatter, others use plain Markdown, and their capabilities vary widely. This fragmentation creates a significant maintenance burden for developers and package publishers who want to share AI-executable knowledge across different platforms.

PRPM (Prompt Package Manager) solves this problem by acting as a universal package manager and format converter. It supports over 8 major AI IDE formats, enabling a "write once, distribute everywhere" workflow. By maintaining comprehensive specifications and JSON schemas for each format, PRPM can perform semantically-aware conversions, allowing users to install any package in the format required by their specific tool. This system turns PRPM into a central hub for "distributable intelligence," bridging the gap between documentation and codemods.

Sources: packages/webapp/src/app/blog/format-specifications-guide/page.tsx:75-82, packages/webapp/src/app/blog/write-once-distribute-everywhere/page.tsx:50-57, packages/webapp/src/app/blog/distributable-intelligence/page.tsx:39-42, packages/webapp/src/app/blog/format-specifications-guide/linkedin.txt:1-5

Format Summary

The following table provides a high-level comparison of the primary AI tool formats supported by PRPM.

Format	File Location	Frontmatter	Required Fields	Key Features
agents.md	agents.md	None	None	Plain markdown, open standard, hierarchical lookup.
Cursor	.cursor/rules	Required	description	4 rule types (Always, Intelligent, File-specific, Manual), MDC format.
Claude Code	.claude/{agents,skills,commands}/	Required	name, description	allowed-tools, model selection, executable hooks.
Continue	.continue/rules/*.md	Required	name	File globs, content regex matching, alwaysApply logic.
Windsurf	.windsurf/rules	None	None	Plain markdown, single file, 12,000 character hard limit.
GitHub Copilot	.github/copilot-instructions.md	Optional	None	Two-tier system (repo-wide + path-specific), comma-separated patterns.
Kiro Steering	.kiro/steering/*.md	Optional	None	Inclusion modes, foundational file types (product.md, tech.md).
Kiro Hooks	.kiro/hooks/*.json	N/A (JSON)	name, when, then	Event-driven file automations (e.g., on file creation).

Sources: packages/webapp/src/app/blog/format-specifications-guide/page.tsx:92-163, packages/webapp/src/app/blog/agents-md-deep-dive/page.tsx:32-35

JSON Schemas and Validation

PRPM maintains a comprehensive set of JSON schemas for over 15 AI prompt formats and their subtypes. These schemas are the backbone of the PRPM ecosystem, providing a machine-readable source of truth for each format's structure, required fields, data types, and validation rules.

Sources: packages/webapp/src/app/blog/json-schemas-for-ai-prompts/page.tsx:43-46, packages/converters/schemas/README.md:5-11

This diagram illustrates the validation workflow when a package is published.

Core Functions of Schemas

1. Validation: Schemas are used by the prpm publish and prpm validate commands to ensure packages are correctly formatted before they are published to the registry. This prevents broken packages and provides clear, actionable error messages to authors.
2. Format Conversion: The conversion engine uses schemas to validate both the input and output of a transformation, ensuring that a package converted from Cursor to Claude, for example, is a valid Claude skill.
3. Developer Experience: By integrating schemas into an IDE (like VS Code's settings.json), developers get autocompletion, inline documentation, and real-time validation when authoring prompt files.
4. Documentation: The schemas themselves act as living documentation, containing descriptions, examples, and comments that link to official sources for each format.

Sources: packages/webapp/src/app/blog/json-schemas-for-ai-prompts/page.tsx:216-258, 281-291, packages/converters/schemas/README.md:5-11

All schemas are publicly available in the prpm repository and via a registry API.

• Source Repository: packages/converters/schemas/
• Registry API: https://registry.prpm.dev/api/v1/schemas/{format}.json

Sources: packages/webapp/src/app/blog/json-schemas-for-ai-prompts/page.tsx:556-571, 584-599

Format Conversion System

PRPM's core strength is its ability to automatically convert packages between all supported formats. This is what enables the "write once, distribute everywhere" philosophy.

This sequence diagram shows the process when a user installs a package with a target format.

The system relies on a few key principles:

• Canonical Format: Packages are stored in the registry in a universal internal format (canonical.schema.json). This format preserves core instructional content and common metadata.
• Schema-Driven Conversion: Converters map fields from the source format to the canonical format, and then from the canonical format to the target format, using the schemas as a guide.
• Best-Effort Transformation: The system preserves as much information as possible. Format-specific features that have no equivalent in the target format (e.g., Claude's allowed-tools when converting to Windsurf) are often documented as comments in the content to preserve intent.

Sources: packages/webapp/src/app/blog/format-specifications-guide/page.tsx:700-706, packages/webapp/src/app/blog/write-once-distribute-everywhere/page.tsx:121-137

Detailed Format Specifications

agents.md

The agents.md format is an open standard for providing project-specific guidance to AI agents, supported by tools like OpenAI Codex, GitHub Copilot, and Google Gemini. Its design philosophy is "radical simplicity."

• File Location: AGENTS.md at the project root. Some tools, like OpenAI Codex, support a hierarchical system where the nearest AGENTS.md in the directory tree takes precedence.
• Format: Plain Markdown. It explicitly forbids YAML frontmatter.
• Key Features:
  • Tool-Agnostic: Designed to work across multiple AI tools.
  • Simplicity: No required sections, special syntax, or configuration.
  • Hierarchical Precedence (Codex): Codex merges AGENTS.md files up the directory tree and supports AGENTS.override.md to replace parent instructions entirely.
  • Auto-Description: PRPM automatically extracts a description from the first paragraph of the file.
• JSON Schema: agents-md.schema.json

This diagram shows the hierarchical lookup used by OpenAI Codex.

Cursor

• File Location: Individual files within the .cursor/rules/ directory.
• Format: Markdown Components (MDC) with required YAML frontmatter.
• Frontmatter:
  • description (string, required): Human-readable description for AI rule selection.
  • globs (array of strings, optional): File patterns for rule application.
  • alwaysApply (boolean, optional): If true, the rule is always active.
• Key Features: Four rule application types (Always Apply, Apply Intelligently, Apply to Specific Files, Apply Manually).
• JSON Schema: cursor.schema.json

Sources: packages/webapp/src/app/blog/format-specifications-guide/page.tsx:173-200, packages/cli/src/commands/init.ts:68-71

Claude Code

• File Location: Organized by subtype into directories: .claude/agents/, .claude/skills/, .claude/commands/, and .claude/hooks/.
• Format: Markdown with required YAML frontmatter. Hooks are executable scripts.
• Frontmatter (Agents/Skills):
  • name (string, required): A lowercase identifier.
  • description (string, required): A brief overview.
  • allowed-tools (string, optional): Comma-separated list of tools the AI can use (e.g., "Read, Write, Bash").
  • model (string, optional): Specify which Claude model to use ("sonnet", "opus", "haiku").
• Key Features: Fine-grained tool restriction, per-agent/skill model selection, and event-driven executable hooks.
• JSON Schemas: claude-agent.schema.json, claude-skill.schema.json, claude-slash-command.schema.json, claude-hook.schema.json.

Sources: packages/webapp/src/app/blog/format-specifications-guide/page.tsx:243-290, packages/cli/src/commands/init.ts:76-88

Continue

• File Location: Markdown files in .continue/rules/*.md.
• Format: Markdown with required YAML frontmatter.
• Frontmatter:
  • name (string, required): Display name for the rule.
  • globs (string or array, optional): File path patterns.
  • regex (string or array, optional): Match rules based on file content patterns.
  • alwaysApply (boolean, optional): Tri-state logic for rule inclusion.
• Key Features: Can trigger rules based on file content via regex, in addition to file paths.
• JSON Schema: continue.schema.json

Sources: packages/webapp/src/app/blog/format-specifications-guide/page.tsx:334-364

Windsurf

• File Location: A single file at .windsurf/rules.
• Format: Plain Markdown with no frontmatter.
• Key Features:
  • Radical Simplicity: No metadata or configuration.
  • Hard Limit: Content is truncated beyond 12,000 characters.
• JSON Schema: windsurf.schema.json

Sources: packages/webapp/src/app/blog/format-specifications-guide/page.tsx:394-417, packages/cli/src/commands/init.ts:93-96

GitHub Copilot

• File Location: A two-tier system:
  1. Repository-wide: .github/copilot-instructions.md
  2. Path-specific: .github/instructions/*.instructions.md
• Format: Markdown. The repository-wide file is plain markdown, while path-specific files use optional YAML frontmatter.
• Frontmatter (Path-Specific only):
  • applyTo (string or array, optional): Glob patterns, can be a single comma-separated string.
  • excludeAgent (string, optional): Restrict rule to a specific agent ("code-review" or "coding-agent").
• Key Features: The two-tier system allows for global defaults with specific overrides. Also supports AGENTS.md.
• JSON Schema: copilot.schema.json

Sources: packages/webapp/src/app/blog/format-specifications-guide/page.tsx:450-482, packages/webapp/src/app/blog/copilot-deep-dive/page.tsx:47-75, 100-112

Kiro

Kiro uses a domain-organized system with "Steering Files" and "Hooks".

• Steering Files:
  • File Location: .kiro/steering/*.md.
  • Format: Markdown with optional YAML frontmatter.
  • Frontmatter:
    • inclusion (string, optional): "always", "fileMatch", or "manual".
    • fileMatchPattern (string, required if inclusion is fileMatch).
    • foundationalType (string, optional): Special files for core context: "product", "tech", or "structure".
  • Key Features: Rules are organized by domain (e.g., testing.md, security.md) and activated based on context.
  • JSON Schema: kiro-steering.schema.json
• Hooks:
  • File Location: .kiro/hooks/*.json.
  • Format: Pure JSON.
  • Structure: Contains when (trigger conditions like fileCreated) and then (actions like askAgent).
  • Key Features: Enables event-driven automation within the IDE.
  • JSON Schema: kiro-hooks.schema.json

Sources: packages/webapp/src/app/blog/format-specifications-guide/page.tsx:497-530, 563-603, packages/webapp/src/app/blog/kiro-deep-dive/page.tsx:41-60, 67-101

Conclusion

The prpm project provides critical infrastructure for the fragmented AI coding assistant ecosystem. By supporting and maintaining specifications for a wide array of tool formats, it enables developers and framework authors to create and distribute AI-executable knowledge that is portable and future-proof. The combination of a canonical internal representation, schema-driven validation, and a robust conversion engine allows prpm to serve as a universal bridge, promoting interoperability and accelerating the sharing of best practices across all major AI development platforms.

Sources: packages/webapp/src/app/blog/write-once-distribute-everywhere/page.tsx:206-221, packages/webapp/src/app/blog/distributable-intelligence/page.tsx:280-285