DEV Community: Mathias Markl

How I Gave My AI Agents a Dynamic MCP Marketplace

Mathias Markl — Tue, 07 Apr 2026 13:05:16 +0000

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.

How I Gave My AI Agents a Permanent Memory That Syncs Across Machines

Mathias Markl — Fri, 27 Mar 2026 10:08:31 +0000

If you've spent any time working with AI coding agents like Claude Code, you've probably noticed the elephant in the room: every session starts from scratch. Your agent debugs a tricky deployment issue, discovers that your project needs a specific environment variable, figures out the architecture of your codebase — and then forgets all of it the moment the session ends.

The next session? Back to square one.

I built agent-knowledge to fix this. It's an open-source MCP server that gives AI agents a persistent, git-synced memory — a knowledge base they can read from and write to across sessions, across machines, and across different AI clients.

The Problem: Ephemeral Agent Sessions

When you're working with Claude Code (or any AI coding agent), the conversation is stored as a JSONL transcript file — but the agent itself can't search or learn from previous sessions. Every new session is a blank slate.

This means you end up repeating yourself constantly. You re-explain your project structure. You re-describe team preferences. You re-debug the same issues. It's like working with a brilliant colleague who has amnesia.

The Solution: Two Complementary Memory Systems

agent-knowledge tackles this with two systems working together:

Knowledge Base — A git-synced markdown vault where structured entries live. Think of it as a shared wiki that your agent can read and write. Entries are organized into categories like projects, decisions, workflows, people, and notes. Each entry is a markdown file with YAML frontmatter, and every write is automatically committed and pushed to git.

Session Search — TF-IDF ranked full-text search across all your past session transcripts. Instead of those JSONL files just sitting on disk, they become a searchable archive. Your agent can look up what happened in previous sessions — what errors occurred, what decisions were made, what files were modified.

How It Works Under the Hood

The architecture is straightforward. agent-knowledge runs as an MCP server over stdio, exposing 12 tools that your AI client can call. It also auto-starts a dashboard on localhost:3423 for browsing everything visually.

On the knowledge side, markdown files live in a git repository (by default at ~/claude-memory). Every read triggers a git pull, every write triggers a git add, commit, and push. This means if you're working on two machines, your knowledge stays in sync automatically.

On the session search side, it parses the JSONL transcript files that Claude Code generates and builds a TF-IDF index over them. The index is cached for 60 seconds and rebuilt on demand. Individual files are cached based on their modification time so unchanged files are never re-parsed.

There's also a scoped recall system with six predefined filters: errors (stack traces, exceptions), plans (architecture, TODOs), configs (settings, env vars), tools (MCP calls, CLI commands), files (paths, modifications), and decisions (trade-offs, rationale). This lets your agent ask targeted questions like "what errors have I seen in this project before?"

Getting Started

Setup is simple:

git clone https://github.com/keshrath/agent-knowledge.git
cd agent-knowledge
npm install && npm run build

Then register it as an MCP server in Claude Code:

claude mcp add agent-knowledge -s user \
  -e KNOWLEDGE_MEMORY_DIR="$HOME/claude-memory" \
  -- node /path/to/agent-knowledge/dist/index.js

And grant permissions in your ~/.claude/settings.json:

{
  "permissions": {
    "allow": ["mcp__agent-knowledge__*"]
  }
}

That's it. Open http://localhost:3423 in your browser and you'll see the dashboard with four tabs: Knowledge, Search, Sessions, and Recall.

Works With Claude Code and OpenCode

agent-knowledge works with any MCP client over stdio. The setup guide includes configuration examples for both Claude Code and OpenCode.

Claude Code gets the richest experience with lifecycle hooks and session auto-distillation. You can set up a SessionStart hook that announces the knowledge dashboard URL at the beginning of every session, so the agent always knows where to look.

OpenCode supports MCP servers through its opencode.json config and offers lifecycle hooks via its plugin system. You can wire up events like session.created and tool.execute.after to integrate agent-knowledge into your workflow.

Both clients support the full set of 12 MCP tools — knowledge CRUD, session search, scoped recall, and admin configuration.

The Dashboard

The built-in web dashboard is a vanilla JS single-page app — no framework, no build step. It connects over WebSocket for live updates and supports light/dark theming with Material Design 3 tokens.

