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.

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:

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)

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

This is a collaborative bounty between Dynamic, Arc, and Unlink.

Machines are starting to pay each other (for API calls, inference, data, and compute) in amounts far too small for traditional rails. But today those payment streams are fully transparent: anyone can watch an agent's spend, infer its strategy, and map its counterparties.

Build a system where autonomous agents (or users) make high-frequency, low-value payments that are also private. How the pieces fit together:

• Dynamic embedded/server wallets give your agents (or users) a wallet and sign the offchain payment authorizations — no seed phrase, no popup per payment.
• Arc + Circle Gateway provide the gas-free, stablecoin-native nanopayment rail (USDC via x402 / batched settlement) where sub-cent payments make economic sense.
• Unlink wraps the flow so balances, transfer amounts, and counterparty history stay confidential

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

Leverage Chainlink's Confidential AI Attester to bring verifiable AI reasoning onchain. Combine authenticated offchain data, trusted execution environments (TEEs), and AI inference to create cryptographically-backed attestations that smart contracts can consume for decision-making. Build applications spanning DeFi credit markets, compliance, identity, proof of reserves, and other trust-minimized financial use cases.

Come see us at the Chainlink desk to get an API key to access the Attester

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.

Special Prize: one of the $1,000 prizes goes to the Best Video Presentation, the most compelling public demo video showcasing a project built on the Uniswap stack. To qualify, the video must be publicly posted, explicitly mention Uniswap, and explain how the team integrated part of the Uniswap stack.

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

Pay and accept stablecoins or crypto from any wallet, exchange, or chain, and settle in the token of your choice. By abstracting away the swap-and-bridge step, Fireblocks Flow removes a major source of friction and unlocks a new class of applications.

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

Examples:

• Merchant & PSP acceptance: accept deposits in any token from any chain, settle in the stablecoin you prefer
• iGaming & prediction markets: take deposits from any wallet or exchange with compliance enforced on every transaction
• Agentic deposits: agents programmatically create transactions, attach funding sources, and submit via API
• Withdrawals & currency conversion: send funds out to a user's wallet, converting across chains and tokens in one flow (e.g. SOL from a vault -> USDC on Ethereum)
• Point-of-sale & real-world payments: accept any asset, settle in one

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, delegated access, and Flow (bonus) for programmatic deposits and payouts. Give your agent a wallet, or delegate from your own.

Let's see agents operating onchain!

Examples:

• Trading or DeFi agents that execute onchain strategies
• Agent-to-agent commerce and autonomous businesses
• Personal finance or treasury agents acting on a user's behalf via delegated access
• Agents that pay for APIs, tools, or compute through HTTP 402 / x402 payment flows
• Automated payment, payroll, or settlement systems

Dynamic handles login, seamless wallet onboarding, signing, and onchain UX, so you can focus on building something that matters. This is an open track - so no theme, no constraints, no limits. The best product wins.

Bonus:

• Depth over breadth
• Technical execution and ambition
• Real-world adoption potential

Already have an app? Give the wallet experience a makeover with Dynamic. Swap in smoother login, embedded wallets, better signing, multi-chain support, or onchain payments.

Examples:

• Add/extend multi-chain support (EVM, SVM, Sui, Bitcoin, TON, and more ) to your app
• Layer in payments or Flow where users previously had to bridge and swap by hand
• Add server wallets or delegated access to power new automated or agentic features
• Upgrade auth, key management, or signing UX in a product that already has users

🥇 1st place — $2,000 🥈 2nd place — $1,000

Build an app that combines Dynamic and Unlink to enable private nanopayments on Arc. Use Dynamic for wallet creation, Unlink for private accounts and private transaction routing, and Arc for high-throughput settlement. We’re looking for creative implementations of private transactions rather than one specific app category, surprise us with the use case.

This is a joint prize track.

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.

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

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

Already building something? Extend your existing project with one of Privy's newest capabilities.

We're looking for teams that integrate Privy Earn, universal deposit addresses, or the Agent Wallet CLI into an existing application, protocol, or product.

Examples:

• Add yield and savings functionality with Earn
• Add seamless funding with universal deposit addresses
• Give an AI agent the ability to hold assets and transact using the Agent Wallet CLI
• Upgrade an existing fintech, trading, or consumer app with new financial capabilities powered by Privy

What judges will look for:

• Depth of integration with Earn, deposit addresses, or the Agent Wallet CLI
• How much the integration improves the existing product
• Technical execution
• Product polish and user experience
• Potential for real-world adoption

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 an app that combines Dynamic and Unlink to enable private nanopayments on Arc. Use Dynamic for wallet creation, Unlink for private accounts and private transaction routing, and Arc for high-throughput settlement. We’re looking for creative implementations of private transactions rather than one specific app category, surprise us with the use case.

This is a joint prize track. There will be a 1st place prize for $2k and a runner up for $1k.

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.