About this hackathon

Welcome to the Agent Arena 2026.

This is a build challenge for people who want to build a genuine agentic AI system, not a demo. You pick one of three tracks and build a complete, working system for it:

DeepDive — a self-verifying research analyst that checks every claim against its source.
FinPilot — a proactive financial agent that forecasts, simulates decisions, and intervenes.
CreatorOS — a self-improving content studio that learns from how its content performed.

All three tracks are the same level of difficulty and are judged on the same scale, so it does not matter which you pick — it matters how real your system is.

What every track rewards is the same backbone: multiple cooperating agents (not one giant prompt), a real loop where the system checks or improves its own work, an auditable trail of why it made each decision, and your own measurement of whether it actually works. A system that genuinely does these things beats a feature-complete shell every time.

Mesh API is the official sponsor, and using it is mandatory. Every LLM/AI call in your project must route through Mesh API, an OpenAI-compatible gateway that gives you access to many models through one key.

Submissions are first screened by an automated system that reads your code, and the strongest submissions are then reviewed by human judges.

Terms & Conditions

Submissions are first screened by an automated AI system that evaluates your code, and the top submissions are then reviewed by human judges.

Using Mesh API is mandatory. A submission that does not route its LLM/AI calls through Mesh API will not be considered a valid submission.

The decisions of the judges are final.

How you're judged

1
Multi-agent orchestration
2
The track's core loop — the system checking or improving its own work
3
Core domain capability of your track
4
Supporting domain capability of your track
5
Foundation, data model and real ingestion
6
Self-evaluation — your own test set and measured numbers
7
Auditable decision trail
8
Code quality and reproducibility

Pick your track

You build for one track. Read them all and pick the one you want to spend the week on.

Track 01

DeepDive

Build a Self-Verifying Research Analyst

Mesh API is the official sponsor and using it is mandatory. Every LLM/AI call in your project must route through Mesh API. A submission that does not use Mesh API is not a valid submission.

The Challenge

Build DeepDive, a multi-agent research system that investigates a question across many sources and produces a structured, cited report in which every claim has been checked against the source it points to. Unsupported claims are removed or flagged, thin areas trigger more research, and the whole run is logged so a human can see exactly what was kept and what was rejected.

This is not a search wrapper and not a single long prompt. Tools that produce cited reports from one question already exist. Their well-known weakness is trust: they cite sources, but the cited source often does not actually support the sentence attached to it. The hard, valuable part of this challenge is not gathering information. It is making sure the final report is genuinely true to its sources.

The Story (what you are building, end to end)

A user asks a real question, for example: "What are the main risks of investing in the EV battery market in 2026?"

A planner agent breaks the question into sub-questions (market size, key players, known risks, recent events). Researcher agents gather evidence for each sub-question from the web, and optionally from documents the user uploaded, storing each piece of evidence with its source. A draft is assembled. Then the verifier agent reads the draft and checks each claim against the source it cites: if the source does not support the claim, the claim is dropped or marked unverified, and if a sub-question turns out to be thinly supported, the system loops back and researches more. Finally a synthesizer agent writes the structured report with citations that genuinely trace to retrieved sources. Every step is logged: the sub-questions, what was searched, which claims passed verification, and which were rejected and why.

What You Will Build

1. Multi-agent orchestration (the backbone)

A coordinator that plans the research, delegates to specialized agents, passes results between them, and assembles the final answer.
At least three genuinely distinct agents (for example planner, researcher, verifier, synthesizer). Distinct means each has its own job and its own prompt or its own tools — not the same prompt behind different names.

2. Real information gathering

Agents fetch real evidence from the web, and optionally from user-uploaded documents.
Retrieved content is stored together with its source, so claims can later be traced back.

3. The verification loop (the core of this track)

A verifier step that checks each claim in the draft against the source it cites, and marks or removes claims the source does not support.
When a sub-question is thinly supported, the system loops back and gathers more rather than padding the report. This self-correcting loop is what separates a real system from a wrapper.

4. Grounded, cited output

A structured report where every claim carries a citation that genuinely traces back to a retrieved source. Nothing is invented by the language model on its own.

5. An auditable decision trail

A record of the run: the sub-questions, what was searched, which claims passed verification, and which were rejected and why.

6. Self-evaluation (we reward this heavily)