The Knowledge tab shows a card grid of your entries, filterable by category. The Search tab gives you full-text search with TF-IDF ranking and role filtering. The Sessions tab lists all your past conversations with project names and git branches. And the Recall tab lets you do scoped searches to quickly find errors, plans, or decisions from your history.

There's even a live reload feature for development — edit the UI files and connected browsers auto-refresh.

Auto-Distillation and Secrets Scrubbing

Two features that stood out to me: auto-distillation and secrets scrubbing.

Auto-distillation automatically extracts insights from completed sessions and pushes them to the knowledge base. Instead of manually curating what the agent learned, it happens automatically.

Secrets scrubbing ensures that API keys, tokens, passwords, and private keys are redacted before anything gets pushed to git. This is critical — you don't want your agent accidentally committing sensitive data to a shared repository.

Why This Matters

AI coding agents are incredibly powerful, but the lack of persistent memory has been a major friction point. Every time you start a new session, there's a ramp-up cost. The agent needs to re-learn your project, your preferences, your past decisions.

agent-knowledge eliminates that ramp-up. Your agent remembers what it learned, can search its own history, and shares knowledge across machines and sessions. It turns ephemeral conversations into a cumulative knowledge base that grows over time.

If you're using AI coding agents seriously, give agent-knowledge a look. It's MIT licensed, well tested, and the documentation is thorough. Check out the architecture docs if you want to understand how the internals work, or jump straight to the setup guide to get started.

Have you been dealing with the same "amnesia" problem with your AI agents? I'd love to hear what approaches you've tried. Drop a comment below!

How I Got Multiple AI Coding Agents to Stop Losing Track of Their Work

Mathias Markl — Thu, 26 Mar 2026 20:53:06 +0000

I recently wrote about agent-comm — a communication layer that lets multiple AI coding agents talk to each other. But talking is only half the problem. The other half? Knowing what work needs to be done, who's doing it, and what stage it's in.

The problem

When you run multiple AI agents in parallel — say three Claude Code sessions working on different parts of a feature — things fall apart fast:

No shared backlog. Each agent only knows what you told it in its prompt. There's no central place to see all pending work.
No pipeline visibility. Is the spec done? Has anyone started implementing? Did tests pass? Nobody knows.
No dependency tracking. Agent B can't start until Agent A finishes, but there's nothing enforcing that.
No artifacts. Specs, plans, test results — they live in chat context and vanish when the session ends.

I needed something that gives AI agents the same project management primitives that human teams take for granted — but exposed as MCP tools they can call directly.

The fix: a pipeline for AI agents

agent-tasks is an open-source pipeline-driven task management server that AI coding agents can use via MCP. Think of it as a lightweight Jira — but designed for machines, not humans.

Every task flows through configurable pipeline stages:

backlog → spec → plan → implement → test → review → done

Agents claim tasks, advance them through stages, attach artifacts at each step, and block on dependencies — all through 31 MCP tools.

What agents can do with it

1. Pipeline-driven workflow

Tasks aren't just "open" or "closed." They move through stages, and each stage produces artifacts:

Spec stage: Agent writes a specification and attaches it
Plan stage: Agent breaks the task into subtasks
Implement stage: Agent writes code, attaches a summary
Test stage: Agent runs tests, attaches results
Review stage: Another agent reviews and approves

2. Dependencies and blocking

task_add_dependency(task_id=5, depends_on=3, type="blocks")

Agent 5 literally cannot advance until task 3 is done. The system detects cycles too — no deadlocks.

3. Multi-agent collaboration

Agents can be assigned roles on tasks:

Collaborator: actively working on it
Reviewer: needs to approve before advancement
Watcher: gets notified of changes

4. Approval gates

task_request_approval(task_id=5, stage="review")
# Another agent:
task_approve(task_id=5)

This enforces a maker-checker pattern. No task moves to "done" without explicit sign-off.

5. Artifacts with versioning

Every spec, plan, test result, and review note is stored as a versioned artifact attached to the task. Previous versions are chained so you can see how decisions evolved.

6. Full-text search

Need to find that task about the auth middleware rewrite? task_search(query="auth middleware") uses SQLite FTS5 to search across all task titles and descriptions.

Setup

Install it:

npm install -g agent-tasks

Add to your MCP config (Claude Code settings.json, Cursor, etc.):

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

That's it. The dashboard auto-starts at http://localhost:3422.

A real coordination pattern

