Managing MCP Toolkits

We designed a centralized management system for Model Context Protocol (MCP) toolkits within the AI Catalog. This feature empowers developers to seamlessly create, configure, and manage collections of AI tools and agents, bridging the gap between raw code payloads and an intuitive, visual interface.

The problem:

Managing scattered AI tools and raw code payloads creates a high cognitive load for developers. Without a logical grouping system, configuring and updating these protocols manually increases the risk of system errors, security vulnerabilities, and broken integrations.

Goal:

• Consolidate management: Allow users to group related AI tools and agents into unified "Toolkits."
• Reduce cognitive load: Translate raw code into a clear, scannable visual layout (cards and drill-down views).
• Prevent user errors: Design robust validation for creating new toolkits and safe, reversible flows for destructive actions.

To build a unified Platform Agentic Framework, I analyzed the technical constraints of the Model Context Protocol (MCP) and mapped the daily workflows of developers managing AI assets. The goal was to understand how to present highly technical infrastructure without overwhelming the user.

Key insights

• Scattered workflows led to redundancy: Developers lacked a centralized way to discover and reuse Agents and Tools. A unified marketplace was essential to accelerate innovation and reduce duplicate efforts.
• High risk of configuration errors: Registering MCP servers involves complex metadata, JSON descriptors, and secure IAM configurations. Relying on manual entry would inevitably lead to broken integrations.
• Trust is a prerequisite for reuse: To confidently integrate an Agent or Tool, developers needed immediate visibility into its version history, input/output schemas, and security posture.

• System mapping - Collaborated closely with PMs and engineering to understand the MCP architecture, establishing a clear mental model that differentiates Agents, Tools, and Toolkits for the user.
• Information architecture - Designed a scalable catalog structure that supports robust filtering, free-text search, and quick access to integration snippets (UI, API, SDK, and LangChain clients).
• Wireframing the asset lifecycle - Created intuitive flows for registering and updating assets. Focused on auto-extracting tool references directly from code or JSON descriptors to minimize manual data entry.
• Iterative refinement & error prevention - Designed clear drill-down views for complex schema configurations. Added deliberate friction and clear warnings to destructive actions (like deleting an active toolkit) to prevent accidental disruptions to autonomous agent workflows.e…

The UI was designed around the principle of progressive disclosure - hiding complex backend configurations while keeping critical technical metrics highly accessible and scannable.

1. The Toolkit Catalog (Visualizing Infrastructure) Transformed fragmented protocol data into structured, scannable list and card views. Developers can instantly see the version, capability tags, and connection status of each toolkit, allowing for rapid discovery and reuse.

3. Friction-Based Guardrails (Error Prevention) Destructive actions and critical configurations were built with deliberate friction. The system actively checks for active dependencies and blocks incorrect inputs, forcing explicit validation before any destructive execution to safeguard production environments.

4. Deep Drill-Downs & Integration Snippets Designed a comprehensive detail view for each asset. It isolates complex input/output schemas into clear tabs and provides ready-to-copy configuration snippets for multiple channels (UI, API, SDK, and LangChain), making integration immediate.

Building this framework proved that deep AI infrastructure doesn't inherently require a high cognitive load for developers. By anchoring design decisions in system architecture and developer behavior, we turned a technical bottleneck into an intuitive, scalable asset management system.