Your own set of test questions and a way to measure how grounded and complete your reports are — for example, the fraction of claims that pass verification — with the numbers recorded in the repo. A team that genuinely built this almost always measured whether it works.

Highlighted Bonus (optional, makes you stand out)

Structured agent framework (e.g. LangGraph) with explicit nodes and a real loop back to research when verification fails.
Contradiction detection across sources: flag where sources disagree rather than silently picking one.
Source-quality weighting: trust a primary source over a random blog, with the logic visible in code.
Clean export and follow-up: a shareable report (PDF or page) and a conversational follow-up that reuses the earlier research.

Suggested Stack (use what you are comfortable with)

Backend: Python (Flask or FastAPI)
Agents: LangGraph, CrewAI, AutoGen, or your own orchestrator
LLM access (mandatory): all LLM/AI calls must go through Mesh API, the official sponsor. Mesh is an OpenAI-compatible gateway (base_url="https://api.meshapi.ai/v1", key prefix rsk_): one key gives access to many models. Point the OpenAI SDK at Mesh and read your key from the MESH_API_KEY environment variable. Full guide: Mesh API docs.
Web search / retrieval: any search API or scraping approach; a vector DB (Chroma, Qdrant, FAISS, Pinecone, or similar) for grounding over documents
Database: SQLite or PostgreSQL
Frontend: a simple web UI or API (Streamlit, Gradio, Jinja2, or a JS frontend)

Keep your API keys in a local, gitignored .env. Since your code is what is evaluated, your credentials are never needed by us.

Submission Requirements

A public GitHub repository with all your code and a README explaining what you built, how the agents cooperate, and how to run it.
A short note on your key design decisions and your self-evaluation results (your test set and the numbers).
(Optional) A short demo video and a deployed URL — reviewed for shortlisted submissions.

What a Great Submission Looks Like

A coordinator that genuinely orchestrates distinct agents, with results passed between them.
A verification step that actually rejects unsupported claims — you can point to a claim that got removed.
Reports where the citations really support the sentences they are attached to.
A visible decision trail and honest, self-measured groundedness numbers.

Build something you would be proud to show in an interview.

Using Mesh API (required)

Mesh API is mandatory — every LLM/AI call must go through it. Mesh is an OpenAI-compatible gateway: one key gives access to many models (GPT, Claude, Gemini, and more).

Create an API key (it starts with rsk_) on the Mesh dashboard, then point the OpenAI SDK at Mesh and read your key from the environment:

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.meshapi.ai/v1", api_key=os.getenv("MESH_API_KEY"))
client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)

Add your key to a gitignored .env and as the GitHub secret MESH_API_KEY. Full guide: Mesh API docs.

Setup & Requirements

Follow this to make sure the automated checks pass and your project is eligible for evaluation.

Your repository must contain:

All your source code.
A requirements.txt (or pyproject.toml / Pipfile) listing a web framework (Flask or FastAPI) and the LLM client you use through Mesh API.
A README.md describing what you built, how your agents cooperate, your key design decisions, and your self-evaluation results.
A .gitignore that includes .env — never commit secrets.

Repository secrets (Settings → Secrets and variables → Actions) — new to GitHub secrets? Follow this short guide:

MESH_API_KEY — your Mesh API key. Mandatory; every LLM/AI call must go through Mesh.
SUBMISSION_TOKEN — your submission token, shown on your dashboard as soon as you register.

Your keys stay in your own repository and are only used by checks running in your own GitHub Actions — they are never sent to us.

Enabling the automated checks:

Download the workflow file: https://careerapi-production.krishnaik.in/api/ci/hackathons/agent-arena-2026/workflow.yml
Add it to your repository at .github/workflows/agent-arena-2026-checks.yml (create the .github/workflows/ folders if they don't exist).
Add the secrets listed above.
Push a commit. The checks run automatically — results appear in your repository's Actions tab and on your submission dashboard.

Critical checks (must pass for your commit to be eligible for evaluation):

Code compiles — all Python files are free of syntax errors.
Dependencies present — your requirements list a web framework and an LLM client.
Mesh API is used — your code routes LLM calls through Mesh (api.meshapi.ai base URL, or the meshapi SDK).
Mesh API key works — your MESH_API_KEY secret is a valid key. Verified with a metadata call that spends no credits.

Advisory checks (feedback only — these do not block you): no committed .env, a README is present, a .gitignore that ignores .env.

The automated checks are a first filter — passing them does not finalize your score. A failing critical check simply means "fix and push again"; it is not a penalty.

Mesh API — docs (mandatory LLM gateway) LangGraph — agent orchestration CrewAI FastAPI Chroma — vector database

Track 02

FinPilot

Build a Proactive Financial Agent

Mesh API is the official sponsor and using it is mandatory. Every LLM/AI call in your project must route through Mesh API. A submission that does not use Mesh API is not a valid submission.

The Challenge

Build FinPilot, a multi-agent system that ingests a user's transactions, understands their behavior, forecasts where their money is heading, simulates "what-if" decisions against their real data, and proactively surfaces specific, personalized recommendations.

This is not another budgeting dashboard. Apps that categorize transactions and show spending charts already exist and are very good at it. Their common limitation is that they are reactive and backward-looking: they tell you what already happened and wait for you to ask. The hard, valuable part of this challenge is forward-looking reasoning: understanding a person's behavior well enough to predict what will happen, to answer "can I afford this?" before they commit, and to proactively intervene with a specific action, not a generic tip.

The Story (what you are building, end to end)

A user uploads or logs their transactions.

A categorization agent labels each transaction (rent, food, subscriptions, impulse buys) with logic whose output genuinely depends on the transaction. An analysis agent studies behavior over time and detects patterns and anomalies: "food delivery is up 40% this month," "six subscriptions, two of them unused." A forecasting step projects where the user is heading if current behavior continues. An advisor agent reasons over all of this and produces specific, grounded recommendations: "cancel these two subscriptions to save this amount," "at this rate you miss your savings goal by March." The user can also ask "can I afford a trip next month?" and the system simulates it against their real trajectory and answers. A background job sends a scheduled digest with the key insight and one action. Every recommendation records why it was made.

What You Will Build

1. Multi-agent orchestration (the backbone)

A coordinator that routes work to specialized agents and assembles the result.
At least three genuinely distinct agents (for example categorizer, analyzer, forecaster, advisor). Distinct means each has its own job and its own prompt or its own tools — not the same prompt behind different names.

2. Ingestion and real categorization

Transactions are imported (CSV upload or manual logging) and categorized by logic that genuinely depends on the transaction, then stored. Hardcoded or random categories do not count.

3. Behavior analysis and anomaly detection

The system aggregates behavior over time and detects real patterns and anomalies in the user's own data — not generic observations.

4. Forecasting and the simulation loop (the core of this track)

The system projects the user's financial trajectory, and can simulate a "what-if" decision (a planned purchase, a savings goal) against that trajectory and report the effect. This forward-looking reasoning is the heart of the track and is what separates a real system from a categorization wrapper.

5. Proactive, grounded advice

Recommendations are specific and tied to the user's detected patterns and forecast, not generic advice. A generic "save more money" tip scores nothing; "cancel these specific items" scores high.

6. An auditable decision trail

Every recommendation records why it was made — which pattern or forecast triggered it.

7. Self-evaluation (we reward this heavily)

Build test data and measure how accurate your categorization and forecasts are, with the numbers recorded in the repo. A team that genuinely built this almost always measured whether it works.

Highlighted Bonus (optional, makes you stand out)

Structured agent framework (e.g. LangGraph) with an explicit analyze → forecast → advise flow.
Goal tracking with the advice adapting as the user progresses or falls behind.
Conversational layer that answers free-form money questions from the user's real data.
Scheduled proactive delivery (email or Telegram) of a personalized digest, driven by a real background scheduler (Celery / APScheduler / cron), not a manual button.

Suggested Stack (use what you are comfortable with)

Backend: Python (Flask or FastAPI)
Agents: LangGraph, CrewAI, AutoGen, or your own orchestrator
LLM access (mandatory): all LLM/AI calls must go through Mesh API, the official sponsor. Mesh is an OpenAI-compatible gateway (base_url="https://api.meshapi.ai/v1", key prefix rsk_): one key gives access to many models. Point the OpenAI SDK at Mesh and read your key from the MESH_API_KEY environment variable. Full guide: Mesh API docs.
Database: SQLite or PostgreSQL
Frontend: a simple web UI or API (Streamlit, Gradio, Jinja2, or a JS frontend)
Scheduling (bonus): Celery, APScheduler, or cron

You may use synthetic or sample transaction data. Keep your API keys in a local, gitignored .env. Since your code is what is evaluated, your credentials are never needed by us.

Submission Requirements

A public GitHub repository with all your code and a README explaining what you built, how the agents cooperate, and how to run it.
A short note on your key design decisions and your self-evaluation results (your test data and the numbers).
(Optional) A short demo video and a deployed URL — reviewed for shortlisted submissions.

What a Great Submission Looks Like

Distinct cooperating agents with a coordinator, not one prompt doing everything.
Categorization and anomaly detection that genuinely respond to the user's data.
A real forecast or simulation you can demonstrate ("if you keep this up, here is what happens").
Advice grounded in the user's own patterns, a visible reason for each recommendation, and honest accuracy numbers.

Build something you would be proud to show in an interview.

Using Mesh API (required)

Mesh API is mandatory — every LLM/AI call must go through it. Mesh is an OpenAI-compatible gateway: one key gives access to many models (GPT, Claude, Gemini, and more).

Create an API key (it starts with rsk_) on the Mesh dashboard, then point the OpenAI SDK at Mesh and read your key from the environment:

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.meshapi.ai/v1", api_key=os.getenv("MESH_API_KEY"))
client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)

