Use Radzor with AI Agents

Run npx radzor@latest init in your project root. It generates context files for every major AI coding agent, plus a project-wide registry of installed components.

$ npx radzor@latest init

✓ Created radzor.json
✓ Created CLAUDE.md (Claude Code)
✓ Created .cursorrules (Cursor)
✓ Created .windsurfrules (Windsurf)
✓ Created .github/copilot-instructions.md (GitHub Copilot)
✓ Created .clinerules (Cline)
  Configuring MCP server for supported IDEs...
✓ Created .cursor/mcp.json (Cursor)
✓ Created .vscode/mcp.json (VS Code (Copilot))
  Registry created (no components installed yet)

  Components will be added to components/radzor/
  Run `radzor add <component>` to get started

That's it. Your agent now knows about Radzor. Every time you run radzor add, the registry file is automatically updated.

Every AI coding agent has a way to receive project-level context — a file it reads at the start of each conversation. radzor init generates the right file for each agent with instructions that tell it:

• Where to find installed components
• To read radzor.manifest.json before using any component
• To read llm/integration.md for step-by-step integration patterns
• To respect composability.connectsTo when wiring components together

It also generates MCP config files (.cursor/mcp.json, .vscode/mcp.json) so your IDE can query all 100 component manifests via the @radzor/mcp server. Learn more →

# Radzor Components

This project uses Radzor components — AI-ready building blocks
with machine-readable manifests.

## Component Discovery

- Installed components live in `components/radzor/*/`
- Each component has a `radzor.manifest.json` describing its
  full API (inputs, outputs, events, actions)
- Each component has `llm/integration.md` with integration
  instructions
- Each component has `llm/examples.md` with usage examples
- The project-wide registry is in `radzor.registry.json`

## Rules

- ALWAYS read `radzor.manifest.json` before using or modifying
  a Radzor component
- Read `llm/integration.md` for the recommended integration
  pattern
- Respect the `composability.connectsTo` field when wiring
  components together
- When the user asks to add a new component, run
  `npx radzor@latest add <name>`

If a file already exists (e.g. you have a CLAUDE.md with your own rules), the Radzor section is appended between <!-- radzor:start --> / <!-- radzor:end --> markers. Running init again updates the section without duplicating it.

In addition to agent rule files, radzor init generates a radzor.registry.json at the project root. This file gives agents a single-read overview of every installed component — no need to parse multiple directories.

{
  "$schema": "https://radzor.io/schema/registry",
  "updatedAt": "2026-04-07T12:00:00.000Z",
  "components": [
    {
      "slug": "audio-capture",
      "name": "@radzor/audio-capture",
      "version": "0.1.0",
      "category": "audio",
      "description": "Capture audio from the microphone...",
      "path": "components/radzor/audio-capture",
      "composability": {
        "connectsTo": [{
          "output": "audioStream",
          "compatibleWith": [
            "@radzor/speech-to-text.input.audioStream"
          ]
        }]
      }
    },
    {
      "slug": "speech-to-text",
      "name": "@radzor/speech-to-text",
      "version": "0.1.0",
      ...
    }
  ]
}

The registry is automatically updated every time you run radzor add. To rebuild it from scratch (e.g. after deleting a component manually), run npx radzor@latest init again.

Here's what happens when a developer asks their AI agent to add a feature using Radzor components:

# Developer says:
"Add voice recording to my app"

# Agent reads radzor.registry.json → sees no audio component

# Agent runs:
$ npx radzor@latest add audio-capture

# Agent reads:
#   components/radzor/audio-capture/radzor.manifest.json
#   components/radzor/audio-capture/llm/integration.md

# Agent writes the integration code using the manifest's
# inputs, outputs, events, and actions — no guessing.

The agent never guesses at an API — it reads the manifest and the LLM integration docs to produce correct, type-safe code on the first try.