Fetch-A-Thon 3.0

Fetch-A-Thon 3.0 is a AI Agent Hackathon by Fetch.ai Innovation Lab is bringing together students, developers, builders & AI enthusiasts to LEARN. BUILD. COLLABORATE.

🎉 Exclusive Offer

Unlock One Month Free access to ASI:One Pro and Agentverse Premium

Use code:FETCHATHONINDFETCHATHONIND

October 24, 2026 to October 24, 2026

India

Prizes

National Winners

₹35,000

Cash Prize + Internship Interview Opportunity

First Runner-up

₹25,000

Cash Prize + Internship Interview Opportunity

2nd Runner-up

₹15,000

Cash Prize + Internship Interview Opportunity

Best Multi-Agent Workflow X2

₹5,000

Cash Prize

Best Agentverse Deployment X2

₹5,000

Cash Prize

Best Personal AI

₹5,000

Cash Prize

Introduction

Fetch.ai is your gateway to the agentic economy. It provides a full ecosystem for building, deploying, and discovering AI Agents. With Fetch.ai, you can:

Build agents using the uAgents framework.
Register agents (built with uAgents or any other framework) on Agentverse, the open marketplace for AI Agents.
Make your agents discoverable and accessible through ASI:One, the world’s first agentic LLM.

What are AI Agents?

AI Agents are autonomous pieces of software that can understand goals, make decisions, and take actions on behalf of users.

The Three Pillars of the Fetch.ai Ecosystem

uAgents – A Python library developed by Fetch.ai for building autonomous agents. It gives you everything you need to create agents that can talk to each other and coordinate tasks.
Agentverse - The open marketplace for AI Agents. You can publish agents built with uAgents or any other agentic framework, making them searchable and usable by both users and other agents.
ASI:One – The world’s first agentic LLM and the discovery layer for Agentverse. When a user submits a query, ASI:One identifies the most suitable agent and routes the request for execution.

Challenge statement

ASI:One Agent Challenge – From Intent to Action

The Challenge

Most AI applications stop at conversation. Your challenge is to build an AI agent that can be discovered through ASI:One, understand a user's intent, and take meaningful action to solve a real-world problem.

Your agent might coordinate services, automate workflows, analyze live information, make recommendations, complete transactions, collaborate with other specialized agents, or execute multi-step tasks. The result should be more than a chatbot or a thin wrapper around an API.

What to Build

Build a single agent or multi-agent system that:

Solves a clearly defined real-world problem.
Performs multi-step planning, reasoning, or orchestration.
Uses tools, APIs, external services, data sources, MCP, or other agents to produce an executable outcome.
Is registered on Agentverse and discoverable through ASI:One.
Implements the Agent Chat Protocol (ACP).
Allows the complete primary workflow to be demonstrated directly inside an ASI:One conversation without requiring a custom frontend.
(Recommended) Uses ASI1 Interactive Cards to provide rich, guided user interactions such as forms, carousels, review screens, detail views, or custom interactive layouts directly inside ASI:One conversations.

You may use any framework, including Google ADK, LangGraph, CrewAI, OpenAI Agents SDK, Claude Agent SDK, uAgents, or plain Python.

Mandatory Requirements

To be eligible for prizes, your project must:

Register at least one agent on Agentverse.
Implement the Agent Chat Protocol (ACP).
Be discoverable and directly usable through ASI:One.
Demonstrate meaningful tool execution or multi-agent orchestration.
Complete the primary user workflow entirely within an ASI:One conversation.
Submit a public GitHub repository with instructions to run or test the project.

Bonus Points

Projects may receive additional consideration for:

Effective multi-agent collaboration.
Implementation of the Payment Protocol with a credible monetization model.
Effective use of ASI Interactive Cards to create intuitive, guided, and action-oriented user experiences inside ASI:One.
Strong reliability, error handling, and recovery from failed tool calls.
Creative use of real-time data and external services.
An agent that could realistically continue operating after the hackathon.

Deliverables

Public ASI:One Shared Chat URL demonstrating the complete workflow.
Agentverse Agent Profile URL(s) for each submitted agent.
Public GitHub Repository.
Short Demo Video.
Brief description covering:
- The problem being solved.
- Target users.
- The outcome produced by the agent.

Project Submission Instructions

All participants, whether joining online or offline, must submit their projects through the ASI:One dashboard.

How to Submit Your Project

Open the dashboard: Fetch-A-Thon 3.0 Dashboard
Select the Project Submission Agent from the available agents on the dashboard.
Submit your project details by following the instructions provided by the agent. Make sure to include all the required deliverables mentioned above, including your GitHub repository, ASI:One Shared Chat URL, Agentverse profile, demo video, and project description.
Verify your submission to ensure all required links and information are included and accessible.

Need Help While Building?

You can use the AI Mentor available on the dashboard to get help with technical issues, debug problems, clarify concepts, and get guidance while building your project.

Important: Project submission through the dashboard is mandatory for both online and offline participants. Make sure you complete your submission within the announced deadline. Only projects that meet the mandatory challenge requirements will be eligible for prizes.

Build something meaningful, focus on working AI agents rather than fancy UI, and show us how your agent turns intent into action!

Important links

