Agentify — Summary

Agentify is an "Agent Interface Compiler" — a CLI that reads an OpenAPI specification (Swagger 2.0 or OpenAPI 3.x) and generates up to 9 agent-consumable output formats: MCP server (with Dockerfile), CLAUDE.md, AGENTS.md, .cursorrules, Skills, llms.txt, GEMINI.md, A2A Card (Google Agent-to-Agent protocol), and a standalone CLI tool. The core value proposition is eliminating the N×M synchronization problem: as APIs evolve, maintaining separate CLAUDE.md, AGENTS.md, MCP server, and skill files by hand becomes impossible — Agentify regenerates all formats from one source of truth (the OpenAPI spec). The tool uses a pluggable emitter architecture with an intermediate representation (AgentifyIR), security scanning on both input (blocks eval/exec/Function injection) and output (scans generated code before writing), and a tiered generation strategy based on API scale (small: one tool per endpoint; medium: Tool Search + Lazy Loading; large: Code Execution + Docs Search). Tested on real APIs from 13 endpoints (Notion) to 1,093 endpoints (GitHub REST API). Compared to seeds, Agentify is unique in the catalog — it is the only tool that generates agent interface primitives (commands, skills, CLAUDE.md, MCP servers) as build artifacts from a formal API specification, treating agent interfaces the way code generators treat database schemas or protocol buffers.

Agentify — Overview

Origin

Created by koriyoshi2041. Published as agentify-cli on npm. The CLAUDE.md reveals an extensive pre-development research phase: 4 research reports, 7 expert reviews, 2 UX studies, and a 14-week milestone roadmap documented in the repository.

Philosophy

From the README:

"Your API has new users it doesn't know about yet — AI agents. Claude Code reads CLAUDE.md. Cursor reads .cursorrules. Codex and Copilot read AGENTS.md. And if you want your API callable as a tool, you need an MCP server. That's a lot of files to write and keep in sync with your API spec. Agentify reads your OpenAPI spec and writes them all."

Vision Statement (from CLAUDE.md)

The CLAUDE.md reveals the broader product vision:

• Tagline: "One command. Every agent speaks your product."
• Core experience: npx agentify-cli transform <openapi-url> → complete Agent interface suite
• 5-level product maturity model (L0-L4): L4 = Agent-Native with full interface suite. "L4 currently doesn't exist; Agentify fills the gap."
• Time window concern: "Market intelligence researcher updated: Speakeasy $37.5M funding — window narrowed to 3-5 months" (March 2026)

Design Principles

1. Security Day 1: Input sanitization blocks eval/exec/Function constructor; output code is scanned before writing
2. Pluggable emitters: Each output format is a separate emitter implementing a simple emit(ir, options) interface
3. Tiered generation: API scale determines strategy — not every endpoint needs its own tool for large APIs
4. No ts-morph: Handlebars templates over ts-morph (removed per expert review — "15MB dependency, Handlebars is enough")
5. Flat IR: Simple AgentifyIR intermediate representation rather than Capability Graph (deferred to Phase 2)

Tested APIs

Agentify — Architecture

Distribution

• Type: npm package
• Binary: agentify-cli (via npx agentify-cli)
• Version analyzed: 0.4.1
• Runtime required: Node.js 18+
• Language: TypeScript (strict mode)
• Dependencies: Commander.js, Zod, @apidevtools/swagger-parser, @modelcontextprotocol/sdk, Handlebars, Vitest

Install Method

npx agentify-cli transform https://petstore.swagger.io/v2/swagger.json

Directory Tree

agentify/
├── src/
│   ├── cli.ts                # CLI entry point (Commander.js)
│   ├── index.ts              # Library export
│   ├── types.ts              # AgentifyIR intermediate representation
│   ├── parser/               # OpenAPI parsing + input sanitization
│   ├── generator/            # Pluggable emitters
│   │   ├── strategies/       # Tiered generation strategies (small/medium/large)
│   │   └── [emitter files]
│   └── security/             # Security scanner
├── test/                     # Vitest tests (136 tests)
├── docs/
│   └── demo.gif
├── self/                     # Self-generated documentation (dog-fooding)
├── CLAUDE.md                 # Extensive project CLAUDE.md (178 lines)
├── AGENTS.md                 # Concise project AGENTS.md
└── package.json

Pipeline

OpenAPI Spec (URL or file)
    |
    v
  PARSE → SANITIZE → ANALYZE → COMPILE → EMIT → SCAN → OUTPUT
             |            |          |        |       |
         Strip unsafe  Detect     Build IR  Run    Security
         patterns      domains,   (typed)   emit-  scan all
                       auth,                ters   generated
                       API scale                   code

