Skip to content
[ ARKIV ]
Submit
Arkiv Ideathon August 2026

What can YOU [ ARKIV ] ?

Pitch what you'd build on Arkiv — the queryable, tamper-proof Web3 database. Design the idea, not the deployment.

Submissions close Aug 31 · 23:59 UTC

Submit your idea Explore the tracks
prize pool
$4,000
tracks
4
deadline
Aug 31
submit
an idea
Queryable Time-scoped Tamper-proof Ethereum-aligned

why arkiv

Arkiv is the Web3 database: CRUD + built-in indexes over Arkiv entities — filter, paginate and count like you would in SQL. Ethereum-aligned, $GLM-powered.

[ Two ways in ]

prompt

"show me Messi's goals against Real Madrid" await arkiv.buildQuery().where(eq("opponent", "Real Madrid")).fetch()

result

2 goals vs Real Madrid:
goal_311 El Clásico · 23' · 1st half · right foot
goal_207 La Liga · 79' · 2nd half · left foot

prompt

"keep every goal until August 20, then let it expire" await arkiv.createEntity({ goal, expiresIn: 2_592_000 })

result

Stored ✓ · 0x2f81…9c04 · expires Aug 20 · block #512,940.

prompt

"prove goal_311 was really recorded" await arkiv.getEntity("goal_311") // creator, block & tx — checkable on-chain

result

goal_311 · created at block #47,206 by 0xa1b2…88f0 · checkable against Ethereum.

prompt

"where do these goals actually live?" await arkiv.getEntity("0x2f81…9c04")

result

Arkiv DB-Chain ⇄ Ethereum:
arkiv DB-Chain · queryable entities · owner = your wallet
ethereum L1 anchor · final verifiability ✓

tracks

Submit to any track until Aug 31 — spotlights run back-to-back, Other is open all month. Tap a card for its brief — ideas, data model, host.

schedule

Hosted spotlights run in sequence — the form stays open for every track until Aug 31, 23:59 UTC.

August 2026 3 tracks + open lane
AI & DevTools Aug 3 – 11 Marketplaces Aug 12 – 20 DeFi Aug 21 – 31 Other · underlined, all month
  1. AI & DevTools Aug 3 – 11

    Hosted by SantiagoDevRel

  2. Marketplaces Aug 12 – 20

    Hosted by Shantelle

  3. DeFi Aug 21 – 31

    Hosted by Marcos

  4. Other All month

    Hosted by SantiagoDevRel

build

One connection: the Ideathon MCP. Your agent gets the tracks, the rules, the exact judging rubric and Arkiv's fundamentals — plus a prompt that pressure-tests your idea before you submit. No wallet, no key, nothing to deploy.

Step 1

Connect the Ideathon MCP

One URL, read-only, no key. Works with MCP clients that support remote servers — Claude Code, Claude.ai, Cursor and more. It carries everything official — tracks and briefs, rules and rubric, Arkiv fundamentals — so your agent designs grounded, not guessing.

Prompt — paste this to your agent

Add the Arkiv Ideathon MCP to my tools, then list its tools, resources and prompts so we know exactly what context we have.

https://ideathon-mcp.arkiv.network/api/mcp What's inside →
Step 2

Work the tracks with real context

Ask for a track's brief and idea seeds, search the knowledge base, or pull the scoring rubric — the same 100 points the judges use. Your agent even knows what deliberately stays OFF Arkiv, so it won't over-promise.

Prompt — paste this to your agent

Using the Ideathon MCP, pull the brief for the track that fits my idea and tell me the 3 things the rubric rewards most.

tools: list_tracks · get_doc · search_kb Arkiv docs →
Step 3

Pressure-test with review_my_idea

The built-in idea coach: it places your draft on a readiness band and asks the 3–5 highest-leverage questions on the judges' angles — the Arkiv counterfactual, data & query design, growth, scope. Answer, iterate, then submit sharp.

Prompt — paste this to your agent

Run the Ideathon MCP's review_my_idea prompt on my idea and ask me the questions that make it stronger.

prompt: review_my_idea Then submit it →

New to the entity model? Start with the Arkiv Fundamentals → — it explains exactly what the form asks about.

Pick a track Submit your idea

prizes

Pitch the idea and its Arkiv data model — no deploy. A $4,000 USDC pool across all tracks; submissions close Aug 31 · 23:59 UTC.

