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.

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!

Any type of ENS integration is eligible for this pool prize, split evenly among all eligible projects. Get creative!

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.

We're looking for the most market-viable products and dApps already relying on decentralized storage that choose Walrus as their storage solution for this hackathon. Bring an app real users would actually reach for, and put Walrus underneath it — media, user data, app assets, or whatever your product stores today. We care more about depth than breadth here: the strongest submissions will show a clear product, real traction or a credible path to it, and Walrus doing genuine work in the stack rather than a quick add-on bolted on to qualify. Walrus is chain-agnostic, so it slots in regardless of where your app already lives — including EVM. If you're currently on IPFS, Arweave, Filecoin, or an S3 bucket, this is a great weekend to give Walrus a try.

For teams starting something new this weekend. We'd love to see products that tap into Sui and any part of its stack — Walrus for decentralized storage, DeepBook for on-chain liquidity and order books, and everything else Sui offers. For EVM developers, Walrus is the most natural entry point: it's the chain-agnostic piece that drops straight into an EVM app, so you don't need to build entirely on Sui to take part — but if your idea reaches deeper into the stack, even better. Just like the existing-products track, we're looking for the most market-viable products — real ideas people would actually use — with Walrus or the broader Sui stack doing genuine work: storing blobs behind a smart contract, hosting a frontend, replacing IPNS, anchoring a DAO proposal or a verifiable manifest, powering an NFT drop, building on DeepBook, or wherever it fits your concept.

Apps that utilize AgentKit to deliver agentic experiences, where Delegated World ID enhances safety, fairness, or trust, especially products that unlock free trials for agents and free access to initial usage.

Apps where the product breaks without proof of human.

Example patterns:

• One-per-human access to limited resources (tickets, grants, allowlists)
• Sybil-resistant voting, quadratic funding, or allocation
• Human-only marketplaces (postings, matching, anti-spam)
• Reputation and trust systems gated by personhood

Existing projects that will integrate any of our SDKs (IDKit, Minikit, Agentkit) in a meaningful way into their existing project. The winner of this category will be evaluated by:

• How “novel” is the use case for World ID
• Technical integration readiness

Teams building with ProveKit to compile and prove Noir circuits in real apps (web, mobile, services, and/or on-chain), unlocking new UX by making proofs practical to generate and verify across environments.

Example patterns:

• On-device proving (mobile or browser) for privacy-preserving flows
• Proof verification embedded in a Mini App/web app backend
• On-chain verification using a recursive verifier
• Developer tooling/pipelines that make Noir → proving → verification reproducible and fast

Build and deploy smart contracts that demonstrate advanced programmable logic using USDC or EURC — such as conditional flows, onchain automation, or multi-step settlement mechanisms.

What we’re looking for:

Conditional escrow with onchain dispute + automatic release Programmable payroll / vesting in USDC or EURC Crosschain “conditional transfer” (escrow on source, release on destination via Circle Forwarder)

Build chain abstracted USDC apps that treat multiple blockchains as one liquidity surface, using Arc to move USDC wherever it’s needed. Projects should demonstrate how capital can be sourced, routed, and settled across chains through a single application without fragmenting user experience.

What we’re looking for:

• Crosschain payments, credit, or treasury systems
• Applications that are not locked to a single chain
• Seamless user experience despite crosschain complexity"

Build applications that enable autonomous AI agents to transact with each other using nanopayments on Arc. Projects should demonstrate how agents can make gas-free micropayments for API calls, data access, compute resources, or services without human intervention. Focus on agent-to-agent commerce, automated payment flows, and scalable transaction systems where traditional payment rails are too expensive or slow.

Examples:

• AI agents paying for API calls, LLM inference, or data access per-use
• Autonomous agents trading services or compute resources
• Multi-agent systems with payment-based coordination mechanisms
• Agent marketplaces with gas-free microtransactions
• Pay-per-query knowledge bases or RAG systems accessed by agents
• Automated content monetization (pay $0.01 per article/video)

Build prediction market applications on Arc that move beyond speculation and deliver real-world utility — such as forecasting, hedging, and decision-making. Projects should leverage Arc’s stablecoin-native infrastructure (USDC/EURC gas, native FX, deterministic finality, and compliance-ready architecture) to create prediction markets that are easier to use, economically predictable, and credible enough for consumer, institutional, and enterprise use cases. Please see resources section for recommended products to use

Examples:

