MCP market

MCP market

The MCP market is how AgentNet grows an open tool ecosystem. Anyone can participate - independent builders, teams, and enterprises - on two tracks. Both tracks assume AGIN for agent callers.

Auto-discovery: the platform continuously pulls streamable-http endpoints from the public MCP Registry, probes tools/list, and self-tunes frequency from demand signals. Only metadata and URLs are stored—no third-party credentials. Manual registration and auto-discovery share the same discoverable surface.

We use the open Model Context Protocol (MCP) idea of tools with JSON schemas. The market is for listing, discovery, and reuse - with AGIN so providers and users always know which agent is in the call path.

Build (publish connectors)

If you build tools - CRM helpers, ticket routers, data lookups, internal ops scripts - you can package them as MCP servers and list them for others to use. Same track for a solo project or an enterprise product team.

What to ship

1. Standard MCP tools + AGIN requirement

   Expose clear tool names, descriptions, and JSON input schemas. Declare that AgentNet callers present an AGIN identity card on every tools/call.

   Tool shape (JSON) · json Copy

   {
     "name": "crm_create_followup",
     "description": "Create a sales follow-up task in the caller's CRM. AIAGENTNET callers present an AGIN identity card on every tools/call.",
     "inputSchema": {
       "type": "object",
       "required": ["title", "due_at"],
       "properties": {
         "title": { "type": "string" },
         "due_at": { "type": "string", "format": "date-time" },
         "account_id": { "type": "string" }
       }
     },
     "annotations": {
       "agentnet": {
         "requires_agin": true,
         "caller_identity": "AGIN identity card on every tools/call"
       }
     }
   }

2. Accept AGIN on the call path

   AgentNet runtimes present the calling agent's AGIN identity card when invoking your tools. Your connector should read and retain caller identity for logs, quotas, and abuse control - not treat traffic as anonymous bots.

   JSON-RPC tools/call (what providers should handle):

   tools/call request · json Copy

   {
     "jsonrpc": "2.0",
     "id": 1,
     "method": "tools/call",
     "params": {
       "name": "crm_create_followup",
       "arguments": {
         "title": "Follow up with Acme",
         "due_at": "2026-07-10T17:00:00Z",
         "account_id": "acct_42"
       },
       "_meta": {
         "agentnet": {
           "agin_id": "agin_01EXAMPLE",
           "agent_principal": "agent:01EXAMPLE",
           "display_name": "Sales follow-up agent",
           "owner_context": "org:acme-demo",
           "call_id": "call_01EXAMPLE"
         }
       }
     }
   }

   tools/call result · json Copy

   {
     "jsonrpc": "2.0",
     "id": 1,
     "result": {
       "content": [
         { "type": "text", "text": "Follow-up task created." }
       ],
       "isError": false,
       "_meta": {
         "agentnet": {
           "agin_id": "agin_01EXAMPLE",
           "call_id": "call_01EXAMPLE",
           "receipt_hint": "provider should log agin_id + call_id + tool outcome"
         }
       }
     }
   }

   Remote HTTP transport (illustrative headers):

   HTTP (illustrative) · http Copy

   # Remote MCP: every tools/call presents the agent identity card.
   # Providers: log these for who-used-my-service. Exact names may stabilize with runtime releases.
   X-AIAGENTNET-AGIN-Id: agin_01EXAMPLE
   X-AIAGENTNET-Agent-Principal: agent:01EXAMPLE
   X-AIAGENTNET-Call-Id: call_01EXAMPLE
   Authorization: Bearer <caller-supplied-third-party-token-if-required>

   Public contract: every tool invocation is attributable to an agent AGIN, visible to the service provider. Field names above are product-level examples - not internal key paths or crypto specs.

3. Caller-supplied product credentials

   Do not bake customer API keys into your listing. Document which secrets the caller org must provide (e.g. their CRM token). AGIN answers which agent; product credentials answer which customer account at the third-party system.

4. Boundaries and failure honesty

   Document side effects, rate limits, and failure modes. Return real errors - never fake success when the upstream call failed. Prefer AGIN-based limits over pure IP bans when possible.

5. Listing metadata

   Capability summary, audience, required credentials, and that you support AGIN-bearing callers. That is what other users search and select on.

6. Register on the market

   Individuals and organizations use the same path: live registration form or POST /api/mcp/listings. Registration has no approval gate; tools appear under Live tools after discover when healthy.

Build checklist

• MCP tool/resource shape (names + schemas)
• AGIN-aware calls - log/attribute the calling agent; do not require anonymous access as the only mode
• Documented credential contract (caller brings third-party keys)
• Runnable package (stdio and/or remote MCP as you support)
• Human-readable listing: purpose, audience, risks
• No hardcoded production secrets

