n8n AI Workflow Hackathon

Join n8n AI Workflow Hackathon

May 31, 2025 to June 4, 2025

San Francisco

Introduction

Fetch.ai’s vision is to create a open AI Agent marketplace. We are empowering developers to build on our platform that can connect services and APIs without any domain knowledge.

Our infrastructure enables ‘search and discovery’ and ‘dynamic connectivity’. It offers an open, modular, UI agnostic, self-assembling of services.

Our technology is built on four key components:

uAgents - uAgents are autonomous AI agents built to connect seamlessly with networks and other agents. They can represent and interact with data, APIs, services, machine learning models, and individuals, enabling intelligent and dynamic decision-making in decentralized environments.

Agentverse - serves as a development and hosting platform for these agents.

Fetch Network - underpins the entire system, ensuring smooth operation and integration.

ASI:One - A Web3-native large language model (LLM) optimized for agent-based workflows.

Challenge statement

n8n AI Workflow Hackathon Challenge Statements

Challenge 1: Autonomous Content Creator

Design an AI-powered workflow that takes trending topics and key data from external sources and transforms them into polished content. How can you leverage n8n to orchestrate a multi-step process that automates content creation from initial research to final publishing with minimal manual input?

For example, your solution could utilize the following basic structure:

Research: Find the key data and sources to use Draft Generation: Generate a first draft of the content to prepare it for publishing Check: Review the draft for grammatical errors and accuracy Publishing: Publish the content via CMS or social media integrations

The goal of this challenge is to automate the content creation pipeline, saving users time while maintaining high standards. We recommend following this general outline for your solution, but you are welcome to meet with a mentor to brainstorm your ideas and take your project to the next level!

Challenge 2: Automated HR Onboarding and Engagement

Design an AI-powered HR assistant that streamlines the entire onboarding journey from scheduling interviews and sending offer letters to tracking training progress and gathering feedback. How can you leverage n8n to automate this process across tools like calendars, email platforms and HR systems while reducing manual tasks and creating a more engaging experience for new hires?

HR typically covers several different areas within a company. Your solution can focus on some of the following areas, as well as any others you may find applicable:

Scheduling: Send interview invitations and calendar holds based on candidate and team availability Offer Distribution: Automatically generate and send offer letters and onboarding documents Tracking: Monitor completion of onboarding tasks like training modules or equipment requests Feedback: Collect input from new hires and hiring managers to improve the onboarding process

The goal of this challenge is to reduce administrative overhead and improve the new hire experience. You are encouraged to follow this general flow or customize it with mentor support to address unique HR needs or tools.

Challenge 3: Personal Health Coach

Build a personal health agent that helps track wellness across sleep, fitness and nutrition by integrating with wearables, fitness trackers and health apps. How can you use n8n to collect, analyze and act on this data to deliver meaningful insights and drive better health outcomes?

For instance, your solution can focus on some or all of the following key components:

Data Aggregation: Connect to APIs for wearables, nutrition trackers or sleep monitors to pull in user data Monitoring: Detect patterns or anomalies, such as inconsistent sleep or missed workouts Insights: Generate actionable suggestions or encouragement based on trends Notifications: Send reminders, alerts or progress summaries via email or app integrations

The goal of this challenge is to empower users to take control of their health through automation and proactive recommendations. Feel free to build on this outline and explore creative features with a mentor!

Open Innovation Challenge

Design a project that leverages agentic workflows to transform how routine processes are currently managed. How can you use n8n’s integrations with AI tools, external APIs and human-in-the-loop mechanisms to reimagine outdated workflows, automate manual tasks or streamline day-to-day operations?

For this innovation challenge, here are some inspo ideas you can use to build your own solution:

Problem Identification: Choose a routine or inefficient process that could benefit from automation Automation Setup: Use n8n to design a workflow that handles key steps Integration: Connect third-party tools, APIs, or AI models to expand functionality User Experience: Create intuitive touchpoints that keep users informed or enable human input where needed

The goal of this challenge is to demonstrate how intelligent automation can drive meaningful change in everyday processes. You are encouraged to explore bold ideas and bring your own use case to build a solution that makes a real-world impact. Share with a mentor to help bring your idea to life!

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.
Read the guide for this code here ↗

from uagents import Agent, Bureau, Context, Model
    class Message(Model):
        message: str
    
    sigmar = Agent(name="sigmar", seed="sigmar recovery phrase")
    slaanesh = Agent(name="slaanesh", seed="slaanesh recovery phrase")
        
    @sigmar.on_interval(period=3.0)
    async def send_message(ctx: Context):
       await ctx.send(slaanesh.address, Message(message="hello there slaanesh"))
        
    @sigmar.on_message(model=Message)
    async def sigmar_message_handler(ctx: Context, sender: str, msg: Message):
        ctx.logger.info(f"Received message from {sender}: {msg.message}")
    
    @slaanesh.on_message(model=Message)
    async def slaanesh_message_handler(ctx: Context, sender: str, msg: Message):
        ctx.logger.info(f"Received message from {sender}: {msg.message}")
        await ctx.send(sigmar.address, Message(message="hello there sigmar"))
        
    bureau = Bureau()
    bureau.add(sigmar)
    bureau.add(slaanesh)
    if __name__ == "__main__":
        bureau.run()