Lepton

Agents Hackathon
In partnership with Circle & Arc

Paid by the fraction. A builder series for AI agents and the creators they serve, moving value too small to have been worth moving before: per article, per listen, per call, per second. Settled instantly on Arc in USDC.

The lepton was the smallest coin of the Greek world, a hundredth of a drachma. The name endured two and a half thousand years, until the euro replaced the drachma in 2002. Nanopayments are the lepton reborn for machines: value as small as $0.000001, clearing in under half a second.

Format
Online · 3 weeks
Dates
Jun 15 → Jul 6
Settlement
Arc · <500ms
Access
Invite-only
A one-lepton bronze coin in an olive wreath, inscribed ΛΕΠΤΟΝ
One Lepton
Greece · ΛΕΠΤΟΝ · the smallest coin
Hosts
00

The Lepton Agents Hackathon is hosted by Canteen, a builder series for AI agents and creators that pay, receive, and stream value at the smallest scale, settled on Arc, the stablecoin-native L1 from Circle.

Canteen · Host

A research and technology firm working at the intersection of crypto, AI, and payments. Hosts and curates the Lepton Agents Hackathon.

Circle · Platform (NYSE: CRCL)

A global financial technology firm building the most widely used stablecoin network. Issuer of USDC and EURC.

Arc · Settlement

The purpose-built L1 blockchain from Circle, where capital, humans, and machines coordinate. Native USDC gas and sub-second finality make sub-cent payments economical for the first time.

