Your next AI agent starts here.

Scaffold a production-ready MCP server with A2A support and portable Agent Skills. Start with a structured foundation. Build what makes your agent yours.

Explore on GitHubSee how it works

Skip the blank-page problem.

Standing up an interoperable agent server means boilerplate: protocol envelopes, an agent card, a skill file, packaging and validation. mcp-agent-kit generates that starting structure so your first hour goes to your own tools.

It doesn’t remove integration work. Your tools, your logic and your client setup are still yours.

One foundation. Three building blocks.

Select a block to see what it is and what it connects to. Validation and tests sit underneath all three.

MCP servertools / resources / prompts A2A supportagent card + tasks Agent Skillportable SKILL.md validate.py + client_test.py + unit tests

From scaffold to your own agent.

Configure your project

Pick a snake_case name, a description and a base URL.

create-mcp-agent my_agent

Generate the scaffold

The CLI writes server, tools, A2A card, SKILL.md and tests.

cd my_agent

Validate the implementation

Six compliance checks, plus a dual-era client probe test.

python validate.py

Extend it with your own tools

Add a file under tools/, register it in server.py, re-validate.

python server.py

Start with a foundation. Stay in control.

This is the tool definition shape the scaffold ships with (tools/example.py), trimmed for display. Your own tools follow the same pattern and are registered in server.py.

Illustrative excerpt, not program output.

tools/example.py
def calculate_metrics(arguments):
    values = arguments.get("values", [])
    ...

TOOL_DEFINITION = {
    "name": "calculate_metrics",
    "description": "Use when analyzing numerical series or computing aggregate metrics. Do not use for unstructured text parsing.",
    "inputSchema": {
        "type": "object",
        "properties": {
            "metric_type": {"type": "string", "enum": ["mean", "sum", "max", "min"]},
            "values": {"type": "array", "items": {"type": "number"}},
        },
        "required": ["values"],
    },
    "annotations": {"readOnlyHint": True, "destructiveHint": False},
    "handler": calculate_metrics,
}

What the repository implements today.

Implemented

Project structure

Generates tools/, a2a/, server.py, validate.py, client_test.py, SKILL.md and a README.

Implemented

Stateless MCP server

Targets MCP 2026-07-28 over stdio: server/discover, tools, resources and prompts, each request carrying its own _meta, with sorted list results. Standard library only.

Implemented

A2A agent card and tasks

Builds agent.json from registered tools and serves it with a task lifecycle (submitted, working, completed, failed, input_required).

Implemented

Portable SKILL.md

Frontmatter checks: name matches directory, description 20–1024 characters in “Use when X. Do not use for Y.” form.

Implemented

Validation and tests

validate.py runs six checks; the repository ships 20 unit tests under tests/.

Not included

Auth, database, hosting

The README lists these as out of scope: add a bearer-token validator or persistent task store yourself. Client compatibility beyond the documented Claude Desktop and Claude Code steps isn’t claimed.

Preview a scaffold.

A browser preview of what create-mcp-agent would write for your inputs, using the same name and description rules as the CLI. It does not generate files; the official CLI does.

    
    
    Checks mirror the CLI’s name rule and description pattern. Whether a generated project passes all six validate.py checks is only known by running it. Generated server files import mcp_agent_kit, so it must be installed.
    
  
    

    


    
  
    Your next commit starts here.
    
  
    
    
      
      
    1. Open the repository. Python 3.10 or newer is required.
      2. 
      
    2. Install and scaffold. The README documents installing from PyPI and running the generator.
      3. 
      
    3. Run validation. Six compliance checks, then the probe client test.
      4. 
      
    4. Run the repo’s tests. From a clone of the repository.
      5. 
      
    5. Extend the project. Add tools under tools/ and register them in server.py.
      6. 
    
    
    
    
  
    

    


    
  
    Questions.
    
  
    What is mcp-agent-kit?
    A scaffolding kit and runtime foundation for building an MCP server with A2A support and portable Agent Skill packaging. It is an early release (0.1.0, Beta).
    
  
    What does it generate?
    tools/example.py, server.py, a2a/agent.json, a2a/server.py, SKILL.md, validate.py, client_test.py and README.md.
    
  
    How do MCP and A2A support work?
    The MCP server speaks stateless JSON-RPC over stdio. The A2A server is a standard-library HTTP server exposing /.well-known/agent.json and task endpoints (/a2a/tasks/send, /a2a/tasks/{id}); the agent card is generated from your registered tools.
    
  
    What is the role of SKILL.md?
    It packages the agent’s purpose and tool index as a portable skill file. The README shows copying it into ~/.claude/skills or .claude/skills for Claude Code.
    
  
    Which Python version is required?
    Python 3.10 or newer, per pyproject.toml. The protocol core has no runtime dependencies; Flask is an optional extra.
    
  
    How do I validate a generated project?
    Run python validate.py inside it, and python client_test.py for the probe client tests.
    
  
    Can I customize the scaffold?
    Yes. The output is plain Python files you own. Add tools, change the agent card, edit SKILL.md, then re-run validation.
    

    


    
  
  
    Build the foundation. Create the intelligence.
    
  
    Open source. Developer controlled. Ready to extend.
    
  
    View the project on GitHub
    
  
    Read the documentation