• Macroeconomic data markets — Markets on CPI, Fed decisions, jobs, GDP → Short-duration, high-frequency demand
• Geopolitical & event-driven markets — Markets on elections, conflicts, trade, energy shocks → Direct pricing of real-world uncertainty
• Institutional hedging markets — Onchain tools for macro + geopolitical risk → Simpler, more direct than derivatives
• Multi-currency / localized markets — Region-specific markets (EURC, USDC, etc.) → Native FX + localized settlement
• Governance & enterprise forecasting — Markets for internal decisions, policy, planning → Enabled by identity, compliance, auditability

Are you a founder or have interesting MVPs from previous hackathons? Take a project you already own and add a working Arc integration. Open source repos and live products both qualify.

What We look for: (examples)

• USDC or EURC payment flows on Arc added to an existing commerce, fintech, or wallet product
• Crosschain transfers or unified balance integrated into a project already in production with Arc serving as the core settlement later
• Agentic economic payments shipped into an existing AI agent or API monetization tool
• Stablecoin settlement or escrow logic on Arc added to an existing DeFi protocol or marketplace
• Arc-powered treasury or FX features built into a live multi-chain product

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.

Build a tokenization application using the Hedera Token Service (HTS). Hedera's native token service lets you create, configure, and manage tokens at the protocol level with built-in compliance controls, custom fee schedules, and atomic operations, no smart contract required.

This bounty is focused on real-world asset tokenization: securities, real estate fractions, invoices, carbon credits, commodities, fund shares, or any asset class where on-chain representation unlocks liquidity, transparency, or automation. Projects that demonstrate a clear path from physical asset to on-chain token with meaningful compliance or lifecycle management will be favoured.

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

Build an application powered by LI.FI Composer.

Composer enables developers to define and execute complex onchain workflows as a single Flow. We're looking for projects that demonstrate how transaction composition can unlock new products, experiences, and interaction models.

Submissions may include consumer applications, financial products, wallets, agents, infrastructure, or entirely new categories.

Projects will be judged on:

Innovation Product quality Technical execution Effective use of Composer

Build an experience that demonstrates how Composer can simplify complex onchain interactions.

We're interested in products that make blockchain applications more intuitive, accessible, and efficient through thoughtful design and workflow abstraction.

Projects will be judged on:

User experience Product design Accessibility Effective use of Composer

Build tooling that improves the Composer developer experience.

Examples include Flow builders, simulation environments, debugging tools, testing frameworks, workflow editors, analysis tools, deployment tooling, and infrastructure.

Projects will be judged on:

Utility Developer experience Technical quality Reusability

Build applications that use Composer as an execution layer for AI-assisted or autonomous systems.

Examples include AI-generated Flows, strategy agents, workflow automation, and autonomous execution systems.

Projects will be judged on:

Innovation Product quality Technical execution Effective use of Composer

Integrate LI.FI Composer into an existing application, protocol, wallet, agent, or developer tool.

We're excited to see how Composer can enhance products that already exist by enabling new workflows, simplifying existing interactions, or unlocking entirely new capabilities through transaction composition.

Projects will be judged on:

Quality of integration Product impact Technical execution Effective use of Composer

Build your first workflow with CRE! Chainlink Runtime Environment (CRE) is an all-in-one orchestration layer that enables developers to build institutional-grade smart contracts — data-connected, compliance-ready, privacy-preserving, and interoperable across blockchains and traditional systems. With CRE, you can connect blockchains to external APIs, enterprise systems, data sources, LLMs, or AI agents.

Using the CRE SDK (available in Go and TypeScript), you’ll build Workflows — modular programs that orchestrate logic across on-chain and off-chain environments. With the CRE CLI, you can compile, simulate, and deploy these workflows to CRE, where they run on a Decentralized Oracle Network (DON) for fault-tolerant execution.

Build something awesome using Chainlink! Specifically using CCIP, Price Feeds, Data Streams, PoR or VRF.

Note: Please use CRE instead of using Chainlink Functions or Automation. These products will be deprecated, and any project that needs this type of functionality should use CRE instead.

Build with Chainlink Confidential AI to bring private data into Web3 applications through trusted AI inference! Using confidential compute and Trusted Execution Environments (TEEs), developers can securely analyze documents, financial records, identity information, and other sensitive inputs while keeping the underlying data private.

Create applications for private credit scoring, under-collateralized lending, KYC/AML, compliance automation, AI-powered attestations, smart notaries, reputation systems, or entirely new use cases. Whether you're building a DeFi protocol, AI agent, consumer application, or institutional workflow, Chainlink Confidential AI enables trusted decision-making without exposing sensitive information.

Build a meaningful upgrade to an existing project using Chainlink technology!