Get
Started
01
00
Register on Luma (if you haven't already)
Enter your GitHub handle and Discord handle accurately, since this is how we collate submissions.
01
Join the Canteen Discord
Drop in and say hello. Tell us who you are and what you're building. The Canteen team is around, and so are the other Arc builders.
02
Join the Arc builder Discord
Mention Canteen + Lepton in the onboarding flow. If you get rejected or have trouble joining, ping @kdrohan in the Canteen Discord.
03
Install the ARC CLI
uv tool install git+https://github.com/the-canteen-dev/ARC-cli
Includes RPC access to a Canteen-hosted Arc testnet, plus Arc repos and docs pre-bundled as agent context, so your coding agent can build against Arc out of the box.
04
Install the Circle CLI
npm install -g @circle-fin/cli
A unified interface for agent wallets, x402-compatible payments, and crosschain USDC transfers, straight from the command line. Requires Node.js v20.18.2+.
05
Arc 101
Get started with Arc, the Circle Agent Stack and Nanopayments. Walk through the Arc 101 demo to see the full stack come together, then clone the companion repo to build from a working example.
git clone https://github.com/the-canteen-dev/circle-agent
Slides: Arc 101 demo
06
Read the Distribution Bootstrap
The hard part of a payments product was never the rail — it was finding the people. The Distribution Bootstrap for Payments Founders is the companion to the Distribution section below: it sketches eight starting points to add to or remix with the RFBs, in a rough order to deploy, attaching payments to open-source communities that are already gathered through the webhooks, plugins, and APIs they already expose.
07
Submit your project: forms.gle/SMqLaw2pMGDe58LFA
Deadline: the submission form must be filled out by 11:59 PM ET on July 6, 2026.
You will need: a public link to your GitHub repo and a short recorded video demo (keep it under 3 minutes). A live deployed link is optional but strongly encouraged. You will also be asked traction questions: how many users you have onboarded, and what user problems you are building for. You can submit as many times as you like before the deadline.
Overview
02

For as long as a payment couldn't be smaller than roughly thirty cents after fees, there was no way to sell a five-cent article or a one-cent play. The only move was to bundle a month of them and charge ten dollars. Every subscription is a quiet admission that the real unit was too small to sell on its own.

Nanopayments remove the floor. Value as small as $0.000001, gas paid in USDC rather than a volatile token, settled in under half a second on Arc with gasless batching. The smallest unit becomes sellable for the first time. That is why this round leans toward creators and publishers: they are the ones the floor priced out, and they already have the audiences.

People are no longer the only ones paying. AI agents can now pay each other per call, per byte, per second, which turns "what should this cost?" into a decision an agent makes thousands of times an hour. Treat the sub-cent payment as a primitive, treat your agent as something that earns and spends, and the products start to suggest themselves.

Smallest payment
$0.000001 via Gateway, gas-free and batched
Settlement
<500ms cross-chain, USDC gas on Arc
Awards
03
$50k across four tiers, paid in cash or equivalent
Grand Prizes
$40k TOTAL
  • 1st place: $10k · 1 team
  • 2nd place: $7.5k × 2 teams · $15k total
  • 3rd place: $5k × 3 teams · $15k total
Standout Teams
$7.5k TOTAL

10–12 teams demonstrating exceptional work, awarded in roughly equal shares (~$650–$750 per team). Not ranked within the cohort.

Feedback Incentives
$500 TOTAL

For developers who provide the most useful product feedback on Circle's developer tooling: friction points, product improvements, and developer-experience insights.

Easter Eggs
$2k TOTAL

Code-golf challenges, Discord puzzles, content challenges, and assorted side quests scattered throughout. Designed for explorers.

The smallest coin

Every economy mints a smallest coin.

Struck so ordinary people could pay for everyday things: the denomination of bread, water, and the day's wage. Mints kept shrinking the coin until it was too small to be worth striking. Software has no such floor, so the lepton becomes the nanopayment.

Λ
Lepton
Greece · λεπτόν
From leptós, "small, fine." A bronze coin a few millimetres across; the widow's two mites were lepta.
≈ 1/7 chalkous
•••
Quadrans
Rome · quadrans
The smallest everyday bronze, about a euro cent in today's money. Three pellets marked its value, and it bought a turn at the public baths.
¼ as
Kākaṇī
India · kākaṇī
The smallest copper coin named in Kautilya's Arthashastra; an ardha-kākaṇī was smaller still.
¼ māsha
Wén
China · 文
The round bronze cash with a square hole; a thousand strung on a cord made one guàn.
1/1000 guàn
Pashiz
Persia · pašīz
Copper small change of the Persian world; the silver siglos bore the royal archer, the pashiz served the everyday.
copper · ¼ siglos

In daily life these were the coins that mattered: a few obols covered a day's bread in Athens, and a Roman entered the public baths for a single quadrans. Not every economy minted them. Egypt weighed value instead (the deben and its tenth, the kite), and China and India used cowrie shells for the smallest change.

The
Stack
04

Circle's developer platform on Arc, the primitives best suited to agents and creators that move money at the smallest scale. Use what you need.

Agent-native tooling: give an AI agent its own wallet, let it discover and pay for x402 services, and transact across chains, all within built-in compliance guardrails. Circle CLI and Skills wire it into Claude Code, Cursor, Codex, or any custom agent.
Use case: the fastest path from a coding agent to one that autonomously holds and spends USDC. Start here.
Embed secure wallets in any app, with automated key management.
Use case: give every agent and every creator a wallet that can autonomously spend and receive.
Build and manage smart contracts.
Use case: pricing logic, escrow, revenue splits, and streaming payment flows.
x402 Protocol
The HTTP 402 "Payment Required" flow for pay-per-request APIs and content.
Use case: price any endpoint, article, or stream per request, settled on access. Live standard; the circlefin/arc-nanopayments reference shows it end to end.
The leading digital dollar and digital euro.
Use case: native settlement on Arc and multi-currency creator payments.
Reference implementations · Arc sample apps

Open-source starting points: fork them, remix them, or use as scaffolding for your submission. Full index →

circlefin/arc-nanopayments: nanopayments end to end, with a LangChain paying agent, x402-protected seller endpoints, and Gateway batching. Start here.

the-canteen-dev/circle-agent: a Canteen-built explainer companion to arc-nanopayments.

circlefin/arc-commerce: USDC payments for credit purchases.

circlefin/arc-multichain-wallet: unified USDC balance and crosschain transfers.

circlefin/arc-escrow: AI-powered work validation and USDC settlement.

circlefin/arc-fintech: multichain treasury with crosschain capital movement.

circlefin/arc-p2p-payments: seamless, gasless peer-to-peer payments on Arc.

circlefin/arc-stablecoin-fx: USDC↔EURC FX swaps via the App Kit Swap SDK.

circlefin/arc-defi-lending-and-borrowing: DeFi lending, using cirBTC as collateral to borrow USDC.

circlefin/arc-prediction-markets: decentralized prediction markets, powered by UMA.

App Kits · Multichain payment SDKs

A suite of SDKs for composing multichain payment and liquidity flows behind one type-safe interface, so you build against a single API instead of wiring up each protocol per chain. Install the all-in-one App Kit SDK, or pull in individual kits. Install guide →

Send: transfer tokens between wallets on the same blockchain.

Bridge: transfer USDC across blockchains.

Swap: exchange one token for another on the same blockchain.

Unified Balance: a chain-abstracted balance you can spend instantly.

Combine: chain multiple capabilities into one flow — e.g. crosschain swap (Bridge + Swap).

Requests
for Builders
05

RFBs, Requests for Builders, are our version of YC's Requests for Startups. Six open problems worth solving when the smallest payment finally clears. This round leans toward RFB 6: Creator & Publisher Monetization, the people the payment floor priced out. But these aren't tracks. Build what you care about, or surprise us.

The problem. Your agent needs paywalled APIs, premium data, or compute. How does it autonomously discover, evaluate, and pay for these services without overspending?

What the AI decides
  • Which resources are worth paying for (cost vs value)
  • Budget allocation across competing services
  • When to cache versus re-fetch paid content
  • Quality and price tradeoffs between providers
What builders create
  • Agents that autonomously pay for x402-protected resources
  • Budget systems with daily/weekly limits and smart allocation
  • Cost-benefit analyzers: is this $0.001 call worth it for the task?
  • Multi-provider routing to the cheapest or fastest option
Example builds
  • ResearchAgent: pays for premium sources and papers while researching a topic
  • BudgetBot: a $10/day budget optimized across dozens of paid APIs
  • ArbitrageReader: buys real-time feeds only when expected value beats the data cost
Traction metrics
  • Total autonomous payments made
  • Average transaction size (target: sub-cent)
  • Budget utilization efficiency · cost per task completed

The problem. Your agent provides a valuable service: analysis, generation, transformation. How do you monetize it per use, without the overhead of subscriptions?

What the AI decides
  • Dynamic pricing by demand, complexity, or compute cost
  • Whether to accept a payment offer or negotiate
  • Quality tiers: faster or better for a higher payment
  • Capacity allocation across paying customers
What builders create
  • x402-enabled agent APIs (pay-per-call for agent services)
  • Dynamic pricing engines based on complexity and current load
  • Agent service marketplaces with real-time pricing
  • Metered services: pay per token, image, or row processed
Example builds
  • SummarizerAPI: $0.001 per paragraph summarized
  • ImageGenService: $0.01 per image, dynamic pricing at peak
  • CodeReviewBot: charges per line reviewed, with complexity multipliers
Traction metrics
  • Total revenue earned · unique paying clients
  • Transactions per hour · average price per request

The problem. Agents need to pay other agents for specialized services. How do we build fluid, real-time economic networks between them?

What builders create
  • Agent service discovery with real-time pricing
  • Reputation systems on payment history and service quality (ERC-8004 gives onchain identity, reputation, and validation)
  • Multi-hop workflows with automatic payment splitting
  • Escrow for complex agent-to-agent agreements
Questions to explore
  • Do agent pricing wars emerge: race to the bottom, or quality differentiation?
  • Can agents form guilds or co-ops for pricing power?
  • Do specialized broker agents emerge to match supply and demand?
Example builds
  • AgentMesh: agents discover and pay each other for chained services
  • NanoEscrow: sub-cent escrow for agent task handoffs
  • AgentBroker: matchmaking agent taking a 0.1% fee to connect providers with requesters
Traction metrics
  • Agent-to-agent transaction volume · network graph density
  • Average settlement time · payment chain depth

The problem. Some services aren't discrete, they're continuous. How do agents and viewers pay for ongoing compute, real-time data, or time-based services?

What builders create
  • Pay-per-second streaming payment infrastructure
  • Continuous authorization: approve a spending rate, not each transaction
  • Real-time usage metering with instant billing
  • "Tap to stop" streams agents can start, pause, and cancel
Use cases
  • GPU rental billed by the millisecond, stopping when done
  • Live data feeds paid per update, paused in quiet periods
  • Real-time transcription paid per second of audio
  • Live media (video, audio) paid per second watched
Example builds
  • StreamPay: infrastructure for pay-per-second agent services
  • ComputeStream: rent GPU by the millisecond, pay only for usage
  • DataFaucet: real-time market data with per-update pricing
Traction metrics
  • Total streaming volume · average stream duration
  • Payment granularity achieved · stream start/stop latency

The problem. Building nanopayment-enabled agents is hard. What infrastructure and developer tools make it easy? Note: the facilitator and starter-kit lane is already crowded, so aim at applications and orchestration.

What builders create
  • SDKs that add x402 payment to any agent framework
  • Wallet management for agent fleets (1,000 wallets at once)
  • Analytics dashboards for agent spend and earnings
  • Testing and simulation environments for nanopayment flows
Developer experience focus
  • "Add nanopayments to your agent in three lines of code"
  • One SDK across frameworks (LangChain, CrewAI, custom)
  • Testnet faucets, simulation modes, real-time spend dashboards
Example builds
  • NanoPay SDK: drop-in autonomous payments for agent frameworks
  • AgentTreasury: dashboard for managing a fleet of wallets
  • x402-middleware: Express/FastAPI middleware for instant API monetization
Traction metrics
  • Developers and projects using the tools · agents deployed
  • Transaction volume through the platform · time-to-integration

The problem. Subscriptions don't fit all content. How do creators monetize individual pieces (one article, one photo, one song) without forcing readers into recurring fees? See the Prior Art section for eight worked angles.

What builders create
  • Pay-per-article reading (unlock for $0.05, not $10/month)
  • Micro-tipping for citizen journalism and independent reporters
  • Per-piece creator support instead of recurring pledges
  • Revenue splitting for collaborative content (co-authors, editors)
  • AI reading lists that auto-pay creators as you consume
Use cases
  • Citizen journalism: a reader tips $0.10, the reporter is paid instantly
  • Newsletter unbundling: pay $0.02 per article, not for 50 subscriptions
  • Music and podcasts: pay per listen, not per month
  • Photography: license a single image for $0.25 with instant settlement
Example builds
  • ReadPay: browser extension that auto-pays x402 articles as you read
  • TipJar: embedded widget for instant creator tips, no minimum
  • SplitStream: content platform that auto-splits payment to every contributor
  • NewsWallet: citizen journalism where reporters earn per reader, not per ad
Traction metrics
  • Creators earning · total creator payouts
  • Average payment per piece · reader-to-payer conversion

Anything goes. The six RFBs are prompts, not limits. Build whatever you believe in: if it does something real on Arc, we'll take it as a valid submission. Surprise us.

Coming from Agora

If you started a project at the Agora hackathon, you're welcome to keep building it here. To be eligible for prizes, though, your submission needs real progress on both fronts since then: traction and product. We weigh the two equally.

Voices · on small money
"Money makes all things commensurable, since all things are measured by money."
Aristotle Nicomachean Ethics · Book V // on dividing value to the smallest unit
"If you add a little to a little, and do this often, soon it becomes great."
Hesiod Works and Days · c. 700 BCE // on small sums adding up
"Men agreed to employ in their dealings something intrinsically useful and easily handled, such as iron, silver, and the like."
Aristotle Politics · Book I // on the origin of coined money
Distribution
06

The hard part of a payments product was never the rail. It was finding the people. For creator payments, they are already gathered: open-source, self-hosted communities with large, established audiences and no built-in way to move money between the people who make the work and the people who value it. Add a payments layer and the whole catalog opens at once: patronage, royalties, pay-per-view, tips, quadratic funding.

You don't have to build the audience or fork the project. Each of these already exposes the webhooks, plugins, and APIs you need to attach payments from the outside.

ProjectWhat a payment layer unlocksStars
immich-app/immichLicensing and tips paid to the photographer named in the file103k
TryGhost/GhostPaid memberships, subscriptions, and newsletters for writers54k
jellyfin/jellyfinPay-per-view, rentals, or a creator subscription on your own media server53k
mastodon/mastodonPatronage and quadratic funding for the posts a community values50k
discourse/discoursePaid groups and gated categories for a community's best threads47k
DIYgod/RSSHubPaid feeds, and citation tolls when an answer is grounded in a source44k
navidrome/navidromeRoyalties split by what listeners actually played21k
chocobozzz/peertubePer-view or per-second streaming, split across contributors15k
owncast/owncastLive tips and pay-to-watch streams11k
Kareadita/KavitaPay-per-book or rentals on a self-hosted reading library11k

and dozens more across music, video, photos, writing, and the fediverse.

And the split is often already written down. beetbox/beets and metabrainz/picard keep track credits and provenance, immich keeps the photographer in the file. Read that graph and attribution metadata becomes the payout rule: every collaborator paid automatically, in the proportions the credits already record. Nanopayments push it furthest, into the per-listen and per-citation cases that were always too small to clear, but the opening is the same everywhere: the users are already here, and no one has been paying them.

Ideas to remix with the RFBs

Not directives or mandates — just starting points to add to or remix with the RFBs. The Distribution Bootstrap for Payments Founders sketches eight of them, in a rough order to deploy.

The Subsonic-Protocol Scrobble Sidecar: a binary that registers across Subsonic servers, keeps an artist-to-wallet registry, and settles per-listen payments onchain with per-user spending caps.
The MusicBrainz Payee Registry: an artist-MBID-to-wallet mapping that handles credit splits using the metadata standards beets and Picard already write.
The Owncast Per-Second Streaming Webhook Sidecar: a webhook subscriber that derives viewing duration from join/leave events and settles per-second rates to live streamers.
The Jellyfin Per-Minute VOD Sidecar: subscribes to Jellyfin playback events, computes elapsed time per session, and settles per-minute fees to rights holders.
The PeerTube Payments Plugin: a maintained plugin for PeerTube's plugin loader supporting multiple payment rails, including onchain and Monero options.
The Mastodon Donation-Campaign Provider: an external service that feeds campaign data into Mastodon's new donation-campaigns API, configurable per instance.
The LLM Crawler Citation-Toll Layer: per-citation micropayments at the agent boundary that settle to source authors when their work grounds a generated answer.
The Settlement Core: portable backend infrastructure handling subscriptions, billing, multi-currency conversion, and transactional emails for all of the above.
Prior
Art
07

Old practices that nanopayments make buildable again. When the smallest unit of value can finally move, the creator economy stops routing through platforms and starts paying people directly: quadratic funding for content and royalties that follow a work through every hand that made it. Drop the floor far enough and agents start doing it too, by paying each other and staking real money on their reputation.

Engraving of a Roman praeco, the public crier
The praeco · Rome's public crier, paid to carry the news
Red-figure amphora showing a kithara player
The rhapsode · paid by the crowd for the performance they heard
01
Content that earns every time it is cited
The herald was paid for every retelling, not only the first · the kēryx and the praeco

The fastest-growing consumers of content are AI agents and aggregators, and they read the work as free substrate. The hack: give a piece a price for being used as a source, and have an x402 payment settle to the origin the moment an agent grounds an answer in it or another site republishes it. The payment is the easy part; the real build is an attribution layer that detects reuse and proves it, with DIYgod/RSSHub a natural host since it already sits between sources and the feeds that consume them. At Gateway's $0.000001 floor a single citation is worth settling.

Ties to RFB 6 · Creator & Publisher Monetization. The reporter who files a local story should earn from the thousand places it travels, not only the readers who land on the page.

02
Patronage the supporter can resell
A patron's only return was reflected glory · Maecenas, under Augustus

The hack: a recurring micro-pledge that converts into a transferable claim on a creator's future tip and subscription flow, so backing someone early is a position that appreciates if they grow and can be sold on. It gives a small creator an upfront-capital path that monthly subscriptions never could, and opens a market that prices creators before the platforms notice them. Sub-cent fees are what make a claim worth a few dollars actually tradable rather than eaten by gas.

Ties to RFB 6 · Creator & Publisher Monetization. Recurring support is the floor; letting an early believer own a slice of what they helped build is the part subscriptions can't reach.

03
A thousand small backers outweigh one large one
The smallest coin, given by many, was the truest measure of worth · the widow's two mites, Gospel of Mark 12

The hack: a quadratic-funding pool where a piece backed by a thousand people at $0.001 beats one backed by a single hundred-dollar donor, because breadth of support sets the match, not its size. The mechanism is proven (Gitcoin runs it for software) but has never reached content, because contributions that small couldn't clear on their own. Sub-cent settlement is the unlock; the build is the matching pool plus a sybil-resistance layer, dropped into a community like LemmyNet/lemmy or a mastodon/mastodon instance as the way it funds its best work.

Ties to RFB 6 · Creator & Publisher Monetization. Tipping sets how much one reader gives; this sets what the whole room chooses to keep alive.

04
Royalties that follow a work back through everyone who made it
Master, apprentices, gilder, panel-maker: every hand shared the one commission · the workshop

The hack: splits that are recursive and automatic, following a lineage graph, so a remix of a remix pays every ancestor and an edited photo pays the original photographer, settled per play or per view. The enabler is that the lineage already exists as data: beetbox/beets and metabrainz/picard hold track credits and provenance, immich-app/immich holds photo origins. Read that graph, make it the payout rule, and attribution metadata becomes settlement logic. A six-way split of a $0.25 license is only worth doing when the fee is a fraction of a cent.

Ties to RFB 6 · Creator & Publisher Monetization. Collaboration stops being a payout someone reconciles by hand and becomes a property of the file itself.

05
Your money goes only to the artists you actually played
Paid by the crowd in front of him, for the performance they actually heard · the rhapsode, town to town

Streaming platforms pool every subscription and pay out pro-rata, so your money mostly funds whoever is globally popular, not who you listened to. A self-hosted server like navidrome/navidrome or koel/koel already keeps your complete, honest play history. The hack: user-centric royalties on top of it, where your monthly amount is split only across the artists you played, by real listens, settled to them directly, with play-gating so a skip in the first seconds costs nothing. The majors have refused this model for years; direct sub-cent settlement makes it the easy default.

Ties to RFB 6 · Creator & Publisher Monetization. The most honest way to support an artist is to pay the ones you actually listen to.

06
You pay for the rate of flow, by the second
A grant of water was a rate of flow, not a volume · the quinaria, Frontinus' De Aquaeductu

The hack: continuous-authorization streaming for live media, where a viewer approves a spending rate instead of a price and a show on owncast/owncast or chocobozzz/peertube bills per second watched, revenue accruing in real time and splitting live across everyone on the stream. Leave at any second and you've paid for exactly the time you were present, while the creator watches it accrue and can surge the rate at peak. Reserved-but-unused time can auto-sell back to the pool, and a proof-of-flow check pauses the meter the instant delivery drops. Streaming payments are a real code gap in the x402 world, so even the base layer is open ground, and it only settles cleanly on sub-second finality with gasless batching.

Ties to RFB 4 · Streaming & Continuous Payments. The unit of a live performance is the second, so the unit of paying for it should be too.

07
Reward what turned out to matter, paid out after the fact
The prize was awarded after the contest, once every work had been performed · the City Dionysia

The hack: retroactive funding for content. A sponsor pool pays out at the end of each period to the work that proved most valuable, with the split set quadratically by how many distinct people engaged rather than by how much any single backer gave. A crowd can agree on what was good far more easily than it can predict it, and the citation and play signals that already meter direct payments (items 01 and 05) become the impact record each round settles against. Sub-cent settlement is what lets one round distribute across a long tail of thousands of creators in a single sweep instead of handing out a few grand prizes.

Ties to RFB 6 · Creator & Publisher Monetization. The clearest signal of what deserved support is what people kept coming back to once it existed.

08
Reputation you post as collateral, not a score you ask to be trusted
The banker staked his own standing on the coin he vouched for · the trapezitai and argentarii

The hack: a broker agent that posts a USDC bond to stand behind a match, and if the provider it routed you to underdelivers, the bond slashes automatically the moment the outcome resolves. Reputation becomes capital at risk rather than a number you have to believe, which is far harder to fake, and the slash settles in under a second on Arc. This is the natural application of ERC-8004 (onchain agent identity and reputation), a lane the planning work flags as nearly empty next to the crowded facilitator space.

Ties to RFB 3 · Agent-to-Agent Nanopayment Networks. A broker worth using is one with something to lose when the introduction goes wrong.

How we
judge
08

We weigh agency and traction equally. Genuine usage matters even on a testnet: people actually using it, payments actually flowing in test USDC, and we want to see both. These weightings are recommendations. Judges have the final say, and the best projects tend to break the rules.

30%
Agentic Sophistication
How much does the AI actually decide versus just automate? Full autonomy beats meaningful agency beats AI-flavored automation.
30%
Traction
Genuine usage during the event window: people actually using it, payments actually flowing in test USDC, volume you can point to. For creator builds: creators getting paid and readers paying. Great founders ship and get users in three weeks.
20%
Circle tool usage
Creative, effective use of the platform: Wallets, Gateway and Nanopayments, App Kit, Contracts, x402, USDC.
20%
Innovation
Novel approaches, emergent behavior, research insight. New territory beats polished re-runs.
Final delivery

There is no live demo day. Judging is asynchronous: submit through the project form, and the judges review on their own time after the deadline. You can submit as many times as you like, so submit early and often.

Video demo · required
A recorded walkthrough on Loom, YouTube, or Vimeo. Keep it under 3 minutes.
Live product link · encouraged
A working URL judges can use hands-on. Optional, but strongly encouraged.

Plus a public GitHub repo, which is required. Judges read the repo directly and work hands-on with your live product where one is provided. Build for a reviewer who will click around without you in the room.

From
our friends
09

A couple of teams building alongside us. Use them while you're shipping, and tell them we sent you.

FAQ
10

The short version: build whatever you want, as long as it runs on Arc, you actually care about it, and people are already using it. It's a testnet, so the payments are test USDC, but the usage should be genuine: real people putting it to work. The building is the easy part now. Building something that lasts past July 6 is the whole game, and for the teams that keep going, we keep going too: funding, grants, and partnership support after the event.

Whatever you want. The field is open, and the six RFBs and prior-art ideas are prompts, not tracks. What we're looking for comes down to three things, and they matter in this order:

  • It runs on Arc, with payments actually flowing in testnet USDC on the Circle Agent Stack.
  • It's something you genuinely care about and intend to keep building after the three weeks are up, not a demo you'll abandon on July 7.
  • It's already in front of people who use it, solving a real problem they actually have.

We weigh agency and traction equally. Genuine usage matters even on a testnet: people actually using it, payments actually flowing. We want to see both.

No. The RFBs and the prior-art section exist to get you started, not to box you in. This round leans toward creators and publishers because they're the ones the payment floor priced out, but if you surprise us with something better, that wins. As the judging note says, judges have the final say and the best projects tend to break the rules.

That's the point. With the ARC CLI, the Circle CLI, and a coding agent, you can stand up a working payments product in a weekend. We don't want to undervalue that, shipping is real work and not everyone does it. But shipping was never the hard part of a payments business.

The hard part is finding the people, earning their trust, and giving them a reason to come back. Great founders ship and get users in three weeks. That's what we're testing for, not the cleverest demo.

Because a project that's still alive and growing a year from now is worth far more than the cleverest demo that quietly winds down once the event is over. We're not looking for the best two-week sprint. We're looking for the beginning of something you'll still be building when the prize money is long spent.

This is why we point everyone at the Distribution Bootstrap: the rail is easy, distribution is the whole game, and distribution only compounds if you stay with it. And if you do stay with it, we stay with you, see below.

Unlike most hackathons, the prize isn't the finish line for us. If you're serious about building a real thing past July 6, we commit for the long run alongside you. We have follow-on support for teams that keep going:

  • Funding to take the project beyond the prototype.
  • Grant support to keep building while you find traction.
  • Partnership support across Canteen, Circle, and the Arc ecosystem: distribution, introductions, and a path to real users.

The three weeks are how we meet you. What we're really looking for is the small handful of teams we'll still be backing a year from now. If that's you, tell us in your submission and find us in the Canteen Discord.

Yes. If you've already started something — at a prior hackathon, a side project, an unfinished prototype — you're welcome to carry it forward here. That's exactly the kind of long-run building we're after. But we judge the delta, not the whole project: what you shipped and who you reached during Lepton. Where was the product and how many users did it have when Lepton began, and where are both at the end?

That gap is what's eligible for prizes, on both fronts equally: product and traction. New features built and new users onboarded during the program count; work that already existed when you started doesn't. So tell us where you left off, and show us how much further you've taken it.

Apply
11

Make the smallest
unit sellable.

Three weeks, six RFBs, payments settled on Arc in testnet USDC. If you build for creators, this round is for you.