Skip to content
[ ARKIV ]
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.

Each track closes when its window ends · last close Aug 31 · 23:59 UTC

Image
prize pool
$4,000
per track
$1,000
tracks
4
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

Each track closes at the end of its own window — the open Other lane runs all month. Tap a card for its brief — ideas, data model, host, and when it closes.

schedule

Each track closes at the end of its own window — the open Other lane runs all month. Windows run in sequence and each one closes at 23:59 UTC on its last day.

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

Connect to the Arkiv Ideathon MCP at https://ideathon-mcp.arkiv.network/api/mcp and show me what's inside — list its tools, resources and prompts with one line each, so I know it's connected and 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. Or connect the MCP above and ask your agent instead: it serves that same doc.

prizes

Pitch the idea and its Arkiv data model — no deploy. Every track has its own $1,000 USDC pool — $4,000 in total. Each track closes at the end of its own window — the open Other lane runs all month.

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. The track you pick sets your deadline.

  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 your track's window closes — its host reviews every idea.

Total pool
$4,000

Every track has its own $1,000 USDC pool: $500 for 1st place, $300 for 2nd, $200 for 3rd — $4,000 USDC in total, ranked by the judging team against the published rubric. If a track doesn't receive three ideas that meet the judging criteria, the remaining prize money from that track may be redistributed to other tracks. 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
1
Challenge 1 · submissions 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.

some inspiration
  • 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.

Image
Santiago Zuluaga
Host · Challenge 1
Submit your idea Submissions close Aug 11 · 23:59 UTC
2
Challenge 2 · submissions 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.

some inspiration
  • 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.

Image
Shantelle Awomoyi
Host · Challenge 2
Submit your idea Submissions close Aug 20 · 23:59 UTC
3
Challenge 3 · submissions 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.

some inspiration
  • 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.

Image
Marcos Miranda
Host · Challenge 3
Submit your idea Submissions close Aug 31 · 23:59 UTC
Open lane · 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. It is also the official catch-all: found the event after your theme's window closed? Enter here — same rubric, competing for this lane's pool.

some inspiration
  • 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?'

Image
Santiago Zuluaga
Host · Open lane — bring anything
Submit your idea Submissions close Aug 31 · 23:59 UTC