Create a custom Aqua app that implements a sophisticated DeFi position. If you use SwapVM, you may modify SwapVM opcodes and define your own instructions. The final positions must be demonstrated through tests scripts or UI.

Projects that utilize SwapVM will be scored higher during the final judging.

Create a custom Aqua app that implements a sophisticated DeFi position. If you use SwapVM, you may modify SwapVM opcodes and define your own instructions. The final positions must be demonstrated through tests scripts or UI.

Projects that utilize SwapVM will be scored higher during the final judging.

Build a tool that makes The Graph easier to use from AI environments like Claude, Cursor, and ChatGPT. Think reusable infrastructure, not a single app: new or extended MCP servers, agent SKILLs, x402 payment tooling, A2A integrations, framework plugins, or one-click client configs. Featured challenge from the Substreams team: use the Substreams SKILLs to deliver the best one-prompt deployment, going from a single natural-language prompt to a working, deployed Substreams pipeline.

Examples:

• A one-prompt Substreams deployment flow using the Substreams SKILLs
• A cross-protocol MCP that fans one query across every protocol on a shared standard schema
• A layered MCP that unifies several Standardized Subgraph schemas behind one agent interface
• A reusable agent SKILL that stands up a new cross-protocol MCP in minutes
• A project built on Nuthatch, extending its MCP tools, adding new SKILLs, or wiring its output into an agent workflow.
• New integrations with web3 protocols (e.g. a SKILL/MCP integrated with Chainlink's AI tooling)
• A SKILL paired with the Subgraph MCP that turns multi-Subgraph queries into market research or blog posts

Judging criteria: Usefulness to other builders (30%) · Reusability & completeness (25%) · Effective use of The Graph (20%) · Technical execution (15%) · Innovation (10%)

Build an AI agent or application that uses The Graph as its live source of blockchain data. Rewards research assistants, trading/execution agents, portfolio copilots, risk monitors, and more. Query 15,000+ Subgraphs through the Subgraph MCP, stream data with Substreams, or let your agent pay per query with x402.

Examples:

• A DeFi research agent answering natural-language questions via the Subgraph MCP
• A trading/execution agent reading live liquidity data and paying per query with x402
• A portfolio/PnL copilot reading balances, transfers, and swaps across chains
• A risk-monitoring agent watching lending positions for liquidations
• A governance assistant summarizing DAO proposals and voting activity
• A dapp-embedded chat copilot grounded in live Subgraph data

Bonus: extra credit for teams that also ship a reusable SKILL or MCP server.

Judging criteria: Effective use of The Graph (35%) · Usefulness & impact (25%) · Technical execution (20%) · Innovation (10%) · Demo & clarity (10%)

Build on The Graph's composable and standardized data products. Use Standardized Subgraphs (one shared schema across every protocol of a type) to run a single query across many protocols, compose reusable Substreams packages into new pipelines, or layer the Subgraph MCP for cross-protocol analysis. New composable Substreams modules for emerging standards (e.g. ERC-4626 vault flows) also count.

Examples:

• A cross-protocol analytics dashboard comparing TVL/revenue across ten lending markets with one Lending/CDP standard-schema query
• A DEX revenue comparator running one query pattern across every AMM on the DEX AMM standard
• A layered MCP comparing lending, DEX, and derivatives markets side by side
• A pipeline composing reusable Substreams packages (.spkg) into a new sink (Postgres, ClickHouse, Kafka, files)
• A new composable Substreams module for an emerging standard (e.g. ERC-4626)
• A new Standardized Subgraph for a protocol category that lacks one

Judging criteria: Leverage of composability/standards (35%) · Breadth (20%) · Technical execution (20%) · Usefulness (15%) · Demo & clarity (10%)

New AgentKit use cases where a service can tell the difference between "a bot" and "an agent acting on behalf of a real, unique human." Explore where Human-Backed Agents change access, authorization, rate limits, economic terms, payments, commerce, moderation, or accountability.

Selfie Check is a low-friction, selfie-based credential confirming a real, live person without requiring an Orb. This track is a beta test: build a project using Selfie Check and deliver testing documentation covering both developer feedback (SDK/API friction, docs gaps, setup issues) and user feedback (UX friction, comprehension, drop-off, camera/selfie flow issues).

Identity Check let a product ask for verified identity attributes (age, jurisdiction, uniqueness, document-backed signals) beyond simple proof of human. This track is a beta test: build a project using Identity Attestations and deliver testing documentation covering both developer feedback (SDK/API friction, docs gaps, setup issues) and user feedback (UX friction, comprehension, consent, drop-off).

Build AI agents that move value autonomously on Hedera. The agentic economy needs payment infrastructure that works at machine speed: sub-second finality, predictable sub-cent fees, and native token operations without smart contract overhead. Hedera is built for this.

Use the Hedera Agent Kit, OpenClaw's Agent Commerce Protocol, the x402 payment standard, or any combination of agentic tooling to build agents that discover services, negotiate terms, and settle payments on Hedera. Whether it's micropayment streaming, agent-to-agent commerce, or autonomous DeFi, the best projects will demonstrate real payment flows between agents or between agents and services.

Ideas to get you started:

• Agent-to-Agent Marketplace — Services register via OpenClaw ACP, discover peers, negotiate pricing, settle in HBAR/HTS automatically.
• x402 Pay-Per-Use Gateway — Wrap APIs with x402 payments. Agents pay per request in HBAR, no keys or subscriptions.
• Micropayment Streaming — Real-time micro-payments for compute, data, or inference. Settle on Hedera every few seconds.
• Autonomous Escrow — Hold funds, verify delivery via oracle/HCS, auto-release payments on condition match.
• DeFi Copilot — Monitor token prices, execute swaps, rebalance HTS portfolios based on user-defined strategies.
• Subscription Manager — Recurring payments via Scheduled Transactions. Auto-handle renewals, cancellations, prorated refunds.

Build a working application on Hedera using only the Hedera SDK. No Solidity, no smart contracts. Use native Hedera services directly: create tokens, post messages to the Consensus Service, schedule transactions, manage accounts, or combine multiple services into something new.

This bounty is designed for developers who are new to Hedera or new to blockchain. Hedera's SDK lets you do things that typically require smart contracts on other chains: create fungible and non-fungible tokens, set up custom fee schedules, schedule future transactions, and publish verifiable messages, all with a few lines of JavaScript or Python.

Ideas to get you started:

• Tokenized Fund Shares — Create a fund token with KYC-gated transfers and automated dividend distributions via custom fees.
• Invoice Factoring — Tokenize invoices as HTS tokens, allow buyers to purchase them at a discount, and settle on maturity via Scheduled Transactions.
• Carbon Credit Registry — Mint carbon credits as HTS tokens with provenance tracked on HCS and retirement enforced by burning.
• Fractionalized Real Estate — Tokenize property ownership with royalty fees that distribute rental income to holders on every transfer.
• Commodity Receipts — Issue warehouse receipts as HTS tokens backed by oracle-verified commodity prices.

Build a working application on Hedera using only the Hedera SDK. No Solidity, no smart contracts. Use native Hedera services directly: create tokens, post messages to the Consensus Service, schedule transactions, manage accounts, or combine multiple services into something new.

This bounty is designed for developers who are new to Hedera or new to blockchain. Hedera's SDK lets you do things that typically require smart contracts on other chains: create fungible and non-fungible tokens, set up custom fee schedules, schedule future transactions, and publish verifiable messages, all with a few lines of JavaScript or Python.

Ideas to get you started:

• Timestamped Proof System — Use HCS to create verifiable timestamps for documents, media, or events. Mint an HTS token as a receipt for each proof.
• Token-Gated Access — Mint HTS tokens that grant access to a service, event, or community. Check balances via Mirror Node to authorize users.
• Scheduled Payment Bot — Automate recurring HBAR or token payments using Scheduled Transactions. Build a simple UI to configure payment schedules.
• Supply Chain Tracker — Log product journey events to HCS and issue HTS tokens as certificates at each checkpoint.
• Verifiable Messaging — Build a chat or notification system where all messages are logged to HCS for tamper-proof, auditable history.

Build an automation platform that uses Hedera as the decentralized hub for multi-chain automation — scheduling and triggering smart contract calls on other chains, fully on-chain, with no bots, keepers, or off-chain cron. Combine the Hedera Schedule Service with Axelar General Message Passing (GMP) so a scheduled transaction on Hedera fires when its conditions and signatures are met, then dispatches a message through Axelar that executes a contract call on a destination chain. Most chains rely on centralized keepers for automation — Hedera flips it: scheduling is a native primitive, Axelar GMP handles decentralized message passing, and together they enable trustless cross-chain automation.

Focus on real-world workflows: cross-chain payroll, treasury rebalancing, recurring DCA into assets on another chain, scheduled liquidity actions, or time-locked governance execution. The strongest projects will feel production-ready — something a DAO, finance team, or protocol could adopt immediately — and will prove the entire trigger-to-execution loop happens on-chain, with zero centralized servers.

Ideas to get you started: Cross-Chain DCA Cross-Chain Treasury Rebalancing Cross-Chain Payroll Scheduled Cross-Chain Liquidity Time-Locked Cross-Chain Governance Contributor Payroll (single-chain) Governance-Gated Treasury (single-chain)

Build a production-ready automation platform that lets users schedule, approve, and execute on-chain actions using the Hedera Schedule Service, with no bots, keepers, or off-chain cron infrastructure. Most chains lean on centralized keepers or off-chain schedulers to fire future transactions. Hedera makes scheduling a native primitive: submit a transaction, collect the signatures it needs, and let the network execute it when the conditions are met.

This bounty is focused on real-world automation workflows: payroll for contributors, treasury actions gated by governance approval, recurring subscription payments, or time-locked protocol upgrades. Think in terms of users and workflows, not just transactions. The strongest projects will feel like something a DAO, finance team, protocol operator, or business could adopt tomorrow.

Ideas to get you started: Contributor Payroll Governance-Gated Treasury Subscription Manager Time-Locked Upgrades Conditional Escrow

The product layer. Build the best end-user applications and agents on 0G: things people, or other agents, actually use. Because you build on 0G Compute / Private Computer, your inference is private and verifiable by default (TEE-sealed), so you can focus on shipping a real product. Combine with 0G Storage for persistent encrypted memory, Agentic IDs for ownership and composability, and 0G Chain for on-chain actions and micropayments.

This track is for what you ship, not what others build on. If you are building a framework, SDK, or developer tooling, submit to the Infrastructure track instead.

Ideas to get you started: 🔹 Private personal "Digital Twin" or coding agent on 0G Compute with evolving encrypted memory on 0G Storage 🔹 Verifiable research or analysis agent that self-fact-checks, with TEE-attested proof of every result, and optional on-chain provenance 🔹 Agentic browser companion or extension with tradeable memory via Agentic ID 🔹 Consumer on-chain AI app, DeFi experience, RWA tool, or AI x gaming dApp with persistent-memory agents and automatic royalty splits 🔹 Agent minted as an Agentic ID with embedded intelligence (encrypted on 0G Storage), persistent memory, and dynamic upgrades

The builder layer. Build the frameworks, SDKs, primitives, and developer tooling that other teams will build their 0G applications and agents on top of. This track celebrates the work that makes the whole ecosystem faster, safer, and more capable.

If you are shipping an end-user product, submit to the Application track instead.

Ideas to get you started: 🔹 Agent framework or SDK natively integrated with 0G Compute sealed inference and 0G Storage memory 🔹 Model-routing or provenance layer across 0G's hosted models, with verification tracked on-chain 🔹 Agentic ID composability library: breeding, merging, or fine-tuning agents together 🔹 No-code or low-code visual agent builder with one-click deploy to 0G Compute and Storage 🔹 Verification, guardrail, or auditor layer for on-chain agent actions 🔹 Memory-layer abstraction over 0G Storage

For teams iterating on an existing 0G project started at ETHGlobal Cannes, the online agent hackathon, Zero Cup, or independent prior work. We are not judging polish on old demos. We are judging meaningful progress during the Lisbon hackathon window: new features, production hardening, user readiness, and trajectory toward real usage.

Ideas to get you started:

🔹 Evolve a Cannes or online-hackathon prototype into a deployed product with persistent 0G Storage memory and on-chain settlement on 0G Chain 🔹 Harden an existing project with verifiable inference on 0G Compute, error recovery, and robust state management 🔹 Integrate a missing stack layer: move inference to 0G Compute, memory to 0G Storage, or identity to an Agentic ID,

Build with the Uniswap API to access liquidity and execute value onchain. Projects must integrate the Uniswap API with a valid API key from the Uniswap Developer Platform for core functionality such as trade execution, routing, payments, liquidity provision or coordination between agents or systems. This may include trading applications, agent-based systems, automated strategies, or new financial primitives, leveraging Uniswap's permissionless liquidity and emerging capabilities such as AI-driven systems.

The Uniswap API now also supports tokenized stocks, giving teams a new asset class to build on top of.

Build on or extend the Uniswap open-source ecosystem using any part of the Uniswap stack. This includes projects that integrate the Uniswap AMM (v2, v3, or v4) or any Uniswap protocol such as CCA, new v4 hooks, extensions or improvements to official Uniswap repositories, and tooling or solutions built for the broader ecosystem.

For teams starting something new this weekend and building it on Sui. We want to see market-viable products — real apps people would actually use — that make Sui and its stack do genuine work: Move smart contracts and the object model, Walrus for decentralized storage, Seal for access control, DeepBook for on-chain liquidity and order books, zkLogin for seamless onboarding, and everything else Sui offers. Depth beats breadth: the strongest submissions have a clear product and Sui-native primitives doing real work, not a superficial add-on bolted on to qualify. Coming from EVM? Walrus is the most natural entry point — it's chain-agnostic and drops straight in — but the deeper you reach into the Sui stack, the stronger the submission.

For teams that already have a product and, this weekend, integrate a part of the Sui stack into it — or port it to Sui outright. Bring an app real users would reach for and put Sui underneath it: swap in Walrus for storage, add Seal for access control, use zkLogin for auth, tap DeepBook for liquidity, or migrate your logic to Move. We care more about depth than breadth: the strongest submissions show a clear before/after with the Sui integration doing genuine work, not a quick add-on to qualify. Walrus is chain-agnostic, so it slots in wherever your app already lives — including EVM — making it the easiest first step if you're on IPFS, Arweave, Filecoin, or S3.

Most people know ENS for name → address lookups. We want to see what else it can do. Store verifiable credentials or zk proofs in text records. Build privacy features with auto-rotating addresses on each resolution. Use subnames as access tokens. Surprise us!

AI agents need persistent, human-readable identities too. Use ENS to name agents, resolve their addresses, spin up subname registries for agent fleets, store agent metadata in text records, or build systems where agents can register and discover each other onchain. If you're building anything agentic this weekend, think about how ENS can be the identity layer.

Already building something real? Keep going. This prize is for the best project that meaningfully extends an existing product or open source project with ENS. Add ENS where it makes the product better: identity, discovery, onboarding, payments, profiles, subnames, records, or entirely new UX. We want to see ENS used to ship a meaningful new capability, not just added as a cosmetic integration.