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

Track 1 - Agentverse - Search & Discovery of Agents

Goal:

Build and Register AI Agents on Agentverse, discoverable via ASI:One, that turn user intent into real, executable outcomes.

Requirements to be eligible for a prize:

Develop a single or multi-agent orchestration that demonstrates reasoning, tool execution, and solves a real-world problem.
Use any agentic framework like Claude SDK, OpenAI Agent SDK, Google ADK, Langgraph, CrewAI, etc. of your choice OR simple plain python to bring your idea to life.
Register your agents with Agentverse and implement the Chat Protocol (mandatory) & Payment Protocol (optional) to support direct ASI:One interactions and built-in monetization.
No custom frontend is required - the use case must be demonstrated directly through ASI:One

Deliverables:

Share your ASI:One Chat session URL Example
Agent(s) URL on Agentverse Example
Github Repo URL (Public) + demo video on Devpost

Track 2 - OmegaClaw Skill Forge powered by Agentverse

Goal:

Build a new specialist skill/capability for OmegaClaw using Agentverse.

In this track, participants will expand what OmegaClaw can do by connecting it to specialist intelligence through Agentverse. In many cases, this will mean building a specialist agent for a specific use case, registering it on Agentverse, and then creating the OmegaClaw skill or integration layer that allows OmegaClaw to discover, invoke, and use that agent when needed. If a strong existing Agentverse agent already fits the use case, participants may choose to integrate that instead.

OmegaClaw uses ASI1 as its underlying LLM, so submissions should be designed with the expectation that OmegaClaw will use ASI1 for reasoning, deciding when delegation is needed, and routing requests to the appropriate Agentverse capability. The goal is not just to build a standalone agent, but to make that capability usable by OmegaClaw through search, discovery, routing, and delegation in a real interaction flow.

Please refer this guide to start developing with Agentverse and OmegaClaw

Fetch ai x OmegaClaw Tech Stack Banner - v8.png

Deliverables:

A working specialist OmegaClaw skill that allows OmegaClaw to discover and invoke that capability
Agent profile url on agentverse for the agent being used for the skill: Example
- a newly built agent registered on Agentverse, or
- an existing Agentverse agent successfully integrated into the workflow
A live or recorded demo showing the full end-to-end interaction:
- a user interacts with OmegaClaw through a channel such as Telegram, IRC, or another supported interface
- OmegaClaw identifies the need for a specialist capability
- OmegaClaw invokes the Agentverse skill / specialist agent
- the result is returned back through OmegaClaw to the user
A short technical explanation covering:
- what the capability does
- whether the team built a new agent or used an existing one
- how OmegaClaw routes the request
- how the result is returned to the user through the chosen channel

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