Agentic Framework MCP Server for Multi-Agent Asynchronous Messaging

Overview

The Agentic Framework MCP Server implements the Model Context Protocol (MCP) to enable multiple AI agents to communicate asynchronously and collaborate on complex tasks. It provides a lightweight HTTP-based MCP endpoint, an agent registry, and a file-backed message store so agents can register, discover peers, send messages, and broadcast updates without requiring an external database.

Designed with Test-Driven Development (TDD) and functional programming principles, the server emphasizes predictable behavior, small surface area, and easy reasoning about state. File-based storage makes the server portable and easy to run in development or edge deployments, while Kubernetes deployment manifests and a Justfile support production rollouts with health checks, rolling updates, and version management.

Features

• Agent registration and discovery with unique identities and descriptions
• Asynchronous message queues per agent (file-backed for portability)
• Broadcast messaging to reach all registered agents
• HTTP transport compatible with MCP-compatible clients (e.g., Claude)
• Simple file-based storage — no external database required
• Built with TDD and functional programming for reliability and testability
• Kubernetes-ready manifests and deployment automation via Justfile
• Health checks, log streaming, and automatic restart on failure
• Web UI for monitoring agent activity (auto-opens when first agent connects)

Installation / Configuration

Prerequisites:

• Go and/or the build toolchain used in the repository (see repo README)
• Docker (for container builds)
• Kubernetes cluster for production (optional)
• just command runner (optional; install with cargo install just)

Clone the project:

git clone https://github.com/Piotr1215/mcp-agentic-framework.git
cd mcp-agentic-framework

Local development (example):

# Build and run locally (project-specific build commands may vary)
# Check the repository README if the project uses a makefile or build script
just build        # build the container/asset (if using Justfile)
just run          # run locally (if available)

Kubernetes quick start:

# Edit the Justfile: set docker_user to your Docker Hub username
vim Justfile

# Build, push, and deploy
just update       # builds, pushes, and deploys to the configured cluster

# Check service IP (example)
just status
kubectl get svc mcp-agentic-framework-lb

Configure an MCP client (example for Claude desktop):

{
  "agentic-framework": {
    "type": "http",
    "url": "http://YOUR_LOADBALANCER_IP:3113/mcp"
  }
}

Health checks and operations:

just test-health   # probe health endpoint
just logs          # stream server logs
just restart       # restart deployment
just rollback      # rollback to previous version

Architecture

The server consists of:

• Agent Registry: tracks active agents, names, and metadata.
• Message Store: per-agent queues persisted to disk for resilience.
• HTTP MCP Endpoint: exposes an MCP-compatible transport for clients.

Simple ASCII view:

[Agent A] \
[Agent B]  ->  [MCP Server] -> [File-backed Message Store]
[Agent C] /                      [Agent Registry]

Comparison with Claude Code Sub-agents

Available Resources

• GitHub repository: https://github.com/Piotr1215/mcp-agentic-framework
• Kubernetes manifests: k8s/ directory in the repo
• Justfile: build, deploy, and release automation
• Health and web UI endpoints exposed by the service (see repo README for exact paths)

Use Cases

• Multi-agent problem solving: spawn specialized agents (developer, tester, architect) that negotiate and reach consensus asynchronously.
• Distributed workflows: agents coordinate complex pipelines where tasks are passed between agents and progress is persisted.
• Long-running conversations: store intermediate state to disk so agents can resume or reference past messages reliably.
• Orchestration for sub-agents: use MCP agents to design and refine sub-agent configurations and then dispatch routine tasks to dedicated sub-agents.

Examples:

• Code review: a reviewer agent broadcasts a patch, tester agents run checks and post results, and an architect agent aggregates suggestions.
• Incident triage: monitoring agent posts an alert, responder agents propose remediation steps, and an owner agent decides and broadcasts the final plan.

Getting Help / Contributing

See the project repository for contribution guidelines, issue tracker, and tests. The codebase follows TDD practices—adding tests alongside behavior fixes is encouraged to maintain reliability.