Intermediate Representation (AgentifyIR)

type AgentifyIR = {
  title: string;
  description: string;
  baseUrl: string;
  version: string;
  auth: AuthConfig;
  apiScale: 'small' | 'medium' | 'large';
  domains: Domain[];
  capabilities: ParsedCapability[];
}

Tiered Generation Strategy

Emitters (9 output formats)

Agentify — Components

CLI Commands

transform Options

# Transform all 9 formats
npx agentify-cli transform https://petstore.swagger.io/v2/swagger.json

# Select specific formats
npx agentify-cli transform ./my-api.yaml -f mcp claude.md agents.md

# Generate standalone CLI tool
npx agentify-cli transform ./my-api.yaml -f cli -o my-api-cli

# Custom output directory and name
npx agentify-cli transform https://api.example.com/openapi.json -o ./output -n my-project

Emitter Interface

All emitters implement a simple interface:

import type { Emitter, AgentifyIR, EmitterOptions, EmitterResult } from "../types";

export class MyFormatEmitter implements Emitter {
  readonly name = "my-format";
  readonly format = "my-format";

  async emit(ir: AgentifyIR, options: EmitterOptions): Promise<EmitterResult> {
    return { format: this.format, filesWritten: [...], warnings: [] };
  }
}

Output Example (Petstore, all formats)

  Agentify v0.4.1
  Agent Interface Compiler

  +-- 20 endpoints detected -> SMALL API strategy
  +-- 3 domains identified (pet, store, user)
  +-- Auth: apiKey (SWAGGER_PETSTORE_API_KEY)
  +-- Strategy: Direct tool mapping — one tool per endpoint

  > Generated mcp + claude.md + agents.md + cursorrules + llms.txt + gemini.md + skills + a2a (15 files)
  > Output: ./swagger-petstore-mcp-server
  > Security scan: PASSED

Security Features

• Input sanitization: Blocks patterns: eval, exec, Function constructor, require/import in OpenAPI descriptions
• Prompt injection detection: Scans for injection patterns in API descriptions
• Output code scanning: All generated TypeScript is scanned before being written to disk
• Auto-normalization: Non-compliant specs (like httpbin) are auto-normalized with warnings

Tests

136 tests (Vitest). Integration tests use live Petstore API.

Self-Documentation (Dog-Fooding)

The self/ directory contains Agentify's own generated interface — the tool uses its own CLI to document itself.

Agentify — Uniqueness

differs_from_seeds

Agentify has no direct analog among the 11 seeds. It is the only tool in the catalog that treats agent interface files (CLAUDE.md, AGENTS.md, MCP servers, skills, .cursorrules) as compiled build artifacts derived from a formal API specification — analogous to how OpenAPI code generators produce client SDKs. Seed frameworks (superpowers, BMAD-METHOD, spec-driver) author CLAUDE.md/skills by hand to encode workflow conventions; Agentify generates them programmatically from API schema. The closest conceptual parallel is taskmaster-ai (which also uses a formal schema — task JSON — as input), but taskmaster-ai manages task execution while Agentify manages interface generation. Unlike all seeds, Agentify is a developer tool for API owners, not for AI agent users — it solves the "make my API accessible to AI agents" problem, not the "make my AI agent work better" problem.

Positioning

• Primary differentiator: OpenAPI-to-agents compiler. The only tool that reads a formal API spec and generates all agent interface formats as first-class artifacts, including Google A2A cards and standalone CLI tools.
• Secondary differentiator: Input and output security scanning. No other tool in the batch scans OpenAPI spec descriptions for prompt injection patterns before generating agent interfaces — a real supply-chain security concern for public APIs.
• Target user: API developers and companies who want to make their existing APIs accessible to Claude, Cursor, Copilot, and other AI coding tools without writing CLAUDE.md and MCP servers by hand.

Observable Failure Modes

1. Context window problem for large APIs: The CLAUDE.md notes: "GitHub MCP = 93 tools = 55K tokens" — even with tiered generation, large APIs generate context-heavy outputs that may hit Claude's context window.
2. Format staleness on API updates: Generated files must be regenerated when the OpenAPI spec changes; no watch mode or change detection in v0.4.1.
3. Early-stage competitive pressure: CLAUDE.md explicitly notes market intelligence: "Speakeasy $37.5M funding — window narrowed to 3-5 months" (March 2026). The tool is racing established API tooling vendors.
4. A2A Card niche: Google A2A protocol is early-stage; the value of this output format depends on ecosystem adoption.
5. Stars indicate early awareness (28): Despite 136 tests and real-world API validation, community adoption is early-stage.