2026 Model Context Protocol Server and AI Agent Hackathon

Help the government accelerate AI adoption and provide better services!

Who: You — all government employees are eligible to participate! Hosted by GSA; industry partners include Databricks, OpenAI, and IBM.

What: The Model Context Protocol (MCP)  is an open-source standard for connecting AI applications to external systems.  As AI use expands from conversational tools to autonomous agents, its practical value can be greatly improved through, governed access to federal data assets and service delivery capabilities. We’re looking for your help building MCP servers for your agency’s open data assets and service delivery use cases. Whether you’re working with datasets the public needs to discover, services citizens interact with, or APIs that power critical decisions, this is your opportunity to make that information AI-ready.

Where: Online — it’s a virtual event.

When: September–October, 2026

How: Register now to receive information on how to participate, as well as future announcements.

Background

As the use of artificial intelligence systems expands from conversational tools to autonomous agents, their practical value depends on reliable, governed access to real-world data.  MCP is an open-source standard for connecting AI applications to external systems. Using MCP, AI applications like Claude, Gemini or ChatGPT can connect to data sources (e.g. local files, databases) and tools (e.g. search engines, calculators)  serving as the bridge between AI agents and the APIs, databases, and open data portals that hold the federal government’s most valuable information assets and service delivery capabilities.

In order to explore scaling the development of this critical infrastructure layer, the AI Tooling Meetup Group from the AI Community of Practice is organizing this government-wide open data and service delivery MCP hackathon: a collaborative, competitive event designed to empower subject matter experts and developers across agencies to prototype MCP servers for their open data assets and service delivery use cases.

The 2026 Model Context Protocol Server and AI Agent Hackathon will deliver value at multiple levels simultaneously:

• For the government workforce — it will produce a growing library of MCP server prototypes connected to real government data and service delivery assets — accelerating the ability of agency AI tools to answer plain-language questions, surface relevant datasets dynamically, and support real-time analysis for decision-makers.
• For the public — in the near future it may provide broader access to government data and services through AI-powered interfaces — making it easier to query, understand, and use government information and service delivery workflows without specialized technical knowledge.
• For the broader AI ecosystem — it will demonstrate a replicable model for embedding domain expertise directly into MCP servers, making specialized knowledge readily accessible to AI systems and the people who use them. As the field matures, this approach can be extended to additional data types, protocols, domains, and use cases. 

The challenge

The federal government has made substantial investments in open data and service delivery, yet a critical gap remains: these vast information assets and the underlying service delivery mechanisms are largely inaccessible to the next generation of autonomous AI agents. While data and services exist, AI systems lack the structured, context-rich “translation layer” required to query, interpret, and perform actions within complex government services and data. One of the core objectives of this hackathon is to explore how we can empower the federal workforce to build MCP servers — the standardized interfaces that allow AI to safely and effectively understand, retrieve, and submit information to vital government data and services.

This hackathon serves as an exploratory initiative, empowering domain experts to translate their specialized knowledge into reusable, agent-ready code. MCP shows promise and may potentially be used to improve how government data and services can be delivered. Participants gain hands-on experience with technology that may reshape citizen engagement while positioning their agencies at the forefront of AI-enabled data and service delivery, helping build expertise that will be increasingly valuable across government.

What you’ll build

Select from one of three applications:

• Dataset Access Server — Make a federal open dataset query-able by AI agents
• Service “Read” Integration — Enable AI applications to retrieve information from a government service
• Service “Write” Integration — Enable AI to submit information to a government service

What you’ll gain

• Hands-on expertise — Learn an emerging technology that can potentially reshape how the public interacts with government data and services
• A concrete pilot — Walk away with a working prototype that can be used as a foundation for production implementation
• Technical resources and support — Access to sandbox environments, training sessions from industry experts, and mentorship throughout the 6-week development window
• Community and recognition — Join a cross-agency community of AI infrastructure innovators and showcase your work to federal and industry leaders

How we will support you

We will provide full training on MCP implementation, server architecture, and deployment best practices through webinars prior to and during the hackathon. We will also host open office hours with technical experts to assist participants during the event. We estimate the following time commitments to successfully participate in the hackathon.

• API research and tooling setup: 10 hours
• Initial build: 10 hours
• Evaluation and improvements: 20 hours

Prizes

Due to federal legal requirements, we cannot offer cross-agency monetary prizes, but winners will be recognized in an awards ceremony by senior government officials.

Judging Criteria

Submissions will be judged on:

• Technical Quality: Whether the server is built to a professional standard — readable, reliable, and designed with the MCP paradigm in mind.
  • Criterion 1: Code Readability & Maintainability
    • A well-crafted MCP server should be organized logically, use consistent and self-documenting naming conventions, and separate concerns — such as data models, tool definitions, and API interactions — so any component can be understood in isolation.
    • Judges will look for clear file and module structure, meaningful variable and function names, and comments that explain intent rather than restate the obvious.
  • Criterion 2: Server Performance & Reliability
    • Submitters must include their own evaluation setup and results — documenting how they tested the server, what inputs were used, and how the server performed — giving judges insight into both the rigor of the testing approach and the quality of the outcomes.
    • High marks go to submissions that demonstrate thoughtful evaluation design, accurate and well-formed tool responses, graceful error handling, and stable performance across a range of test cases.
  • Criterion 3: Adherence to MCP Design Principles
    • MCP servers should be built for agents — using Pydantic models for structured, validated inputs, writing tool names and descriptions precise enough for an LLM to select them without ambiguity, and designing tools around meaningful user goals rather than mirroring underlying API endpoints.
    • Judges will look for evidence that each tool represents a real agent-facing action, not a thin wrapper around a single REST call.
• Innovation: How novel and creative the solution is. Creative use of MCP tooling and unique agent workflows may result in higher scores.
• Mission Alignment: How it supports mission needs and improves service delivery and oversight.
• Presentation: Clear storytelling and explanation, effective demo flow and evidence of testing.

Judges

Judges will be announced prior to the start of the Hackathon.  We are not accepting applications for judging positions at this time.

Deliverables

At the conclusion of the hackathon, participants must submit:

1. GitHub repository: Complete, documented code for your MCP server.
2. Presentation slide deck:
   • Problem statement — What challenge does your server address?
   • Solution overview — How does your MCP server solve this problem?
   • Technical approach and key decisions
   • Demonstration of functionality
3. Evaluation documentation:
   • Testing methodology
   • Performance metrics
   • Security considerations
   • Lessons learned and recommendations

Timeline and key dates

Exact dates are still being finalized, and are subject to change. Watch this space or register for details.

• Training sessions: August 2026
• Kickoff event: September 2026
• Check-in milestones: Mid-September
• Repository submission deadline: Mid-October 2026
• Final presentations: End of October 2026
• Awards ceremony: End of October 2026

Participation requirements and guidelines

Eligibility requirements

• Open to all federal employees and contractors (you must have a government  email) as well as state and local government employees.
• You can participate solo or join as a team. If joining as a team, we recommend a maximum of five individuals per team with a mix of software engineers and domain experts. If joining solo, you will most likely need to be a software engineer with access to domain experts.  There are no restrictions on the number of individuals or teams from any given agency.
• This hackathon is explicitly designed to be inclusive across technical skill levels. Participants do not need to be software engineers — domain experts who understand their agency’s data are equally essential to effective server design.  For service delivery use cases,  we recommend coordinating with system owners to ensure Read/Write API availability for the hackathon. 

Technology requirements and suggested skills

To ensure a successful hackathon experience, we recommend that participants possess a mix of the following technical and domain skills.

Technology requirements

Core development environment:

• Operating systems: Familiarity with macOS, Linux, or Windows (WSL2 strongly recommended for Windows users).
• Command line: Proficiency in navigating a shell or terminal.
• Version control: Experience using Git and navigating GitHub or GitLab.

Suggested technical skills

• Languages: Practical experience with Python (3.10+) and/or Node.js (18+).
• IDE: Comfort using code editors like VS Code, Cursor, or PyCharm, including configuring language extensions/plugins (e.g., Pylance, ESLint).
• Execution: If using your own environment, ability to run and debug code locally using your chosen IDE or terminal.
• Environment and package management:
  • Python ecosystem: Ability to create/activate virtual environments (venv, conda, or uv) and manage packages with pip or uv.
  • Node.js ecosystem: Familiarity with npm or yarn for package management.
• MCP-specific competencies:
  • SDKs: Understanding of how to install and run the MCP SDK (pip install MCP or equivalent).
  • Local testing: Experience using a compatible MCP client for testing, such as Claude Desktop, VS Code with the MCP extension, or the MCP Inspector tool.
• Protocols and APIs:
  • Familiarity with transport concepts (JSON-RPC/studio or HTTP/SSE).
  • A solid understanding of basic REST API concepts, particularly for read/write integration 

Domain expert proficiency

• Strong knowledge of relevant programs, business processes, datasets or operational areas
• Ability to identify high-value problems that an MCP server could help solve
• Ability to explain how work is performed today, including inputs, decisions, handoffs and outputs
• Understands where authoritative data resides, how it is formatted and what limitations or quality issues it has
• Ability to turn a business need into clear developer requirements such as what resources, tools, prompts, or actions the MCP server should expose

Contact the AI CoP

Have questions? We’re here to help! Reach out to us at aicop@gsa.gov.