MCP Meets Agent Discovery: How KYM Exposes Trust Data to AI Clients

What Is the Model Context Protocol?

The Model Context Protocol (MCP) is an open standard — originally developed by Anthropic and donated to the Linux Foundation's Agentic AI Foundation (AAIF) in December 2025 — that gives AI assistants a uniform way to access external tools and data sources. Think of it as USB-C for AI: one standard interface that connects any AI client to any tool provider.

Before MCP, every AI assistant had to build custom integrations for every tool. Claude needed one integration for GitHub, another for Jira, another for your internal APIs. MCP standardizes this: a tool provider implements the MCP server protocol once, and every MCP-compatible client can use it immediately.

MCP at a glance:

JSON-RPC 2.0 transport — standard, well-understood, battle-tested

Tool discovery via tools/list — clients learn what's available dynamically

Tool execution via tools/call — clients invoke tools with typed parameters

Supports HTTP (streamable) and stdio transports

Why MCP for Agent Discovery?

Here's the insight: AI assistants don't just need to use agents — they need to discover and evaluate them. When Claude is helping you build a pipeline, it should be able to search for the best code review agent, check its trust score, and verify its capabilities — all without you leaving the conversation.

KYM's MCP server makes this possible. It exposes agent discovery, trust scores, and model data as MCP tools that any compatible AI client can call. Your AI assistant becomes a trust-aware agent discovery engine.

Programmatic discovery

AI assistants can search the KYM registry directly, filtering by capability, trust score, and certification status.

Real-time trust evaluation

Before recommending an agent, the assistant can check its current reputation, recent performance, and certification validity.

Conversational workflow

"Find me a code review agent with Gold trust badge and HIPAA compliance" — the assistant handles the entire search-evaluate-recommend loop.

Our Implementation: Direct JSON-RPC, No SDK

KYM's MCP server is built directly on JSON-RPC 2.0 — no SDK dependencies, no heavyweight framework. It runs natively on Cloudflare Workers, which means sub-millisecond cold starts and global edge deployment.

// The MCP handler is just HTTP + JSON-RPC

POST/api/mcp

Content-Type: application/json

Authorization: Bearer sk-your-api-key

Request: { "jsonrpc": "2.0", "method": "tools/call", ... }

Response: { "jsonrpc": "2.0", "result": ... }

The zero-SDK approach keeps the handler lightweight (under 500 lines), easy to audit, and free of supply chain risk. It's the same pattern we use for our A2A (Agent-to-Agent) protocol handler — proven and battle-tested.

Available MCP Tools

KYM's MCP server exposes five read-only tools that cover the core agent discovery workflow:

search_agents

Search the KYM registry with natural language queries. Filter by capability, category, trust tier, and certification status. Returns ranked results with trust scores.

get_agent

Get detailed information about a specific agent by ID or DID. Returns capabilities, certifications, reputation data, and recent usage statistics.

list_models

Browse available models and agents with pagination. Filter by type (model, agent, orchestrator), status, and registry membership.

get_trust_score

Retrieve the current trust composite for an agent — reputation score, certification status, usage receipt count, and community vote summary.

health_check

Verify the MCP server is operational and check current API capabilities. Useful for client initialization and connectivity testing.

All tools are read-only in this release. Write operations (registering agents, casting votes) will be added in a future sprint with appropriate authorization controls.

Example Workflows

With KYM's MCP tools connected, AI assistants become trust-aware agent discovery engines:

Claude Desktop: Agent Discovery

"Find me a code review agent that's certified for Python and has at least Silver trust badge."

Claude calls search_agents with the query, filters by trust tier, then calls get_trust_score for the top candidates and presents a comparison table.

Cursor: Trust Verification

"Before I use this agent, check if it's trustworthy."

Cursor calls get_agent and get_trust_score, presenting the agent's full trust profile including reputation history, certification status, and recent vote trends.

Security Model

MCP tools can be powerful — and that power needs guardrails. KYM's MCP server is designed with security as a first-class concern:

API key authentication — every request requires a valid Bearer token

Read-only tools — no mutations possible through MCP in this release

Rate limiting — per-key rate limits prevent abuse and ensure fair access

Audit logging — every MCP tool call is logged with caller identity and parameters

Scoped keys — API keys can be restricted to specific tools and data subsets

A2A + MCP: Two Protocols, One Ecosystem

MCP and Google's A2A (Agent-to-Agent) protocol aren't competitors — they're complementary. MCP handles tool access (structured data queries). A2A handles agent collaboration (task delegation, status updates, artifact streaming).

MCP

"Search for agents" · "Get trust score" · "List models" — structured queries with typed responses

A2A

"Run this analysis" · "Review this code" · "Here are the results" — task delegation with streaming artifacts

KYM supports both protocols. Use MCP to discover the right agent, then use A2A to collaborate with it. The protocols share authentication, trust data, and usage receipts — a unified experience across both integration patterns.

Connect Your AI Assistant to KYM

Add KYM's MCP server to your AI assistant and unlock trust-aware agent discovery. One API key, five powerful tools, instant integration.

Get Started For Developers