Axiom: A Skills Registry for AI Agents

📅 Published:

What Is Axiom?

Axiom is a skills registry for AI agents — a searchable catalog of expert-authored workflows that an AI agent can find and execute on demand.

Most agent tool directories are flat lists. A name, a description, maybe some tags. You either know what you’re looking for or you don’t find it. And there’s no signal about whether the tool is any good.

Axiom is different in one fundamental way: every skill is scored. The formula is explicit and traceable:

SCORE = Q(40%) + U(25%) + F(15%) + M(10%) + S(10%)

Q — Quality        Manual vetting of skill structure and accuracy
U — Utility        Activation count from Axiom telemetry
F — Freshness      How recently the skill was updated
M — Maintenance    Commit velocity of the source repository
S — Social Proof   GitHub stars of the source repository (log-scaled)

The result is a living ranking where the best-performing skills surface to the top, not the most recently added ones.

The catalog covers real-world tasks: technical SEO audits, paid ad strategy, product roadmapping, content gap analysis, conversion rate optimization, GEO optimization, and more. Connect your agent once. When it needs a capability, it searches by intent, gets back scored results, retrieves the right workflow, and executes. The rest of the catalog never touches the context window.

How It Actually Works — A Complete Walkthrough

The easiest way to understand Axiom is to follow a real request from start to finish.

Scenario: You’re running an AI agent and you ask it:

“Audit the technical SEO of my website.”

Here’s exactly what happens:

Step 1: The Agent Searches the Registry

The agent doesn’t know which skill to use. It calls search_skills with your natural language query.

Agent → search_skills("audit the technical SEO of my website")

Axiom takes that query, converts it into a vector embedding using the bge-base-en-v1.5 model running on Cloudflare Vectorize, and runs a nearest-neighbor search across every skill in the registry.

It returns a ranked list:

1. technical-seo-checker  (88% reliability, ⭐ 1,436 source stars)
2. on-page-seo-auditor    (88% reliability, ⭐ 1,436 source stars)
3. seo-ops                (85% reliability, ⭐ 2,229 source stars)

No keyword matching. The agent asked in plain English. Axiom resolved it semantically.

Step 2: The Agent Retrieves the Skill Manifest

The agent picks the top result and calls get_skill_manifest.

Agent → get_skill_manifest("technical-seo-checker")

Axiom’s MCP Gateway fetches the SKILL.md file from its source GitHub repository and injects it directly into the agent’s context window. The manifest is a complete, structured execution workflow.

Step 3: The Agent Reads the Workflow and Executes

This is the critical part. A skill manifest is not a prompt. It’s a recipe.

Here’s what the agent receives — the actual technical-seo-checker manifest (v9.9.5), trimmed to the core:

## Instructions

When a user requests a technical SEO audit, execute these 9 steps:

1. Audit Crawlability — review robots.txt, sitemap discovery,
   crawl waste, redirect chains, and orphan patterns.

2. Audit Indexability — verify coverage, blockers (noindex,
   X-Robots, robots.txt, canonicals), duplicate signals, 4xx/5xx.

3. Audit Site Speed & Core Web Vitals — evaluate LCP/INP/CLS,
   resource weight, and highest-impact fixes.

4. Audit Mobile-Friendliness — viewport, layout fit, tap targets.

5. Audit Security & HTTPS — SSL health, HTTPS enforcement,
   mixed content, HSTS, security headers.

6. Audit URL Structure — URL patterns, parameters, redirect hygiene.

7. Audit Structured Data — schema validation, missing opportunities.

8. Audit International SEO (if applicable) — hreflang, locale targeting.

9. Generate Summary — scorecard, priority queue, quick wins, roadmap.

## Skill Contract

- Reads: current page state, prior audits from memory/
- Writes: scored audit report + summary saved to memory/audits/
- Next skill: on-page-seo-auditor (continue from infrastructure
  into page-level remediation)

The agent doesn’t have to figure out what “technical SEO audit” means. The skill tells it exactly what to do, step by step, what to produce, where to save it, and what to run next.

Step 4: Execution is Logged

Every activation is recorded in Cloudflare D1. The registry learns which skills are being used. High-activation skills surface higher in future searches.

That’s the complete loop. Query → Semantic search → Manifest injection → Execution → Logging.

Why This Is Better Than How Agents Are Usually Built

Most agents today bundle all their capabilities at startup. You define 20 tools in the system prompt, load them every single call, and hope the model picks the right one.

That approach has three failure modes:

