Mathias Markl

Posted on Apr 7

How I Gave My AI Agents a Dynamic MCP Marketplace

#agents #mcp #showdev #tooling

I've written before about agent-comm, agent-tasks, and agent-knowledge — tools for giving AI coding agents coordination, task management, and persistent memory. But there was still one friction point I hadn't solved: getting the right MCP servers in front of the agent in the first place.

The problem with static MCP configs is that everything is always on. Every server you've ever registered is running whether you need it or not. You want to add a new tool? Edit a JSON file, restart your agent. You want to try something from the official MCP registry? Good luck figuring out what's available and how to install it without leaving your coding session.

I built agent-discover to fix this.

The problem

When you configure MCP servers in Claude Code (or any MCP client), you write a static config file. That list is fixed. All those servers load at startup. If you want to browse what else is out there, you leave the agent, search the internet, manually edit the config, and restart.

It doesn't sound that bad until you're in the middle of a session and realize you need a filesystem tool, or a browser tool, or a database connector — and you have to break your flow to set it up.

There's also a more subtle problem: with a long list of always-on servers, your agent's context is crowded with tools it may never use. Less signal, more noise.

The fix: a runtime MCP marketplace

agent-discover is an open-source MCP server registry and marketplace. It acts as a dynamic proxy — you add it to your MCP config once, and from then on your agent can discover, install, activate, and manage other MCP servers without ever leaving the session.

The key mechanic: activated servers have their tools merged into agent-discover's own tool list, namespaced as serverName__toolName. Your agent can call filesystem__read_file without knowing anything about how the filesystem server is configured. Activate, use, deactivate — no restarts, no config edits.

What agents can do with it

1. Browse the official MCP registry

The registry tool with action browse proxies to registry.modelcontextprotocol.io. Your agent can search by keyword, see descriptions and versions, and install directly from results — all in a single tool call.

2. One-call install

registry(action="install", name="filesystem")

That's it. agent-discover registers the server in a local SQLite database, pre-downloads the npm package in the background, and it's ready to activate.

3. On-demand activation

registry_server(action="activate", server_id="filesystem")

The server starts, its tools get discovered and namespaced, and they appear in your tool list immediately. No restart. Deactivate when you're done and the tools disappear just as cleanly.

4. Secret management

API keys and tokens live in per-server secret storage — not in your config file, not in env vars that leak across sessions. They're automatically injected on activation, as env vars for stdio servers or HTTP headers for SSE/streamable-http servers.

5. Health checks and metrics

Every activated server gets health probes — connect/disconnect checks for inactive servers, tool-list checks for active ones. Every proxied tool call records latency, call count, and error count. You get visibility into what's actually working.

Setup

Install globally:

npm install -g agent-discover

Or run directly with npx. Add to your MCP config:

{
  "mcpServers": {
    "agent-discover": {
      "command": "npx",
      "args": ["agent-discover"]
    }
  }
}

That's the only change you ever need to make to your MCP config. The dashboard auto-starts at http://localhost:3424 on the first connection.

The dashboard

The web UI at http://localhost:3424 has two tabs. The Servers tab shows all your registered servers as cards — health status, error counts, active/inactive state, tags, tools list, and expandable sections for secrets, metrics, and config. Action buttons for activate, deactivate, health check, and delete.

The Browse tab is the marketplace view: search the official registry, see server details, and hit install. Real-time updates via WebSocket with dark/light theming that persists across sessions.

How it fits with the rest of the stack

If you're already using agent-comm for agent coordination, agent-tasks for task pipelines, and agent-knowledge for persistent memory — agent-discover rounds out the picture. Now your agents can also expand their own capabilities on demand.

The suite is designed to be used together, but each piece works independently. agent-discover exposes three transport layers: MCP (stdio), REST API (18 endpoints), WebSocket for real-time events. Anything that can make HTTP requests can integrate with it.

Why this matters

The MCP ecosystem is growing fast. There are hundreds of servers in the official registry and more appearing weekly. Static configs don't scale with that — you end up with either a bloated always-on list or a permanently outdated one.

agent-discover turns your MCP setup into something dynamic. Your agent can discover what's available, install what it needs, and activate tools for the duration of a task. It's closer to how humans use tools: pick up what you need, put it down when you're done.

If you're running serious AI coding workflows, give it a try.

GitHub: github.com/keshrath/agent-discover

Feedback welcome — open an issue or drop a comment below.

DEV Community