Here's how I use it with three agents working on a feature:

Agent 1 (planner) creates the task and writes a spec:

task_create(title="Add rate limiting to API", project="backend")
task_claim(task_id=42)
task_add_artifact(task_id=42, name="spec", content="...")
task_advance(task_id=42)  # spec → plan

Agent 2 (implementer) picks up the next unblocked task:

task_next(project="backend")  # returns task 42 at plan stage
task_claim(task_id=42)
task_expand(task_id=42, subtasks=["Add middleware", "Add Redis store", "Add config"])
# ... implements each subtask ...
task_advance(task_id=42)  # implement → test

Agent 3 (reviewer) reviews and approves:

task_claim(task_id=42)
task_add_artifact(task_id=42, name="review-notes", content="LGTM, clean implementation")
task_approve(task_id=42)
task_advance(task_id=42)  # review → done

The whole flow is visible in the dashboard — a kanban board that updates in real-time via WebSocket.

The dashboard

The built-in dashboard gives you a kanban view of all tasks across pipeline stages. You can:

Drag tasks between columns
Filter by project, assignee, or priority
Expand task details with artifacts and comments
View artifact diffs between versions
Track subtask progress
Toggle dark/light theme

No frameworks — it's vanilla HTML/CSS/JS with morphdom for efficient DOM updates.

Technical details

TypeScript + Node.js, zero-framework architecture
SQLite with WAL mode for concurrent reads
3 transport layers: MCP (stdio), REST API (18 endpoints), WebSocket
31 MCP tools covering tasks, subtasks, dependencies, artifacts, comments, approvals, and collaboration
337+ tests with vitest
MIT licensed

It pairs naturally with agent-comm — when a task changes, agents get notified through the communication bridge.

What's next

I'm actively using this to coordinate up to 5 Claude Code agents working simultaneously. If you're running multi-agent setups and losing track of what's happening, give it a try.

GitHub: github.com/keshrath/agent-tasks

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

How I Got Multiple AI Coding Agents to Stop Stepping on Each Other

Mathias Markl — Wed, 25 Mar 2026 15:16:33 +0000

The problem

If you've tried running multiple AI coding agents in parallel — say, Claude Code in one terminal doing implementation while another does code review — you've probably hit this: they have no idea the other exists.

Agent A refactors a function. Agent B, unaware, edits the same function. You get merge conflicts, duplicated work, and wasted tokens. The more agents you run, the worse it gets.

The fix: give them a way to talk

I built agent-comm, an open-source communication server that any AI coding agent can plug into. It works with Claude Code, Codex CLI, Gemini CLI, Aider — anything that supports MCP or can make HTTP requests.

What agents can do with it

1. Discover each other

Agents register with a name and capabilities. Others can query who's online and what they're working on.

2. Send messages

Direct messages, broadcasts, topic-based channels, threading, reactions. An agent finishing a task can broadcast "auth module refactored, ready for review" and another agent picks it up.

3. Coordinate with shared state

A namespaced key-value store with atomic compare-and-swap. This is the real workhorse — agents use it for:

Distributed locks: "I'm editing src/auth.ts, back off"
Progress flags: "migration step 3 of 5 complete"
Shared config: feature flags, environment state

The CAS operation means two agents can't accidentally grab the same lock — exactly like a mutex, but for AI agents.

4. Watch it all happen

A real-time dashboard (WebSocket-powered) shows agents, messages, channels, and state — useful for debugging and understanding what your agents are actually doing.

Setup

npm install -g agent-comm

Add to your MCP config:

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

The dashboard launches automatically at http://localhost:3421.

A real coordination pattern

Here's how I use it with three Claude Code sessions:

Implementer registers, checks shared state for the current task queue
Reviewer watches for "ready-for-review" state changes, picks up completed work
Tester monitors the "reviewed" channel, runs tests on approved changes

They coordinate through channels and state locks. No merge conflicts, no duplicate work. Each agent knows what the others are doing.

Technical details

TypeScript, SQLite (WAL mode + FTS5 full-text search)
33 MCP tools, 22 REST endpoints
214 tests across 11 suites
MIT licensed

The MCP tools cover agent management, messaging, channels, and shared state. The REST API mirrors everything for non-MCP clients.

What's next

I'm actively using this daily and iterating. Would love feedback from anyone else running multi-agent setups.

GitHub: github.com/keshrath/agent-comm