How to enter
  1. 1

    Pick a track

    Tap a track card for its brief — buildable ideas + what a strong submission looks like. Or bring anything to the open Other lane.

  2. 2

    Shape the idea

    Map it to Arkiv: which entities, which attributes, which queries. That data model IS the pitch.

  3. 3

    Answer the form

    Your form answers ARE the submission — no repo, no deploy. Optional: a mock, diagram or short video.

  4. 4

    Send it

    Submit before Aug 31, 23:59 UTC — your track's host reviews every idea.

Total pool
$4,000

Every winning idea gets $400 USDC from the $4,000 pool — up to 10 winners across the tracks, decided by the judging team against the published rubric. Strong ideas can also earn mainnet credits, follow-on build support and marketing amplification.

Prizes are paid in USDC to an EVM wallet. Prize winners complete KYC before payout. Winners & highlights roll out the week of Sept 1.

Judged on
Track alignment · 20 Arkiv fit · 20 Data & query design · 20 Impact & usefulness · 15 Clarity & feasibility · 15 Uniqueness · 10
Submit your idea Arm your agent first → Full rules & rubric →
1
Challenge 1 · spotlight Aug 3 – 11

AI & DevTools

Give your agent a real data layer. Ephemeral coordination state your agent writes and queries across runs — task queues, review traces, eval indexes, build recipes.

Agents and dev tools constantly need shared state that outlives a single run but shouldn't live forever: what's been claimed, what a review found, how an eval scored. Arkiv gives that state a queryable, time-scoped home with verifiable authorship — no side database, no indexer.

ideas to steal
  • 01

    Agent Handoff Queue

    A task queue where agents create, claim, update and close work items as Arkiv entities.

    Why Arkiv · Query by repo / status / priority / expiresAt; stale claims expire; creator metadata verifies who made each transition.

  • 02

    PR Review Trace

    A GitHub Action that stores an agent's findings, fixes and final status per commit.

    Why Arkiv · Query by repo / sha / severity; keep traces only through the review window; tx hashes make review state auditable.

  • 03

    Prompt Run Index

    A tiny eval harness that records prompt inputs, model metadata, scores and failures.

    Why Arkiv · Indexed numeric scores + timestamps make regressions queryable; a short expiry keeps eval clutter from piling up.

  • 04

    Build Recipe Registry

    A searchable registry of build recipes your agent pulls on demand.

    Why Arkiv · Recipes are entities indexed by stack / task / version; maintainers update them and readers verify the publisher.

  • 05

    Incident Context Board

    A shared incident scratchpad for logs, hypotheses, owners and mitigations.

    Why Arkiv · Time-scoped entities fit the incident window; query by service/severity; signed updates keep the timeline verifiable.

What a strong submission looks like

A crisp write-up: the problem, the Arkiv entity + attribute schema you'd use, the queries your agent relies on, and why Arkiv beats a plain database. A mock, diagram or pseudocode makes it sing.

Santiago Zuluaga
Host · Challenge 1
Submit your idea Challenge 1 · Aug 3 – 11
2
Challenge 2 · spotlight Aug 12 – 20

Marketplaces

Listings, quotes, bookings, bounties — anything with a lifecycle. Filterable by price/category/expiry, self-pruning when it goes stale, with verifiable authorship on every write.

Marketplaces are mostly state management: what's listed, what's been quoted, what's still available, who said what. Arkiv models each of those as a queryable entity with an expiry and a verifiable creator — so inventory filters cleanly and expires itself instead of going stale.

ideas to steal
  • 01

    RFQ Quote Board

    Buyers post requests; sellers post quotes; the UI filters active quotes by price, category and expiry.

    Why Arkiv · Quotes expire automatically; numeric attributes power price/deadline queries; signer metadata verifies quote origin.

  • 02

    Dispute Evidence Packet

    A dispute page where buyers and sellers attach time-bounded evidence entities.

    Why Arkiv · Query all evidence by orderId and side; keep it only through the dispute window; every attachment has a verifiable creator.

  • 03

    Availability Slots

    A booking marketplace for desks, devices or services with expiring availability slots.

    Why Arkiv · Slots are CRUD entities indexed by location / start / price; expired slots prune themselves instead of rotting as inventory.

  • 04

    Bounty Microboard

    A lightweight task marketplace with open bounties, submissions, reviews and status.

    Why Arkiv · Query by skill / reward / deadline / status; owner fields distinguish sponsor, submitter and reviewer.

  • 05

    Seller Signal Feed

    Sellers publish short-lived inventory, SLA or capacity signals buyers can query before transacting.

    Why Arkiv · Time-scoped signals prevent stale claims; attributes make availability filterable; tx-linked updates are verifiable.