We're looking for teams that enhance an existing application, protocol, or infrastructure by integrating Chainlink services to unlock new functionality, improve security, or create a better user experience.

Eligible Chainlink technologies include: Chainlink Runtime Environment (CRE) CCIP (Cross-Chain Interoperability Protocol) Chainlink Confidential AI Price Feeds Data Streams Proof of Reserve (PoR) VRF (Verifiable Random Function)

Important: Please use CRE instead of Chainlink Functions or Automation. Functions and Automation are being deprecated, and projects requiring this type of functionality should implement it using CRE.

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.

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.

Build financial primitives where privacy is a first feature, not an afterthought. Canton's sub-transaction privacy means counterparties never see each other's positions, exposure, or order flow.

Build something like:

• Private perpetuals DEX: traders' positions and P&L invisible to other participants until settlement
• Confidential margin management: bilateral collateral agreements where only the two counterparties see exposure
• Dark pool order matching: institutional-grade order books where order flow is hidden from non-participants
• Private lending protocol: loan terms visible only to lender and borrower, invisible to other depositors

Bring real-world financial instruments on-chain with the compliance, privacy, and settlement guarantees that institutions actually require.

Build something like:

• Tokenized bond issuance with private investor registry — cap table visible only to issuer and each individual holder
• Repo agreement automation — PvP settlement with confidential bilateral terms between counterparties
• Private equity secondary market — transfer restrictions and investor accreditation enforced in Daml, deal terms private
• Supply chain finance with selective disclosure — invoices visible only to the financing bank and the relevant supplier
• Confidential trade finance — LC workflows where importer, exporter, and bank each see only their portion

Build payment infrastructure and financial services where privacy is the default not a premium feature.

Build something like:

• Privacy-preserving cross-border payment: sender and receiver amounts hidden from other network participants
• Neobank on Canton: multi-party account management where each customer's balance is invisible to others
• Stablecoin-based treasury management: corporate cash pooling with subsidiary-level privacy from parent visibility

Build autonomous financial workflows where AI agents transact, settle, and manage assets on behalf of users with every constraint encoded in Daml, not enforced by middleware.

Build something like:

• Autonomous subscription billing engine: agent uses Canton's native SubscriptionInitialPayment and renewal contracts to autonomously collect recurring payments without per-transaction approval
• Agent-orchestrated syndicated payment: an AI coordinator agent splits a single payment obligation across multiple counterparty validators atomically, where each recipient only sees their leg of the transaction
• Private AI-to-AI commerce with sub-transaction isolation: two agents from different organizations transact where each agent's validator only sees its own party's view, enforced at the protocol level not by middleware

Build AI agents and AI-powered products that use Ledger as the trust layer. We are looking for projects where device-backed security is central to the product: agents that pay for tools and services, systems that authenticate themselves with Ledger-secured identity, human-in-the-loop workflows for sensitive actions, and products that make autonomous behavior safer instead of bypassing user intent.

EXAMPLE DIRECTIONS

• Agents that pay for APIs, tools, or services with Ledger-secured payment flows, including x402-style patterns.
• Create human-in-the-loop agents where Ledger approves high-risk actions before funds move or permissions escalate.
• Ledger-backed identity, authentication, credentials, or policy-based spending for autonomous systems.
• Build AI copilots that explain transactions, simulate outcomes, or surface risks in complex flows.
• Developer agents that help teams integrate Ledger SDKs, generate Clear Signing artifacts, or validate implementation flows.
• Vertical products such as treasury agents, commerce assistants, or enterprise copilots where Ledger is the explicit control layer.

WHAT WE LIKE

• Real user value, not generic chatbot wrappers.
• Clear boundaries between autonomous behavior and explicit approval.
• Concrete use of Ledger primitives, not just wallet branding.
• Practical demos that show why device-backed trust matters for AI.

Dynamic handles your login, wallets, signing, and onchain UX, so you can focus on actually building something that matters. The world is your oyster!

Pay/accept stablecoins and crypto from any wallet and settle in the stablecoin of your choice. By abstracting away the swap-and-bridge step, Flow removes a major source of friction and unlocks a new class of applications, from point-of-sale systems to real-world payments.

So in a world where bridging and swapping don't exist, what would you build?

AI agents need wallets, signing, and a way to actually move value. Dynamic gives them all three. Build agents that transact, settle, and operate autonomously using Dynamic's server wallets, delegation, and Flow for programmatic deposits and payouts. Show us agents operating onchain.

Create tools that help applications, agents, or other composable integrations rank agents by feedback and reputation. Your goal is to highlight which ones support x402 payments, creating a one-stop place to discover trustworthy, payable agents in the emerging agent economy.

