AI Agent Hackathon 2.0 @ Paradox'25

Paradox'25 IITM

April 6, 2026 to April 7, 2026

IIT Madras

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

The AI agent landscape is evolving rapidly, yet many solutions remain either too generalized or overly technical for widespread adoption. Your mission is to build an innovative AI agent that leverages large language models—particularly the ASI:One LLM—and Fetch.ai's uAgents to effortlessly perform complex tasks specified through natural language instructions.

To demonstrate the practical power of AI Agents, create domain-specific solutions that solve real-world challenges through intuitive user interactions and tangible utility. For enhancing the capabilities of your agent, participants are encouraged to integrate the Model Context Protocol (MCPs) in their solution.

Are you ready to shape the next era of AI-driven automation? The challenge awaits!

👉 Check out the resources to learn how to build and deploy your own AI agents.

Tool Stack

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()