What a strong submission looks like

One marketplace flow, designed end-to-end: the entity schema for a listing/quote, the filters buyers run, how state updates and expires, and where verifiable authorship shows up in the UI.

Shantelle Awomoyi
Host · Challenge 2
Submit your idea Challenge 2 · Aug 12 – 20
3
Challenge 3 · spotlight Aug 21 – 31

DeFi

Market evidence, risk snapshots, oracle notes, intent feeds. Keep execution off the hot path and use Arkiv as the queryable, tamper-proof state around it.

DeFi generates mountains of state that isn't the swap itself: bids, risk snapshots, oracle candidates, incentive epochs, treasury intents. Arkiv is a good home for that — queryable and tamper-proof, time-scoped to the window it matters in, and explicitly not on the execution hot path.

ideas to steal
  • 01

    Auction Evidence Board

    Solvers publish bid metadata, fills and dispute evidence for an auction window.

    Why Arkiv · Query by auctionId / solver / asset / timestamp; evidence expires after the challenge window; creator metadata verifies source.

  • 02

    Liquidation Watch Snapshot

    A dashboard storing periodic risk-state snapshots for mocked lending positions.

    Why Arkiv · Query by market / collateral / healthFactor; snapshots are time-scoped and verifiable, without being execution-critical.

  • 03

    Oracle Round Notes

    Reporters publish candidate values, source links and challenge status for oracle rounds.

    Why Arkiv · Query by asset / round / status; entries live through the dispute window; signer metadata verifies reporter identity.

  • 04

    Incentive Epoch Explorer

    Pools publish incentive parameters per epoch; users query current and previous epochs.

    Why Arkiv · Numeric epoch/pool attributes make incentives filterable; expired epochs prune; updates carry tx hashes.

  • 05

    Treasury Intent Feed

    A DAO publishes swap/payment intents and competing quotes before execution.

    Why Arkiv · Query active intents by token / size / deadline / status; quotes expire; creators are verifiable before a signer acts.

What a strong submission looks like

A DeFi concept with an explicit off-hot-path scope: what evidence/state you'd store as entities, the queries that read it, and how expiry + verifiability become product features.

Marcos Miranda
Host · Challenge 3
Submit your idea Challenge 3 · Aug 21 – 31
Open track · all month

Other

Doesn't fit the other three? Bring it here. Registries, RWA, provenance, governance, social graphs, game state — if it truly uses Arkiv's model, it belongs.

Not every good idea is AI, a marketplace or DeFi. This track is the open lane for everything else that maps cleanly to Arkiv: registries and RWA, provenance trails, governance state, social graphs, game or world state. The bar is the same — it has to genuinely need queryable, time-scoped, tamper-proof entities, not just any storage.

ideas to steal
  • 01

    On-chain Registry

    A queryable registry of anything — domains, licenses, memberships, certificates.

    Why Arkiv · Entities indexed by owner + attributes; expiry models renewals; creator metadata proves who issued each entity.

  • 02

    Provenance Trail

    Track an asset's history as a chain of time-stamped, verifiable entities.

    Why Arkiv · Query the full trail by asset id; each step is a signed write; expiry can scope custody windows.

  • 03

    Governance Log

    Proposals, votes and rationales stored as queryable entities per cycle.

    Why Arkiv · Filter by proposal / voter / status; verifiable authorship on every vote; epochs prune old cycles.

  • 04

    Social Graph Snippets

    Follows, reactions or badges as lightweight, self-expiring entities.

    Why Arkiv · Query by actor + type; ephemeral signals stay cheap; owners are verifiable.

  • 05

    Game / World State

    Off-chain-fast game events mirrored as queryable, verifiable entities.

    Why Arkiv · Query by session / player; the expiry fits a match; verifiable results without a central server.

What a strong submission looks like

A clear pitch for something outside the three named tracks: the entity model, the queries, and a straight answer to 'why Arkiv and not a normal database?'

Santiago Zuluaga
Host · Open lane — bring anything
Submit your idea Open lane · all month