Ideas for your submission:

• Big Data meets ERC-8004: Build a real-time or historical explorer for ERC-8004 Identity, Reputation, or Validation registries.
• Advanced Analytics: Write SQL to pull ERC-8004 events, compute reputation scores, detect trends, or build activity heatmaps.
• x402 Integration: Flag agents with x402 payment metadata by joining on-chain data to provide transparency to the x402 ecosystem.
• Search & Filters: Build a natural language or filter UI over agent URIs, metadata, and reputation.

Build a product that helps users hold, grow, spend, or manage assets onchain using Privy's wallet and financial infrastructure.

Examples:

• Yield-bearing savings accounts
• Treasury management tools
• Stablecoin wealth apps
• Automated portfolio products
• Consumer investing experiences
• Onchain banking or payments products

What judges will look for:

• Meaningful use of Privy's Earn capability
• Clear financial use case and value proposition
• Thoughtful user experience
• Technical execution and product polish
• Potential for real-world adoption

Build the easiest way for users to bring assets into an application using Privy's universal deposit addresses.

Examples:

• Trading platforms
• Consumer fintech apps
• Gaming economies
• Cross-chain onboarding flows
• Wallet funding experiences
• Agent funding systems

What judges will look for:

• Meaningful use of universal deposit addresses
• Reduction of user friction
• Creative funding or onboarding flows
• Technical execution and polish
• Clear end-to-end user journey

Build an AI agent that can hold assets, move money, or interact with onchain services using Privy's Agent Wallet CLI.

Examples:

• Trading agents
• Research agents
• Personal finance agents
• Autonomous businesses
• Agent-to-agent commerce
• Automated payment systems

What judges will look for:

• Meaningful agent autonomy
• Creative use of onchain actions
• Technical sophistication
• Product usefulness
• Quality of the user experience

Take a real, widely-used open-source app and give it privacy. Unlink is an embedded privacy SDK (deposit(), transfer(), withdraw(), execute()`), so you can route an existing product's flows through private balances without rebuilding it. A working "private [well-known app]" is the kind of demo that we want to see.

Suggested targets (or pick any reputable OSS app):

• Wallets — MetaMask Snap, Rabby, Rainbow: add privacy to an existing wallet
• DeFi — Uniswap, Aave, Euler: route swaps or supply/borrow through a private account via execute()
• Treasury — Safe, Sablier, Superfluid: private payouts, streams, or treasury moves

Judged on how cleanly Unlink slots into the app, the privacy it adds, and how close the result is to something a company can deploy immediately.

Build a product where users move, own, and trade onchain without exposing their balances or history. Unlink handles all the privacy, so all you need to do is to call deposit(), transfer(), withdraw(), execute(), or more. This is the open track: the best product wins, fork or no fork.

What you can build:

• Private payouts: Pay teams, creators, and vendors without exposing history
• Stablecoin apps: Add private balances and transfers to user wallets
• Treasury operations: Move and rebalance funds without leaking strategy
• Private DeFi: Swap, lend, borrow, or allocate from private balances
• AI agent wallets: Give agents scoped funds without public strategy leaks
• Trade settlement: Settle OTC, RFQ, and market-maker flows privately
• Grants and rewards: Fund contributors without linking identity to payments
• Any other idea you have!

Judged on usefulness, UX, and how meaningfully privacy is embedded.

Already building something? Continue it here and make it private. This track is for teams extending their own existing project by adding Unlink, so the work you arrive with counts and the privacy layer is what you ship this weekend.

Good fits: a payouts tool, stablecoin or wallet app, treasury system, DeFi product, AI agent wallet, trade settlement flow, or grants and rewards platform you've already started, now with private balances, confidential transfers, or private DeFi via execute().

Judged on how naturally privacy fits the existing product, UX, and usefulness.

Create a custom Aqua app based 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.

Examples:

Leverage AMM Lending Options

Awarded to the best consumer-facing app that uses Blink to make funding feel fast, simple, and native to the product.

Examples include games, social apps, creator apps, marketplaces, fintech apps, betting-style apps, trading apps, or anything where users need to fund an account before using the product.

Projects will be judged based on product creativity, quality of integration, demo clarity, and how naturally Blink improves the user experience.

Awarded to the best consumer-facing app that uses Blink to make funding feel fast, simple, and native to the product.

Examples include games, social apps, creator apps, marketplaces, fintech apps, betting-style apps, trading apps, or anything where users need to fund an account before using the product.

Projects will be judged based on product creativity, quality of integration, demo clarity, and how naturally Blink improves the user experience.