How to create an Agent with uAgents Framework ↗Communication between two uAgents ↗How to create ASI:One compatible uAgents ↗ASI:One API ↗Innovation Lab GitHub Repo ↗Past Hackathon Projects ↗

Examples to get you started:

Guide

How to Connect a Local Agent to Agentverse

↗

Guide

Fetch-skills CLI Installer

↗

Guide

How to Integrate ASI:One LLM with your uAgent

↗

Guide

How to create an Image Generation Agent

↗

Guide

MCP Integration Example

↗

Guide

Read our Medium Articles

↗

What to Submit

Code
- Share the link to your public GitHub repository to allow judges to access and test your project.
- Ensure your README.md file includes key details about your agents, such as their name and address, for easy reference.
- Mention any extra resources required to run your project and provide links to those resources.
- All agents must be categorized under Innovation Lab.
  - To achieve this, include the following badge in your agent’s README.md file:
```
![tag:innovationlab](https://img.shields.io/badge/innovationlab-3D8BD3)
```
```
![tag:hackathon](https://img.shields.io/badge/hackathon-5F43F1)
```
Video
- Include a demo video (3–5 minutes) demonstrating the agents you have built.

Quick start example

This file can be run on any platform supporting Python, with the necessary install permissions. This example shows two agents communicating with each other using the uAgent python library.
Try it out on Agentverse ↗

from datetime import datetime
from uuid import uuid4
from uagents.setup import fund_agent_if_low
from uagents_core.contrib.protocols.chat import (
   ChatAcknowledgement,
   ChatMessage,
   EndSessionContent,
   StartSessionContent,
   TextContent,
   chat_protocol_spec,
)


agent = Agent()


# Initialize the chat protocol with the standard chat spec
chat_proto = Protocol(spec=chat_protocol_spec)


# Utility function to wrap plain text into a ChatMessage
def create_text_chat(text: str, end_session: bool = False) -> ChatMessage:
content = [TextContent(type="text", text=text)]
   return ChatMessage(
       timestamp=datetime.utcnow(),
       msg_id=uuid4(),
       content=content,
   )


# Handle incoming chat messages
@chat_proto.on_message(ChatMessage)
async def handle_message(ctx: Context, sender: str, msg: ChatMessage):
   ctx.logger.info(f"Received message from {sender}")
  
   # Always send back an acknowledgement when a message is received
   await ctx.send(sender, ChatAcknowledgement(timestamp=datetime.utcnow(), acknowledged_msg_id=msg.msg_id))


   # Process each content item inside the chat message
   for item in msg.content:
       # Marks the start of a chat session
       if isinstance(item, StartSessionContent):
           ctx.logger.info(f"Session started with {sender}")
      
       # Handles plain text messages (from another agent or ASI:One)
       elif isinstance(item, TextContent):
           ctx.logger.info(f"Text message from {sender}: {item.text}")
           #Add your logic
           # Example: respond with a message describing the result of a completed task
           response_message = create_text_chat("Hello from Agent")
           await ctx.send(sender, response_message)


       # Marks the end of a chat session
       elif isinstance(item, EndSessionContent):
           ctx.logger.info(f"Session ended with {sender}")
       # Catches anything unexpected
       else:
           ctx.logger.info(f"Received unexpected content type from {sender}")


# Handle acknowledgements for messages this agent has sent out
@chat_proto.on_message(ChatAcknowledgement)
async def handle_acknowledgement(ctx: Context, sender: str, msg: ChatAcknowledgement):
   ctx.logger.info(f"Received acknowledgement from {sender} for message {msg.acknowledged_msg_id}")


# Include the chat protocol and publish the manifest to Agentverse
agent.include(chat_proto, publish_manifest=True)


if __name__ == "__main__": 
    agent.run()

Agentverse MCP Server

Learn how to deploy your first agent on Agentverse with Claude Desktop in Under 5 Minutes

Full Server

Agentverse MCP

Client connection URL

https://mcp.agentverse.ai/sse

Lite

Agentverse MCP-Lite

Client connection URL

https://mcp-lite.agentverse.ai/mcp

Video introduction

Introduction to agents

On Interval

On Event

Agent Messages

Tool Stack

Judging Criteria

Functionality & Technical Implementation (25%)
- Does the agent system work as intended?
- Are the agents properly communicating and reasoning in real time?
Use of Fetch.ai Technology (20%)
- Are the agents registered and discoverable on Agentverse?
- Is the Agent Chat Protocol (ACP) implemented for ASI:One discoverability and interaction?
- Is ASI:One / ASI1 LLM used as a core part of the agent’s reasoning, intent understanding, or decision-making workflow?
- Is the Payment Protocol integrated to enable monetisation or agent-to-agent payments?
- Does the project effectively leverage the Fetch.ai ecosystem to deliver a functional AI Agent solution?
Innovation & Creativity (20%)
- How original or creative is the solution?
- Is it solving a problem in a new or unconventional way?
Real-World Impact & Usefulness (20%)
- Does the solution solve a meaningful problem?
- How useful would this be to an end user?
User Experience & Presentation (15%)
- Is the solution presented clearly with a well-structured demo?
- Is there a smooth and intuitive user experience?