We are proud to be the

TOP sponsor

LA Hacks 2026

Join Fetch.ai Innovation Lab at the official start of UCLA's legendary 36-hour hackathon where 1000+ hackers will descend on one of LA's most iconic venues to build wild technical projects.

🎉 Exclusive Offer

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

Use code:LAHACKSLAHACKSAV

April 24, 2026

Pauley Pavilion

Prizes

Best Use of Fetch.ai - 1st Prize

$2500

Cash Prize + Internship Interview Opportunity

Best Use of Fetch.ai - 2nd Prize

$1500

Cash Prize + Internship Interview Opportunity

Best Use of Fetch.ai - 3rd Prize

$1000

Cash Prize + Internship Interview Opportunity

Best OmegaClaw Skill powered by Agentverse - 1st Prize

$1500

Cash Prize

Best OmegaClaw Skill powered by Agentverse - 2nd Prize

$1000

Cash Prize

Introduction

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

Pillars of the Fetch.ai Ecosystem

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

Important links

Fetch.ai Resources

How to create an Agent with uAgents Framework ↗Communication between two uAgents ↗How to create ASI:One compatible uAgents ↗How to Enable Payment Protocol (FET) ↗How to Enable Payment Protocol (Skyfire) ↗How to register CrewAI agents on Agentverse ↗How to register LangGraph agents on Agentverse ↗How to deploy agents on VM ↗Front-end Web App Integration ↗Innovation Lab GitHub Repo ↗Past Hackathon Projects ↗How to write a good Readme for your Agents ↗

Examples to get you started:

Guide

How to Connect a Local Agent to Agentverse ↗

Guide

How to Integrate ASI:One LLM with your uAgent ↗

Guide

How to create an Image Generation Agent ↗

Guide

Agentverse MCP Server ↗

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

Agentverse MCP (Full Server)

Client connection URL: https://mcp.agentverse.ai/sse

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

Track 1:

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 agents registered on Agentverse?
- Is the Chat Protocol implemented for ASI:One discoverability?
- Is there a well-defined monetization approach aligned with the agent’s functionality and value delivered?
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?

Track 2:

Value of the Skill added to OmegaClaw (25%)
- How useful and meaningful is the skill being added to OmegaClaw?
- Does it solve a real problem or add a genuinely valuable new function?
Quality of the Agent registered/used on Agentverse (25%)
- How well does OmegaClaw discover, invoke, and use the Agentverse capability?
- Is the interaction flow coherent and does the delegation feel intentional rather than bolted on?
End-to-End User Experience (25%)
- How clearly does the project demonstrate a real user interacting with OmegaClaw through a channel such as Telegram or IRC, with OmegaClaw successfully calling the specialist capability and returning the result?
- Does the workflow feel complete and easy to follow?
Technical Execution (25%)
- How well is the system implemented?
- Does the integration work reliably end to end, and is the overall architecture thoughtful and functional?