Add your key to a gitignored .env and as the GitHub secret MESH_API_KEY. Full guide: Mesh API docs.

Setup & Requirements

Follow this to make sure the automated checks pass and your project is eligible for evaluation.

Your repository must contain:

All your source code.
A requirements.txt (or pyproject.toml / Pipfile) listing a web framework (Flask or FastAPI) and the LLM client you use through Mesh API.
A README.md describing what you built, how your agents cooperate, your key design decisions, and your self-evaluation results.
A .gitignore that includes .env — never commit secrets.

Repository secrets (Settings → Secrets and variables → Actions) — new to GitHub secrets? Follow this short guide:

MESH_API_KEY — your Mesh API key. Mandatory; every LLM/AI call must go through Mesh.
SUBMISSION_TOKEN — your submission token, shown on your dashboard as soon as you register.

Your keys stay in your own repository and are only used by checks running in your own GitHub Actions — they are never sent to us.

Enabling the automated checks:

Download the workflow file: https://careerapi-production.krishnaik.in/api/ci/hackathons/agent-arena-2026/workflow.yml
Add it to your repository at .github/workflows/agent-arena-2026-checks.yml (create the .github/workflows/ folders if they don't exist).
Add the secrets listed above.
Push a commit. The checks run automatically — results appear in your repository's Actions tab and on your submission dashboard.

Critical checks (must pass for your commit to be eligible for evaluation):

Code compiles — all Python files are free of syntax errors.
Dependencies present — your requirements list a web framework and an LLM client.
Mesh API is used — your code routes LLM calls through Mesh (api.meshapi.ai base URL, or the meshapi SDK).
Mesh API key works — your MESH_API_KEY secret is a valid key. Verified with a metadata call that spends no credits.

Advisory checks (feedback only — these do not block you): no committed .env, a README is present, a .gitignore that ignores .env.

The automated checks are a first filter — passing them does not finalize your score. A failing critical check simply means "fix and push again"; it is not a penalty.

Mesh API — docs (mandatory LLM gateway) LangGraph — agent orchestration CrewAI FastAPI APScheduler — background jobs

Track 03

CreatorOS

Build a Self-Improving Content Studio

Mesh API is the official sponsor and using it is mandatory. Every LLM/AI call in your project must route through Mesh API. A submission that does not use Mesh API is not a valid submission.

The Challenge

Build CreatorOS, a multi-agent content studio where specialized agents collaborate to plan, write, and refine content, generate a matching visual, schedule it, and then learn from performance feedback to improve future output — all while staying true to a learned brand voice.

This is not a one-shot content generator. Tools where AI agents write on-brand content already exist. Their common limitation is that they are assistants, not closed-loop systems: a human approves the output, handles visuals separately, pushes it live, and nothing learns from how the content actually performed. The hard, valuable part of this challenge is the loop: generating content, capturing real performance feedback, and feeding that back so the system improves over time.

The Story (what you are building, end to end)

A user gives a brief: "a LinkedIn post about AI safety."

A strategist agent decides the angle, hook, and audience. A writer agent drafts the piece for that specific platform. An editor agent critiques the draft against concrete criteria and the writer revises it — this self-improvement step is where quality comes from. A visual agent generates a matching image. The finished piece is stored, queued for a time, and (bonus) posted. Performance feedback — real metrics if available, or user-provided or simulated engagement — is captured and fed back, so a learning step can adjust what the system produces next. A brand-voice profile learned from the user's past content keeps every piece consistent. Every important decision (the angle, the edits) is logged.

What You Will Build

1. Multi-agent orchestration (the backbone)

A coordinator that runs a pipeline of distinct agents and passes work between them.
At least three genuinely distinct agents (for example strategist, writer, editor, visual). Distinct means each has its own job and its own prompt or its own tools — not the same prompt behind different names.

2. The editor refinement loop (a core of this track)

An editor agent critiques the draft against concrete criteria and the writer revises it. The output must genuinely change as a result — not pass through untouched.

3. Brand voice

A profile learned from the user's existing content (more than a single sample) that is injected into generation so output stays on-voice. Different brand profiles produce visibly different output.

4. Visuals and scheduling

A matching image is generated for the content, and the finished piece is stored and queued for a scheduled time.

5. The performance feedback loop (the core of this track)

Performance data for published content — real, user-entered, or simulated — is captured and fed back so the system adjusts future content. This closed loop is what separates CreatorOS from a one-shot generator, and it is the heaviest-weighted part of the track.

6. An auditable decision trail

Every important decision is recorded with the reason behind it: the angle the strategist chose, the edits the editor asked for, and what the system learned from performance feedback. Each record is linked to the content piece it belongs to.

7. Self-evaluation (we reward this heavily)

Define a quality measure for your content and write a script that scores it, for example scoring drafts before and after the editor loop, or comparing pieces generated with and without the feedback learned so far. Record the numbers in the repo. A team that genuinely built this almost always measured whether it works.

Highlighted Bonus (optional, makes you stand out)

Structured agent framework (e.g. LangGraph) with named nodes and a real strategist → writer → editor loop, not a flat sequence.
Multi-platform adaptation: one idea adapted properly for different platforms and formats.
Real publishing through a platform API, with engagement read back into the system.
Real learning: a step that provably changes future output based on what performed best, not just stored numbers.

Suggested Stack (use what you are comfortable with)

Backend: Python (Flask or FastAPI)
Agents: LangGraph, CrewAI, AutoGen, or your own orchestrator
LLM access (mandatory): all LLM/AI calls must go through Mesh API, the official sponsor. Mesh is an OpenAI-compatible gateway (base_url="https://api.meshapi.ai/v1", key prefix rsk_): one key gives access to many models. Point the OpenAI SDK at Mesh and read your key from the MESH_API_KEY environment variable. Full guide: Mesh API docs.
Images: any image generation model you can reach through Mesh API
Database: SQLite or PostgreSQL
Frontend: a simple web UI or API (Streamlit, Gradio, Jinja2, or a JS frontend)
Scheduling: Celery, APScheduler, or cron

You may use user-entered or simulated engagement data if real platform metrics are not available. Keep your API keys in a local, gitignored .env. Since your code is what is evaluated, your credentials are never needed by us.

Submission Requirements

A public GitHub repository with all your code and a README explaining what you built, how the agents cooperate, and how to run it.
A short note on your key design decisions and your self-evaluation results (your quality measure and the numbers).
(Optional) A short demo video and a deployed URL, reviewed for shortlisted submissions.

What a Great Submission Looks Like

Distinct cooperating agents with a coordinator, and an editor whose critique visibly changes the draft.
A brand voice learned from real samples that genuinely changes what gets written.
Performance feedback that actually changes the next piece the system produces.
A visible decision trail and honest before and after numbers.

Build something you would be proud to show in an interview.

Using Mesh API (required)

Mesh API is mandatory — every LLM/AI call must go through it. Mesh is an OpenAI-compatible gateway: one key gives access to many models (GPT, Claude, Gemini, and more).

Create an API key (it starts with rsk_) on the Mesh dashboard, then point the OpenAI SDK at Mesh and read your key from the environment:

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.meshapi.ai/v1", api_key=os.getenv("MESH_API_KEY"))
client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)