1. Context bloat. Every tool description loaded upfront is tokens spent before the agent does anything useful. At any real scale, that’s thousands of tokens per call — before any actual work begins.

2. Hallucinated tool selection. When similar tools exist side by side in the context, models pick wrong ones or invent names that don’t exist.

3. Deployment coupling. Change a tool, redeploy the agent. There’s no separation between the agent’s logic and its capabilities.

Axiom separates them. The agent connects once. Skills arrive only when requested. An update to technical-seo-checker is live instantly — no agent redeploy, no system prompt change.

This is the same principle that made the web scale. DNS doesn’t preload every website into your browser. It resolves addresses on demand. Axiom is DNS for agent capabilities.

What’s Inside a Skill

A SKILL.md is a structured file that lives in a public GitHub repository. Every skill in the Axiom registry points to one. It has four parts:

SKILL.md
│
├── Frontmatter       → name, version, description, compatibility,
│                       when_to_use, allowed-tools, tags
│
├── Instructions      → the step-by-step workflow the agent follows
│
├── Skill Contract    → what it reads, what it writes,
│                       what it hands off to next
│
└── Reference links   → playbooks, templates, examples, edge cases

The paid-ads skill (v1.2.0) includes a platform selection guide that tells the agent which ad platform to recommend based on the user’s goals, a budget allocation framework, a creative testing hierarchy, and optimization levers for each failure mode (high CPA, low CTR, high CPM). The agent follows these frameworks rather than improvising from training data.

Skills are independently versioned. The community that authors them — engineers, marketers, product managers — maintains them in public GitHub repos. The Axiom registry indexes them and makes them discoverable.

The Architecture (Now That You Know the Flow)

Here’s how the pieces connect:

graph TD
    A["AI Agent\n(Claude / Gemini / Cursor)"] -->|MCP request over SSE| B

    subgraph CF_Pages["Cloudflare Pages"]
        B["/mcp Stabilizing Proxy\nNext.js 15"]
    end

    B -->|forwards JSON-RPC| C

    subgraph CF_Worker["Cloudflare Workers"]
        C["MCP Gateway\nusm-remote-mcp.reachsuren.workers.dev"]
        C --> D["search_skills\nVectorize semantic search"]
        C --> E["get_skill_manifest\nfetch SKILL.md from GitHub"]
    end

    D --> F[("Cloudflare Vectorize\nbge-base-en-v1.5")]
    E --> G["Source GitHub Repos\nSKILL.md files"]
    C --> H[("Cloudflare D1\nskills · sources · usage_logs")]

    I["Storefront\nskills-marketplace.pages.dev"] --> H
    I --> J["Registry Browser\nAPI Keys · Telemetry"]

Two layers:

The Storefront (Next.js 15, Cloudflare Pages) is what you see at axiom.builditwithai.xyz. It handles registry browsing, API key management, and telemetry. The /mcp route acts as a stabilizing proxy — it accepts agent requests and forwards them to the Worker. This decouples the UI from the protocol.

The MCP Gateway (Cloudflare Worker) is the engine. It handles the MCP protocol: the SSE handshake on GET /sse and JSON-RPC messages on POST /. When get_skill_manifest is called, it fetches the SKILL.md from GitHub, injects it into the agent’s context, and logs the activation to D1.

The Worker is stateless and globally distributed on Cloudflare’s edge. It has no cold start overhead. Skill delivery is fast.

Quick Start: 30-Second Setup

Connecting your agent to the full Axiom registry takes less than a minute. No complex installation, just a single config entry.

How to Connect Your Agent

Step 1. Get an Axiom Passport at axiom.builditwithai.xyz. Enter your email, verify with OTP, and you receive an API key. Takes 30 seconds.

Step 2. Add the MCP server to your agent client with your API key.

For Claude Desktop, add to claude_desktop_config.json:

{
  "mcpServers": {
    "axiom": {
      "url": "https://axiom.builditwithai.xyz/mcp?key=YOUR_API_KEY",
      "transport": "sse"
    }
  }
}

Step 3. Ask your agent to find a skill.

Search for a skill that can help me plan a product strategy.

The agent calls search_skills. The registry returns product-strategy-session with its score, usage count, and source stars.

Step 4. Run it.

Get the full manifest for product-strategy-session and run a
strategy session for my SaaS product targeting B2B teams.

The agent calls get_skill_manifest, receives the complete workflow, and runs a structured multi-phase strategy session: positioning, problem discovery, solution exploration, roadmap planning.

No fine-tuning. No system prompt changes. One key, the full catalog.

Have a skill repository you want listed? The source format is open — reach out.