Use (consume connectors)

Consumers - solo operators or enterprise fleets - discover connectors and run them with agents that hold AGIN cards.

1. Choose a connector

   Pick from the market by capability. Prefer listings that state credentials, side effects, and AGIN support clearly.

2. Run agents with AGIN

   In AgentNet, AI employees are principals with identity cards - not anonymous scripts. When they call market tools, providers can see which agent acted. That is how you know who is using a service on your side, and how providers know who used theirs.

3. Supply your product credentials

   You (or your org) own third-party tokens. Configure them in the runtime - never paste production secrets into public tickets.

   Client config (JSON) · json Copy

   {
     "mcpServers": {
       "acme-crm": {
         "command": "npx",
         "args": ["-y", "@acme/crm-mcp", "--stdio"],
         "env": {
           "CRM_API_BASE": "https://api.acme-crm.example",
           "CRM_API_TOKEN": "<caller-supplied-third-party-token>"
         }
       }
     },
     "_comment_agentnet": "AIAGENTNET runtime injects AGIN on tools/call (which agent). CRM_API_TOKEN is your product credential (which CRM account). Do not put AGIN secrets in this env block."
   }

   AGIN identifies the agent (injected by AgentNet runtime on each call). Your CRM/mail token authorizes the third-party account. Both are required for accountable automation.

4. Call from an agent runtime

   After Free signup and delivery, agents on AgentOS X (built-in engine & tools) use market tools inside permission boundaries. People remain in the loop for checkpoints where you require them.

5. Keep evidence

   Successful product use leaves an auditable trail: AGIN + tool + outcome (receipt) - not only a chat line that the tool "probably worked."

   Receipt shape (JSON) · json Copy

   {
     "call_id": "call_01EXAMPLE",
     "agin_id": "agin_01EXAMPLE",
     "agent_principal": "agent:01EXAMPLE",
     "tool": "crm_create_followup",
     "status": "ok",
     "provider": "acme-crm",
     "outcome": "task_created"
   }

How AgentNet MCP differs from typical MCP setups

We stay compatible with the MCP tool model (named tools + schemas). Around that model we add AGIN, market listing, and multi-agent runtime - not only a single laptop IDE plugin.

Practical rule for builders: design stable tools and schemas first; wrap them as MCP for agents; attribute every call to AGIN. Do not invent a one-off private protocol just for AgentNet - and do not require reverse-engineering internal platform services that are not documented here.

Live catalog

Backed by the live platform MCP registry and supply index (after health probes). Public read APIs:

• GET /api/mcp/catalog - endpoints + tools
• GET /api/mcp/endpoints - registered MCP servers only
• GET /api/mcp/tools?q=&provider= - live tools (healthy / degraded)

curl -sS https://www.aiagentnet.cloud/api/mcp/catalog | jq '{endpoint_count, tool_count, endpoints: .endpoints[:3], tools: .tools[:5]}'

Register an MCP server (备案)

Share uses registration without an approval gate: list a streamable HTTP MCP endpoint with a provider slug and accountable publisher id. By listing, you signal that tool traffic from AgentNet will carry AGIN so you can tell which agent used your service. Discover probes run tools/list; tools appear under Live tools when healthy. Individuals and organizations use the same form.

POST /api/mcp/listings - declare AGIN support when you register:

{
  "provider": "acme-crm",
  "url": "https://mcp.acme-crm.example/mcp",
  "registered_by": "you@company.com",
  "agin_support": true,
  "summary": "CRM follow-up tools; requires caller CRM token; logs AGIN on every call"
}

curl -sS -X POST https://www.aiagentnet.cloud/api/mcp/listings \
  -H 'content-type: application/json' \
  -d '{"provider":"acme-crm","url":"https://mcp.acme-crm.example/mcp","registered_by":"you@company.com","agin_support":true,"summary":"CRM follow-up; AGIN on every call"}'

Examples

Build example - "follow-up task" connector

A builder (person or company) implements crm_create_followup, documents CRM_API_TOKEN as caller-supplied, logs AGIN / agent principal on every tools/call, packages an MCP server, and registers via Register.

Use example - sales agent

A team finds the provider in Live catalog, attaches their CRM token, and runs a sales AI employee that holds an AGIN card. The provider sees which agent created follow-ups; the team sees which agent acted. The human still owns the CRM account.

Website account tools (optional sample)

Small public sample of MCP wrapping website HTTP routes (no passwords in tool args). Tools map to: