Tencent Cloud AI Registry: Unified Governance for MCP Services, Agents & Skills

The article opens with a concrete problem: a large insurance group's technical lead could not answer how many Agents the organization runs. Claims, underwriting, customer service, and risk control each built their own agents on different platforms, leaving three basic questions unanswered — what MCP services exist, what each Agent can do, and what breaks when a capability changes. The author frames uncontrolled AI assets as "residents without household registration": they exist but lack discoverability, accountability, and change control.

Three "Loss-of-Control" Moments

Tools connected but ungoverned: Business capabilities sit in ERP, CRM, approval systems. Converting them to MCP services is easy; governing the resulting services — registration, health, caller permissions — is where control is lost.

Agents cannot self-describe: An Agent's capabilities, Skill dependencies, and supported protocols live only in code and prompts. If only the author can explain it, it is not yet a reusable asset.

Skills consumed once: Without versioning, rollback, deprecation impact analysis, and reuse mechanisms, a Skill remains a throwaway script rather than an accumulated asset.

The solution is not another platform but a catalog that provides directory, dossier, versioning, state, and permissions — a "household registration" for AI assets.

Tencent Cloud AI Registry: Three Architectural Differentiators

Not built from scratch: Leverages Tencent Cloud's years of microservice registry, health-check, and dynamic-push capabilities, retargeted from microservices to AI assets.

Runtime-agnostic: Unlike registries embedded in a specific Agent runtime, AI Registry is independent. Any Agent built with any framework on any platform registers via the A2A standard; private deployment is lightweight.

Beyond a list: Call-chain governance — routing, authentication, rate-limiting, circuit-breaking, canary — is delegated to the AI Gateway. The two products are integrated: once an asset is registered, the gateway can immediately govern its invocation. "Register to govern, invoke to control."

2.1 MCP Service Management: Zero-Code Onboarding for Legacy Systems

Real barriers lie in legacy HTTP services (ERP, CRM, approval flows) that must not be rewritten. AI Registry allows native MCP Servers to register directly; legacy HTTP services undergo a one-time protocol conversion to become MCP services. Registration is a by-product: protocol conversion, endpoint convergence, Tool synchronization, and instance health-checking happen together, so the service is governed the moment it enters.

Day-to-day operations focus on Tools and instances . Tools support five parameter types; enable/disable takes effect instantly without restart. Instances are continuously probed; unhealthy ones are auto-evicted, healthy ones auto-rejoined, with manual isolation for debugging. Namespaces isolate by team and environment; permissions reach down to specific users and groups. Every service surfaces four facts: endpoint, Tool list, health status, owner. Registration is automated via console, REST API, or Java SDK, embeddable in CI/CD or internal platforms.

2.2 Agent Management: Self-Maintaining Dossiers

Registering an Agent requires only service address, version, and capability declaration. Java stacks get an SDK that handles registration automatically. The system auto-generates an AgentCard per A2A standard, describing what the Agent does and which Skills it mounts, plus a standard discovery endpoint.

The dossier self-updates : Skill mount/unmount or registration changes sync automatically. A service-info snapshot ( svcSnapshot) is captured at creation, so backend scaling or migration never invalidates published cards. Skill mounting follows "only reduce, never expand" — declared capabilities cannot silently grow via backend changes, a constraint most asset-catalog products skip. Runtime visibility includes instance health, version, deployment location, with auto-eviction on anomaly and auto-rejoin on recovery. Namespaces and authorization enforce boundaries; permission changes take effect immediately. Uniform dossiers enable inter-Agent discovery and invocation.

2.3 Skill Management: From Script to Distributable Asset

Entry friction is low: fill a form or upload a ZIP with SKILL.md; the system parses and pre-fills. Governance kicks in after entry: every publish creates a version snapshot, enabling query and rollback. State machine: Draft, Online, Offline — Draft visible only to author; Online mountable; visibility further split into three tiers. Deprecation is guarded: before deletion, the system lists all dependent Agents so impact is visible — a step most catalog products omit.

Reuse is enabled through SkillHub : validated Skills are searchable, downloadable, and can be taken offline anytime. REST API and Java SDK embed reuse directly into CI/CD, eliminating manual copy-paste. Only then does a Skill become a versioned, distributable, reusable asset .

Customer Implementations

Large Insurance Group: Group-Wide AI Asset Governance

Typical "decentralized first, converge later": claims, underwriting, service, risk each built agents — IT's high-code Java agents (Spring AI) iterating with business systems, wanting auto-registration on deploy; business units built low-code agents on various platforms, scattered and invisible. Legacy underwriting/claims systems needed Agent access without heavy rewrite. Two hard constraints: permission model must align with existing private cloud; registry must not lock into a single vendor.

Four-step rollout:

Legacy systems converted to MCP services with zero code change, registered in MCP registry.

Agents via two paths: existing ones register via A2A (AgentCard auto-generated); IT's high-code agents integrate Java SDK (Spring AI) for auto-registration and heartbeat on app startup.

Skills pass three-state review, then published group-wide via SkillHub.

Integration with AI Gateway turns registration into controlled invocation.

Result: first group-wide list answering "how many assets, who can use, what breaks on change."

Top Auto Manufacturer: Multi-Platform Agent Unification

R&D, manufacturing, marketing built agents on different platforms, zero visibility across lines. Requirement: unify governance without binding to any development platform . Runtime-agnostic design was decisive: each line keeps its tools; registration via A2A makes them mutually discoverable and invocable.

Logistics State-Owned Enterprise: Group-Level Skill Reuse

Business units duplicated work — same document processing, route query Skills rewritten repeatedly. Goal: "verified capabilities shouldn't be rewritten every time." Skill registry provides versioned storage with auto-snapshots and rollback; three-state lifecycle with three visibility tiers; SkillHub lets one unit's validated Skill be consumed by others. Capability shifts from "author-only knowledge" to "group-wide query and reuse."

Three different starting points converge on one path: onboard legacy assets first, give new assets self-describing dossiers, then enable distribution and reuse of validated capabilities — three criteria to judge whether a registry is production-ready.

Capability Landscape: Seven Modules, All Live

Unified Registration & Resource Governance : Three asset types unified registration; legacy HTTP zero-code to MCP ; namespace isolation

Protocol Standardization & Capability Description : AgentCard auto-generation; A2A standard; service-info snapshot self-maintenance

Lifecycle & Version Management : Three-state machine; version snapshots & rollback; deprecation impact analysis

Health & Instance Management : Health checks & probing; anomalous instance auto-eviction; instance isolation

Permissions & Visibility : User/group authorization; three visibility tiers; draft forced private

Distribution & Reuse : SkillHub publish/offline; REST API & Java SDK

Observability : MCP & Agent invocation monitoring; instance health monitoring

All capabilities are live in Tencent Cloud console. The article highlights three gaps in typical asset-catalog products: legacy zero-code MCP conversion, AgentCard self-maintenance, pre-change impact analysis .

Selection Guide & Quick Start

Three questions for registry evaluation:

Can it govern legacy assets , not just newly built ones?

Is it decoupled from runtimes , or will it lock you to one platform?

Does registration become controllable invocation , or stop at a static list?

Three low-cost, fast-value starting actions:

Inventory legacy first: Convert running HTTP services via protocol adaptation, register in MCP registry — give legacy capabilities "household registration."

Govern new builds: New Agents register via A2A (AgentCard auto-generated); Java stacks use SDK for auto-registration and heartbeat on startup.

Enable reuse last: Collect validated Skills into SkillHub so the second team doesn't rewrite from scratch.

The value of a household registration lies not in the moment of registration, but in every subsequent query, change, and reuse having an auditable basis.