Add your key to a gitignored .env and as the GitHub secret MESH_API_KEY. Full guide: Mesh API docs.

Setup & Requirements

Follow this to make sure the automated checks pass and your project is eligible for evaluation.

Your repository must contain:

All your source code.
A requirements.txt (or pyproject.toml / Pipfile) listing a web framework (Flask or FastAPI) and the LLM client you use through Mesh API.
A README.md describing what you built, how your agents cooperate, your key design decisions, and your self-evaluation results.
A .gitignore that includes .env — never commit secrets.

Repository secrets (Settings → Secrets and variables → Actions) — new to GitHub secrets? Follow this short guide:

MESH_API_KEY — your Mesh API key. Mandatory; every LLM/AI call must go through Mesh.
SUBMISSION_TOKEN — your submission token, shown on your dashboard as soon as you register.

Your keys stay in your own repository and are only used by checks running in your own GitHub Actions — they are never sent to us.

Enabling the automated checks:

Download the workflow file: https://careerapi-production.krishnaik.in/api/ci/hackathons/agent-arena-2026/workflow.yml
Add it to your repository at .github/workflows/agent-arena-2026-checks.yml (create the .github/workflows/ folders if they don't exist).
Add the secrets listed above.
Push a commit. The checks run automatically — results appear in your repository's Actions tab and on your submission dashboard.

Critical checks (must pass for your commit to be eligible for evaluation):

Code compiles — all Python files are free of syntax errors.
Dependencies present — your requirements list a web framework and an LLM client.
Mesh API is used — your code routes LLM calls through Mesh (api.meshapi.ai base URL, or the meshapi SDK).
Mesh API key works — your MESH_API_KEY secret is a valid key. Verified with a metadata call that spends no credits.

Advisory checks (feedback only — these do not block you): no committed .env, a README is present, a .gitignore that ignores .env.

The automated checks are a first filter — passing them does not finalize your score. A failing critical check simply means "fix and push again"; it is not a penalty.

Mesh API — docs (mandatory LLM gateway) LangGraph — agent orchestration CrewAI FastAPI APScheduler — background jobs

Rules

You pick one track (DeepDive, FinPilot, or CreatorOS) and build a complete system for it.
A public GitHub repository is mandatory — your repo is your submission, and the automated evaluation reads it directly.
Backend must be Python (Flask or FastAPI).
Mesh API is mandatory. Every LLM/AI call in your project must route through Mesh API. A submission that does not use Mesh API is not a valid submission.
No hardcoded secrets or credentials committed to the repository — keep them in a local, gitignored .env.
Faked or stubbed features (hardcoded outputs, an agent that is never called, a "loop" that never loops, a test set that does not exist) will score poorly.
You may participate solo, or as a team of up to three members, submitting through the team leader's account.
A demo video and a deployed URL are optional and are reviewed only for shortlisted submissions.

Who can enter

Open to everyone. Participants who are minors in their place of residence should have the consent of a parent or legal guardian to take part.
A public GitHub account is required to submit.
Organizer employees and their immediate family are not eligible for prizes.

Ready to build?

Registering takes a minute and costs nothing. You get the submission checklist, the checks that run on your repo, and a place to submit when you are done.

About this hackathon

Terms & Conditions

How you're judged

Pick your track

DeepDive

FinPilot

CreatorOS

DeepDive

The Challenge

The Story (what you are building, end to end)

What You Will Build

Highlighted Bonus (optional, makes you stand out)

Suggested Stack (use what you are comfortable with)

Submission Requirements

What a Great Submission Looks Like

Using Mesh API (required)

Setup & Requirements

FinPilot

The Challenge

The Story (what you are building, end to end)

What You Will Build

Highlighted Bonus (optional, makes you stand out)

Suggested Stack (use what you are comfortable with)

Submission Requirements

What a Great Submission Looks Like

Using Mesh API (required)

Setup & Requirements

CreatorOS

The Challenge

The Story (what you are building, end to end)

What You Will Build

Highlighted Bonus (optional, makes you stand out)

Suggested Stack (use what you are comfortable with)

Submission Requirements

What a Great Submission Looks Like

Using Mesh API (required)

Setup & Requirements

Prizes

Rules

Who can enter

Sponsor

Mesh API

Timeline

Ready to build?