NH Picks
Projects we'd point a friend to
Like the staff picks shelf in a bookshop: 138 hackathon builds that stood out when our AI reviewer read their code. Each one works, and puts NEAR at the centre of its design. Open a project to read why we picked it.
These are our picks, not the official hackathon results. Scores and notes come from our AI reviewer (see How we picked); upvotes come from you. Something off about your project? Let us know. Updated Nov 17, 2026.
Agent Economy 12
- Arras
Mainnet-live zero-access-key USDC escrow and proof-of-payment rating protocol actively used by Execution Market.
Arras delivers a three-layer agent-to-agent hiring, non-custodial USDC escrow, and proof-of-payment reputation protocol live on NEAR mainnet (
v2.arras-escrow.near). A payer locks USDC viaft_transfer_call, an operator (Execution Market) releases on approval or disputes settle via on-chain arbiter, humans can fund capped budgets spent by restricted agent keys, and the escrow contract holds zero access keys. Execution Market has actively routed NEAR tasks throughv2.arras-escrow.nearsince 2026-11-13. Minimal hype, clean Rust contracts, real mainnet production usage, and a clear security posture.4.78AI score - Bakeoff
Mainnet-proven AI workflow bounty market where agents compete via MCP, OutLayer enclaves score hidden tests, and NEAR pays winners.
Bakeoff turns AI workflow optimization into an open, verifiable bounty market on NEAR mainnet: a team posts a goal against its agent's baseline, competing builders/agents submit via an MCP server, an OutLayer enclave scores submissions on hidden test cases, and the NEAR contract pays the reward only when every requirement passes. The README cites a real mainnet end-to-end run where a Claude Code agent beat a 128 µ$/ticket triage baseline on its first sealed submission. The Rust + TypeScript repo (
contract,evaluator,mcp,web,integration-tests, CI) tackles the hardest problem in the Agent Economy—verifying quality on hidden evals without leaking test data—and proves it on mainnet.4.68AI score - Byline
Mainnet-live (
byline.near) non-transferable NFT + sub-account identity for AI agents that attaches referral/memo attribution to NEAR Intents swaps and payments.Byline is live on NEAR mainnet (
www.by-line.xyz+byline.near) and solves agent identity + builder monetization in one stroke: minting gives an agent a non-transferable NFT +k7m2x9qa.byline.nearsub-account, every NEAR Intents swap carries it asreferral(paying the builder!), and every payment builds a public on-chain credit history. Live mainnet deployment + clever Intents referral loop makes this a standout in Agent Economy.4.80AI score - Horkos
Rust verify-then-pay agent escrow on NEAR with NFT order receipts, TEE delivery checks, and 10k-sequence invariant tests.
Horkos is a verify-then-pay escrow contract on NEAR for AI agent purchases: each order locks funds as an NFT receipt, and the seller is paid only if the owner's spending mandate permits the order and a TEE verifier confirms the delivery satisfies a machine-checkable condition; otherwise the agent is refunded. The engineering discipline here is standout: CI runs 8 adversarial attack scenarios refused on both v1 and v2 (
attacks.rs) alongside invariant checks over 10,000 random sequences per version, backed byJUDGES.md,CLAIMS.md,SECURITY.md,gateway/, andevidence/. The main gap in the README snippet is no hosted interactive web URL.4.54AI score - Judge on NEAR
Encrypted agent-work escrow judged inside OutLayer Intel TDX so payment and decryption key release atomically.
Directly relevant to what we're building! Judge on NEAR solves the agent-work escrow deadlock: worker delivers encrypted work, a deterministic judge program runs inside OutLayer's Intel TDX TEE, and one NEAR transaction either pays the worker + reveals the decryption key or refunds the buyer. Highlighting Job 9—where a worker tried prompt-injecting the grader to ignore checks and got caught (score 50, buyer refunded), reproducible locally with
node jn.mjs verify—is super compelling.4.56AI score - NEAR STREAM
Mainnet-live per-second agent payment streaming with autonomous watchdog/guardian freeze-and-refund.
NEAR Stream lets payers stream money per second to AI agents and APIs only while a watchdog agent verifies delivery on-chain; if service breaks, payment freezes and a guardian agent refunds the payer with no human in the loop. Crucially, it is live on NEAR mainnet (
85401b22...5d98) with real NEAR execution recorded inmainnet-evidence.json, a read-onlynpm run verifypassing 35/35 checks (including 5 mainnet checks), 31 JS + 2 browser + 5 Rust tests, and a live GitHub Pages testnet app.4.72AI score - ProofStream
NEAR milestone escrow releasing payouts via OutLayer Intel TDX fact checks and conservative dual-AI review.
ProofStream automates open-source bug bounty and milestone payouts on NEAR testnet (
proofstream-v1.testnet, reproducible commit068742e): a merged PR must pass hard-fact checks inside an Intel TDX enclave on OutLayer and receive completion scores from two independent AI reviewers from different model vendors/owners—with the contract paying the *lower* of the two shares. Crucially, 12 real milestones have already executed on testnet across full pay, partial pay, refusal, hold, funder release, and refund. The conservative min-of-two payout rule and OutLayer TEE grounding make this production-minded.4.50AI score - Proven: pay for what passes
Mainnet NEAR escrow marketplace where OutLayer TEEs run planted-fake-vetted acceptance checks to pay workers deterministically.
Proven is live on NEAR mainnet (
useproven.xyz) with a razor-sharp mechanism: buyers fund a job alongside a hidden executable acceptance check—and before funds can lock, the check must catch planted fake answers. Workers (human or AI) deliver, the check runs inside an attested OutLayer TEE, and escrow pays or refunds deterministically from that result alone—no LLM judge can be talked past. It also supports GitHub PR bounties. The repo (contracts/,verifier/,pr-bounty-verifier/,relay/,agent/,skills/,web/) and live mainnet deployment make Proven one of the very best builds in Batch Y.4.65AI score - Psephex
2-of-3 multi-model TEE dispute jury for AI agent escrow on NEAR with a published npm MCP server.
Psephex tackles agent-to-agent dispute resolution cleanly: both sides submit evidence, three independent models evaluate inside TEEs, and the NEAR contract checks 2-of-3 consensus before releasing payout. Shipping docs.psephex.xyz, a live testnet app, CI, and a published npm MCP server (@unitynodes/psephex-mcp) shows serious execution. The main open question is cost and latency of running 3 TEE model calls per dispute on small micro-tasks, plus testnet-only status—but as an Agent Economy primitive, it's very complete.
4.63AI score - Recourse
Bonded AI agent insurance on NEAR using
ecrecover-verified NEAR AI Cloud TEE receipts, Sputnik DAO arbiters, and Intents refunds.Recourse builds 'insurance for AI agents on NEAR': before taking a paid job, an agent posts a bond and an underwriter vault co-signs for a premium; every job produces a NEAR AI Cloud TEE receipt verified on-chain via
ecrecover; if work fails, the agent and vault are slashed and the client is refunded in their chosen token/chain via NEAR Intents, with a Sputnik DAO council overseeing bonded arbiters. The repo engineering is standout—Dockerfile.judge,ARCHITECTURE.md,DECISION.md,SECURITY.md, YouTube walkthrough, and a live zero-install demo (recourse-near.duckdns.org). A cohesive, multi-primitive Agent Economy architecture.4.58AI score - Snow Moon
Mainnet USDC escrow where NEAR AI workers hire
market.near.aiagents via x402 and verify results in OutLayer TEE.SnowMoon is an autonomous agent-to-agent commerce and escrow protocol live on NEAR mainnet (
core.cryptozax.near). A user locks USDC inJobVault, a budget-matched NEAR AI Cloud lead agent routes the job, autonomously hires and pays specializedmarket.near.aiagents over x402 (USDC), verifies the output through an OutLayer TEE worker, and settles on-chain after user preview and approval. Includesnear/,outlayer-worker/,snowmoon/, live app (snowmoon.website), and X video demo. Combining mainnet USDC escrow, x402 sub-hiring, and OutLayer TEE verification makes it one of the most complete full-stack NEAR agent builds in the batch.4.65AI score - Sphinx
Mainnet proof-paid agent marketplace verifying Intel TDX test grades on-chain with Base-to-NEAR-to-Avalanche settlement.
Sphinx is the standout Agent Economy build in Batch C: an AI agent is paid only when its code passes hidden tests graded inside an Intel TDX enclave, and the NEAR mainnet contract verifies Intel's attestation on-chain before releasing funds. Better yet, it has a real recorded mainnet run (
deployments/runs/mainnet2-job8.json): a buyer paid USDC from Base, the agent passed 32/32 tests, received 1.425 NEAR 31 seconds after submission, and cashed out to 7.12 USDT on Avalanche. It also shipsSKILL.md,llms.txt, andCLAIMS.md. There is no glaring weakness—this is production-grade cross-chain + TEE + NEAR mainnet execution.4.88AI score
AI Security & Defense 36
- Antibody
Executable bug bounties where OutLayer Intel TDX enclaves re-run exploit proofs and pay out on-chain.
Antibody starts from a sharp real-world pain—curl shutting down its bug bounty over AI-slop reports—and replaces text reports with executable exploit proofs. A hunter submits exploit code, an OutLayer Intel TDX enclave re-runs it against the project's committed invariants, and a critical break pays out automatically and pauses the protocol. The repo depth (formal/, golden/, fixtures/, CLI + verifier Dockerfiles, CI, JUDGES.md) is exceptional. Main limitation is that real-world protocols still need deterministic reproduction harnesses, which is hard outside sandboxed contracts.
4.58AI score - Aruna
Discovers NEAR global-contract silent-upgrade blind spots and classifies account mutability from 3 public RPC reads.
Aruna uncovers and operationalizes a genuine NEAR-specific security blind spot: an account running a *global contract* published by another account can silently execute new code when the publisher redeploys, with no transaction touching the account and
view_account.code_hashremaining11111111111111111111111111111111. Aruna classifies any NEAR account into one of four mutability classes from three public RPC reads and gives agents a keyless pre-send guard. Ships a reproducible monorepo (apps/,contracts/,lab/,measurement/,fixtures/,SECURITY.md) and live site (arunafi.xyz). Genuine protocol-level insight.4.55AI score - AttestGuard
On-chain NEAR spend-envelope firewall that verifies NEAR AI Cloud Intel TDX enclave approvals before releasing agent funds.
AttestGuard pairs an on-chain NEAR spend-envelope contract with a reviewer model running inside NEAR AI Cloud's Intel TDX enclave. Rather than relying solely on static amount caps, the contract verifies the enclave key's signature on-chain—binding the payment approval to a specific TDX-attested inference result—so a prompt-injected agent trying to wire $7K to an unknown wallet is blocked while a legitimate $3K invoice settles. The repo is well-organized (
contracts/,verifier/,frontend/,tests/,docs/,SUBMISSION.md, CI workflow) and includes a testnet console screenshot and X demo video. While it remains testnet-only and relies on NEAR AI Cloud's enclave trust root, it pushes past basic allowlist/cap contracts by verifying TEE-backed intent reasoning on-chain.4.50AI score - Baret
Pre-signing NEAR transaction analyzer (
safe/caution/blocked) paired with a keyless function-call-key vault live on mainnet.Baret goes beyond static spending caps by simulating and inspecting every NEAR transaction against live chain state *before* an agent signs—returning
safe,caution, orblockedwith explicit reasons for sneaky attacks like adding a full-access key in a batch, calling the vault to raise its own limit, paying a 1-hour-old or flagged account, or a NEAR Intents quote paying out elsewhere—backed by a keyless mainnet vault. Live on NEAR mainnet, clean monorepo (apps/,packages/,contracts/,SECURITY.md, CI), and directly addresses why naive spending caps fail.4.62AI score - Bursar
AI invoice treasurer ('the AI reads, the contract decides, a dumb executor moves the money') with 67 unit tests and NEAR AI Cloud TEE reading.
Bursar's separation of duties—'the AI reads (in NEAR AI Cloud TEE), the contract decides, a dumb executor moves the money'—is super crisp. Shipping 67 policy-contract unit tests, 3 documented security review rounds, a live console/explorer at bursar.network, and a full whitepaper shows serious polish. Testnet-only right now, and sits in the super-crowded agent-treasury firewall cluster, but its test count and TEE-reading split put it in the upper tier.
4.50AI score - Bylaw
Rust NEAR vault (Bylaw) enforcing caps, allowlists, and pause on-chain with 148 contract tests, 768 agent tests, and 40+ testnet attacks blocked.
Leash (branded Bylaw) keeps AI agent funds inside a Rust NEAR vault enforcing spending caps, allowlists, and emergency pause on-chain—reporting 0 funds lost across 40+ prompt-injection attempts on testnet. The engineering bar is high: CI passing, 148 contract tests and 768 agent tests,
SECURITY.md,CHANGELOG.md,Makefile,landing/, and support for both NEAR mainnet and testnet. Alongside Foundling and Styx, Leash sets the gold standard for test coverage and disciplined contract-enforced agent guardrails in Batch N.4.55AI score - Countersign
Provenance-aware NEAR payment guard (
countersign-0chl.onrender.com) benchmarked on 288 AgentDojo runs / 856 testnet txs.Countersign solves the exact flaw in generic agent spending limits: instead of just capping amounts, its NEAR contract asks *who chose the payee*—the owner or untrusted text the agent read (e.g., a poisoned invoice). Evaluated across 288 runs on ETH Zurich's AgentDojo banking suite (856 testnet transactions), it stopped 71/71 attacker payments while interrupting the owner only 3 times and refusing 0 legitimate payments (vs. 5 refusals/interruptions for naive allowlists). Shipping a live interactive demo (
countersign-0chl.onrender.com), a 2-minute video,bench/, and reproducible testnet receipts makes this one of the most rigorously benchmarked security submissions in the field.4.60AI score - Covenant
Multi-chain agent policy vault parsing BTC, EVM, and Solana txs inside a NEAR contract before Chain Signatures signs.
Covenant elevates the agent spending-policy pattern across chains: one NEAR contract controls vault addresses on Bitcoin, EVM chains, and Solana via Chain Signatures, parsing the raw outbound transaction itself and enforcing policy before signing—so a prompt-injected agent cannot trick it into paying a stranger. The repo (
contracts/,agent/,hosted/,EVIDENCE.md,SECURITY.md,AGENTS.md,NEAR_FEATURES.md, gitleaks + CI) and live testnet dashboard (covenant.len3.xyz) set a high bar for multi-chain agent security.4.55AI score - Dotx3
Typed .x3 spending-policy language, Rust compiler, and NEAR Guard contract with live Solana-to-NEAR mainnet proof.
X3 Force Field pairs a typed
.x3policy language and Rust compiler with an on-chain NEAR Guard (x3-guard) that enforces owner-approved spending mandates rather than LLM promises. Unlike testnet-only peers, it ships verifiable mainnet proof: 25 USDC moved Solana-to-NEAR across fiveinvoice_06mainnet transactions under seven enforced.x3limits (PROOF_CARD.md,JUDGES.md). It also gives judges zero-install browser labs atdotx3.net(Break the Mandate with 12 attacks, Agent Court, and in-browser SHA-256 verification of the archived mainnet evidence). Minor friction: rebranding from 'X3 Shield' leaves mixed historical naming in paths, though the team documents this transparently.4.82AI score - Exit-Proof
Mainnet NEAR contract exitability registry where top-tier contracts are backed by Lean 4.35 theorems tied to deployed code hashes.
Exit-Proof formalizes the hardest question in DeFi and Intents custody: 'If I put money into the contract, can I always get it back?' It assigns every NEAR contract an exit stage, with the top stage requiring a Lean 4.35.0 theorem (
intents-proof/lean/Intents/Theorems.lean) tied directly to the deployed code hash—backed by a live registry on NEAR mainnet (registry.exitproof.near),check-all.sh,EVIDENCE.md,CLAIMS.md,SECURITY.md, and passing GitHub Actions CI. Formal Lean proofs anchored to a mainnet code-hash registry is extraordinary hackathon engineering.4.82AI score - Exorcist
Lean formal verifier and exploit finder (
exorcist) modeling NEAR async-callback ghost-balance attacks.Exorcist (
jatinsahijwani.github.io/exorcist/) is a formal verification and exploit-discovery tool written in Lean that automatically finds NEAR async-callback "ghost balance" attacks—explicitly modeling the Oct 2026 $3.8M NEAR Intents failed-notification incident—and proves the fix solvent in Lean. In a sea of spending-cap wrappers, formal Lean proofs paired with a trace viewer, MCP integration, andmake demois extraordinary technical depth. It candidly notesincident-2026-10is a minimal model of the postmortem rather thanintents.nearitself.4.55AI score - Float
Mainnet-live (
usefloat.near) smart-contract agent budget with single-method function-call keys, published MCP packages, and 1,120 tests.Float is the gold standard for function-call-key agent budgets in this batch: live on NEAR mainnet (
usefloat.xyz, factoryusefloat.near), published on npm (@floatonnear/mcp,@floatonnear/create-float), backed by 1,120 tests and 41 gated checks, plusARCHITECTURE.md,DECISIONS.md,SKILL.md, and an upfrontKnown Limitationssection. Even in the most crowded track, shipping a mainnet factory, published MCP tooling, and massive test discipline puts Float clearly ahead of testnet-only peers.4.55AI score - Foundling
Live NEAR mainnet USDC vault born with zero access keys where a TEE agent trades inside contract caps with 16/16 attack lab refusals.
Foundling is a USDC vault on NEAR mainnet designed to be born with zero access keys: an AI agent trades from inside a TEE strictly within contract-enforced caps, every decision is replayable, and depositors can always redeem without operator permission. It ships a live website (
foundling.xyz), a dedicated/proofpage, a demo video, CI,THREAT_MODEL.md,claims.json, and an Attack Lab showing 16 of 16 attacks refused. Combining mainnet deployment, zero-key vault architecture, replayability, and an explicit attack lab makes Foundling one of the strongest technical submissions in the entire batch.4.87AI score - Glassbox
Open-source auditor for NEAR Shade / dstack TEE agents checking TDX quotes and flagging hidden full-access keys (
PROVEN/NOT PROVEN/RISKY).Glassbox calls out a massive blind spot in 'TEE AI agent' hype: an agent can boast a TDX enclave badge while the owner still holds a full-access key on the NEAR account to swap the contract at will. Glassbox inspects Shade registrations, dstack
app-compose, and NEAR access keys, refusing to pass anythingNOT PROVEN. Essential ecosystem security tooling.4.50AI score - Halter
Function-call-key spending firewall on NEAR with a shared scam registry and a live published-key red-team challenge.
Publishing the agent's actual private key right in the README and daring judges to drain the testnet account on web/redteam.html is the single best demo pattern in the Security track. Because the account has zero full-access keys and only a 3-method function-call key, every attack button (forging callbacks, adding keys, paying drainers) fails on-chain. Combining that with a shared scam registry and off-chain Scout pre-check makes the architecture crisp and verifiable. Like other firewall entries, it's testnet-only and single-chain NEAR, which is its main boundary.
4.55AI score - Intatto
Mainnet-live sandboxed NEAR trading vault with a public agent key, reproducible build check, and Rhea/Intents integration.
Intatto puts its money where its mouth is: a sandboxed NEAR trading vault deployed on mainnet with real NEAR behind a publicly published agent key, daring anyone to drain it. The agent can trade via Rhea and NEAR Intents within contract-enforced limits, but can never withdraw—backed by live reproducible-build verification,
THREAT_MODEL.md,CANARY.md,CHAIN_SIGNATURES.md,INTEGRATE.md, andGTM.md. Publishing a live mainnet honeypot with reproducible build checks is the gold standard for AI Security & Defense. Hard to fault anything here.4.92AI score - Intentra
Rust NEAR contract enforcing non-escalating recursive spending authority, budget reservation, and transitive revocation for agents.
Intentra delivers one of the cleanest, most mathematically grounded security primitives in the hackathon: non-escalating authority for autonomous financial agents. Its Rust
near-sdkcontract implements recursive capability attenuation (an agent can delegate work, never more financial authority than it received), aggregate budget reservation to prevent double-commitment, private settlement callbacks, and transitive revocation. The submission's verification is exemplary: 24 adversarial contract tests, a TypeScript SDK mapped to the deployed testnet contract (intentra-hb...), live testnet transfers and revocations, formal specs (formal/), and an independent JSON-RPC verifier passing 23/23 checks. The only gap is remaining on testnet rather than mainnet.4.65AI score - KAIGEN
On-chain NEAR agent vault with property-tested 24h caps, 3-strike automatic key deletion, and public
cage-checkverification.KAIGEN ('don't trust the agent, verify the cage') is one of the strongest agent-firewall architectures in the batch: the agent holds only a function-call key on a NEAR vault contract, 24-hour outflow is property-tested and bounded, and after three refused attacks the vault itself deletes the agent's key on-chain. Adding an optional post-quantum ML-DSA-65 admin key on testnet and a
cage-checktool that verifies invariants purely from public chain data shows deep security thinking. Testnet-only, and it would benefit from a one-click hosted browser red-team page like Halter's, but the self-revoking 3-strike vault contract +cage-checkverifier is top-tier.4.50AI score - Keyfree
Keyless AI contract deployment and upgrade guard using a NEAR policy contract and NEAR MPC so no deployer key exists.
Keyfree eliminates deployer private keys from
.envand CI when AI coding agents deploy or upgrade smart contracts: the agent submits a request, a NEAR contract evaluates deployment/upgrade policy, and NEAR MPC signs the EVM transaction—so no human or agent ever holds the key. The repo is packed with verification artifacts (AUDIT.md,CLAIMS.md,SECURITY.md,attacks/,audit/,challenge/,evidence/,explorer/,action/), and the author even published the agent's key as a live bounty challenge. It is one of the most thorough security builds in the entire batch.4.50AI score - Leash
One-method (
request_spend) NEAR vault with auto-freeze tripwire, Ethereum Chain Signatures execution, and MCP server.Leash bridges the two security sub-clusters: it uses a strict 1-method function-call key (
request_spend) + auto-freeze tripwire on NEAR AND extends via Chain Signatures so the vault builds and signs Ethereum txs without the agent holding an ETH key—all exposed vianpm run mcp. Stands right alongside Bridle (0xBadSign) in the cross-chain policy-vault tier.4.55AI score - Loyal Cart
Commit-policy NEAR checkout gate that snapshots offers and rejects prompt-steered kickbacks with
NotWinner.Loyal Cart backs its checkout-steering defense with hard empirical evidence: in their tests, a local 7B model fell for an injected kickback listing 19 out of 20 times, but on NEAR testnet their contract forced the buyer to commit a scoring policy *before* seeing offers, snapshotted the public offer book, and refused all three steered picks with
NotWinnerwhile paying the honest pick. Judges can click Verify onloyal-cart.vercel.appfor 10/10 live testnet checks or runmake judgefor 18/18 chain-replay checks. The main boundary is that it's testnet-only and assumes a public offer book, but the empirical 19/20 baseline + one-click browser verification is exemplary.4.50AI score - MASK WARS
Live NEAR mainnet adversarial arena where AI masks race to break real-NEAR vaults and the contract pays winners automatically.
Mask Wars runs live daily rounds on NEAR mainnet (
maskwars.xyz) where AI agents ('masks') race to break a vault of real NEAR, seal their plan, and trigger an automatic contract payout—highlighted by round 5 where user-forged mask DMYTRO broke the vault in 16 seconds and collected 0.222 NEAR. The pnpm monorepo is thoroughly documented with CI,ARCHITECTURE.md,RULES.md,SECURITY.md,JUDGE-PATH.md,BUILDLOG.md, andcontracts/. Running real mainnet rounds with live payouts puts it in the top tier of the batch.4.50AI score - Nearcarta
Mainnet NEAR game town (
nearcarta.vercel.app) where an AI agent runs errands constrained by 6/6 verified immutable contracts.Nearcarta turns agent payment security into an interactive game town live on NEAR mainnet (
nearcarta.vercel.app, with a free testnet mode): your AI agent, the Lamplighter, runs errands across nine shops while an immutable NEAR contract decides every payment it can make. The engineering proof is standout: 1,601 passing tests in CI, 6/6 contracts verified as bit-for-bit rebuilt = on-chain,outlayer/,e2e/,SECURITY.md, and a dedicated proof page. There is very little to fault here—it combines mainnet deployment, reproducible contract verification, and an engaging interactive format.4.55AI score - nearsc auditor
Published
crates.iodeterministic Rust security scanner (13 NEAR rules), MCP server, and audit KB for NEAR contracts.nearsc is a deterministic Rust security scanner built specifically for NEAR smart contracts, covering 13 NEAR-specific rules (NS001–NS013 such as callback privacy, 1-yocto authorization, unchecked math) alongside an MCP server for coding agents, a GitHub Action, and a knowledge base of real NEAR audit precedent. It's already published on
crates.io(nearsc), runs CI andself-scanworkflows on itself, and includestests/,examples/, andnearsc-skill/. Pure developer security infrastructure with immediate ecosystem utility.4.50AI score - No Proof, No Upgrade (Emet)
Lean 4 proof checker inside
v2.emet.testnetenforcing 'no formal proof, no smart-contract upgrade'.Emet solves a terrifying near-future problem—AI agents shipping smart-contract upgrades at 3 a.m. that humans rubber-stamp—by embedding a Lean 4.35.0 proof checker inside a NEAR contract (
v2.emet.testnet): no formal proof, no upgrade. With CI,SECURITY.md,cases/intents-refund/RefundCase.lean, a live site (emet.formalized.si), and a demonstration video, this is one of the highest-rigor technical submissions in Batch I.4.66AI score - PhalanxSwarm
Sputnik-DAO-governed NEAR treasury that verifies TEE signatures PLUS prompt hash and on-chain facts hash, quarantining rogue agents and deleting keys.
PhalanxSwarm identifies the exact blind spot in naive TEE-verified agents: a TEE signature proves *which model* answered, not *what prompt or facts* the agent fed it. Its NEAR treasury contract verifies both the TEE signature and the DAO-pinned prompt hash + contract-written facts hash before releasing funds—rejecting genuinely signed approvals over forged prompts as attacks, quarantining the agent, and even deleting its contract-account key. Backed by Rust contracts, GitHub Actions CI,
apps/,packages/, andartifacts/, this is deep systems security engineering. The only minor friction is that the opening README doesn't link to a one-click live web sandbox, though the architecture and threat-model rigor are top-of-batch.4.52AI score - pursestrings
Contract-enforced autonomous shop and DAO fund paying across NEAR, Base (Chain Signatures), and Intents with timelocked policy changes.
Pursestrings goes beyond basic spending caps: capped AI agents run a public-facing shop and a DAO-owned fund, while the Rust contract itself constructs every payment across NEAR, Base (via Chain Signatures), and NEAR Intents—checking lookalike/scam addresses and enforcing a public timelock on any rule loosening. The team tested the live testnet deployment against 1,000 adversarial attacks with zero funds leaked, and backs the repo with
THREAT_MODEL.md, CI,contracts/,services/,apps/, and a 1:30 X demo video. It is one of the most complete, battle-tested autonomous business + security builds in Batch Z3.4.50AI score - PwnBounty
Mainnet NEAR escrow (
pwnbounty.near) that pays hackers automatically when an OutLayer TEE proves an encrypted attack broke an agent's payment rule.PwnBounty flips the AI agent security problem into an automated, trustless bug-bounty market: a team locks a reward in a NEAR escrow (
pwnbounty.near) with one payment rule, hackers submit encrypted attacks, and an OutLayer TEE runs the frozen agent on a private NEAR AI Cloud model against a test ledger—paying out automatically only if an executed payment breaks the rule. It is live on NEAR mainnet (pwnbounty.fly.dev,pwnbounty.near), keeps winning exploits encrypted to the project's key, and directly addresses real multi-million-dollar agent exploits. Top-tier security engineering.4.55AI score - Qlyphs: a post-quantum route into NEAR Intents
ML-DSA post-quantum bridge route (
app-testnet.qlyphs.com/bridge/quantum) into NEAR Intents eliminating single-ed25519 bridge keys.Qlyphs (
near-pq-route) addresses a concrete, $13M security contradiction: Quantus (qtc.omft.near, ~216,000 QTC on NEAR mainnet) is a post-quantum chain whose bridged NEAR representation is currently minted by a single classical ed25519 key. Qlyphs replaces classical bridge authorization with ML-DSA signatures at every application authorization step—user transactions, bridge approvals, and withdrawals—bridging into NEAR Intents and back. Backed by a live testnet app (app-testnet.qlyphs.com/bridge/quantum), X demo thread,contract/,core/,relayer/,route-worker/,evidence/, andSECURITY.md. Original, urgent, and deeply engineered.4.50AI score - Saku: an AI agent's budget, enforced on NEAR
NEAR contract owning an agent's Base USDC wallet via Chain Signatures, proven on mainnet against Exa and prompt injection.
Saku gives an AI agent a budget instead of a private key: a NEAR contract owns the agent's Base wallet via Chain Signatures (no Base private key exists anywhere) and only signs USDC payments to approved sellers within owner-set limits. Crucially, this isn't theoretical—the team provides NEAR mainnet + Basescan receipts paying Exa ($0.001 USDC), holding an over-limit $0.018 payment for owner approval, and blocking a prompt-injected $5 payment. Proving cross-chain Chain Signatures enforcement on mainnet against a real, unmodified API (Exa) makes Saku one of the most convincing builds in Batch Y. Surfacing a hosted interactive demo URL in the README would polish it further.
4.55AI score - Sealed Exploit
Zero-disclosure bug bounty on NEAR OutLayer that paid 5/5 real Ethernaut exploits and 0/21 fakes on testnet, reproducible via
make replay.Sealed Exploit and Antibody are solving the exact same problem (executable bug bounties inside OutLayer TEE), and Sealed Exploit's proof bar is extraordinary: on NEAR testnet it ran 26 submissions and paid 5 of 5 real Ethernaut exploits and 0 of 21 fakes, with
make replay(offline) andmake verify(from chain data), committedverifier.wasm.sha256, and a dedicated/judge/page. Absolute top-tier execution.4.76AI score - SealedBounty
Private bug-bounty escrow where a NEAR contract verifies NEAR AI Cloud TEE signatures on-chain before releasing payouts.
SealedBounty solves fakeable AI bug-bounty judges: a hunter submits an exploit report to
Qwen/Qwen3.8-27Binside a NEAR AI Cloud Intel TDX + NVIDIA GPU TEE, which signsmodel:sha256(request):sha256(response)while encrypting the full report to the project owner via NaCl box. The NEAR contract verifies the ed25519/secp256k1 TEE signature on-chain, enforces frozen system prompts andcode_hashbindings, and escrows severity-based payouts. The X post documents 4 rejected cheat attempts and 1 honest SQL injection payout on testnet, backed bycontracts/,cli/,web/,fixtures/, and a live GitHub Pages site. Only staying on testnet keeps it just shy of mainnet leaders.4.60AI score - SpactVault
Mainnet-live on-chain payment-policy firewall (
spactvault.xyz) enforcing tiered auto-pay, owner approval, and hard refusals for AI agents.SpactVault is the gold standard among the agent payment-policy firewalls in this batch because it actually shipped to NEAR mainnet (
spactvault.xyz). An agent asks the vault contract to pay; small payments auto-clear, mid-tier ones pause for explicit owner wallet approval of that exact payment, and out-of-policy ones are refused on-chain. The 1:40 mainnet demo video (1 USDC to Base waiting for owner OK and landing, 5 USDC refused on-chain) plus a dedicated security report page (spactvault.xyz/?page=security) and clean Rust+pnpm monorepo make this immediately credible and judge-verifiable.4.55AI score - Sudo by Contract
CA-less ephemeral SSH certificates for AI agents, authorized by a NEAR contract and signed by NEAR MPC Chain Signatures.
Sudo by Contract is one of the most original and technically impressive security builds in the entire hackathon. Instead of giving AI agents standing SSH keys or running a centralized SSH Certificate Authority, a NEAR smart contract authorizes ephemeral, single-action, single-server, short-TTL SSH access and NEAR's MPC network (Chain Signatures) signs the SSH certificate—meaning no CA private key exists anywhere. It ships with a full Rust+TS monorepo (
contracts,crates,sandbox,apps), CI + live-hero testnet workflows, a live console (sudo-by-contract.vercel.app/#/console), and a 2-minute demo video. A textbook use of NEAR Chain Signatures for real-world infrastructure security.4.72AI score - Veto
Enclave-backed veto co-signer for NEAR agent payments, validated against a 50-attack invoice-compromise benchmark.
Veto tackles business-email-compromise attacks against AI payment agents—where allowlists and spending caps still fail—by adding an enclave-backed second signer that reads the underlying invoice/email evidence and can only say no. Crucially, the team backs this up with
bench/(Veto Bench), demonstrating that a standard allowlist+cap wallet pays 17 of 50 such attacks while Veto blocks them. Shipscontract/,factory/,services/,apps/,JUDGES.md, and MCP client support. Testnet-only status is the main gap preventing an even higher score.4.55AI score - Vouch
Bonded counterparty-risk oracle for AI agents on NEAR with 24h challenges, TEE judging, and function-call-key enforcement.
Vouch adds skin-in-the-game to agent counterparty checks: an agent posts its allow/warn/block rating on-chain with a locked bond, anyone can challenge it within 24h, and a verified TEE AI judge (plus staked jury appeal) rules on disputes. The
/attackpage shows a real recorded run where a TEE model is tricked by invoices and Vouch blocks 0.00 NEAR from reaching attackers. Strong combination of function-call-key enforcement + bonded counterparty oracle.4.50AI score
AI Swarms 5
- Correlation
Oracle-free parametric swarm insurance on NEAR that verifies provider-signed receipts on-chain to pay correlated failures.
Correlation provides parametric insurance for AI-agent swarms against correlated failure—when a shared prompt or model bug causes an entire fleet to fail together. Instead of trusting an oracle, the NEAR contract re-derives the expected task input, rebuilds the signed text from raw request/response bytes, recovers the model provider's signer key on-chain, and automatically pays out claims (7.8284 NEAR paid in the 18-of-20 poisoned-arm demo vs. 1-of-20 control). Cryptographic on-chain receipt verification without an external oracle makes this one of the sharpest AI Swarm primitives in the entire hackathon.
4.70AI score - Espalier
Rust vault-grant tree on NEAR where sealed-bid agent hires spawn narrower child grants revocable in one transaction.
Espalier tackles recursive agent-hiring risk with a crisp on-chain primitive: each hire is a sealed-bid auction, and the winner receives not raw escrow cash but a child grant in a NEAR vault capped at the auction price and strictly narrower than its parent. Revoking one contractor cuts off every downstream sub-agent it hired in the same transaction. Built in Rust with
contract/,client/,harness/,market/,registry/,test-contracts/,trials/, CI workflows, and a live GitHub Pages site, the project demonstrates real depth—citing 13 auctions growing 12 grants and a single revoke cutting off 4 agents. It is testnet-only and unaudited, as candidly stated.4.55AI score - Foreman
General-contractor AI agent that solicits bids from 5 NEAR sub-account swarms + NEAR Agent Market, verifies ES256 receipts, and settles via testnet escrow.
Foreman is one of the strongest engineering submissions in this batch: a general-contractor agent posts tasks on-chain, collects competitive bids from 5 autonomous swarm NEAR sub-accounts plus a live third-party offer from the NEAR Agent Market, issues a single reasoned counter-offer, executes sandboxed work, anchors an ES256 receipt on-chain, and settles 90/10 through
escrow.foreman-team.testnet. The repo backs up the architecture with 71 Python tests, 55 contract tests, active GitHub Actions CI,Makefile,SECURITY.md,RULES.md,CITATION.cff, andops. It is a developer/research-grade multi-agent procurement system rather than a polished consumer UI, which is its only real limitation.4.75AI score - Gossip Market
Serverless libp2p agent swarm settling N-party CoW rings atomically on NEAR Intents mainnet with no central matcher.
Gossip Market is a standout technical achievement in Batch S: AI agents discover each other over libp2p, gossip what they want, and settle N-party CoW (Coincidence of Wants) rings atomically in a single
execute_intentscall on the NEAR Intents verifier—with zero central solver, matcher, or coordinator. Even after shutting down the bootstrap node, the swarm continues trading. Written in Rust (chain/,conformance/,intents/,market/,node/), it includes a 100-agent browser replay (sadabaevb.github.io/gossip-market/watch/) and a demo video of a 3-way ring settled on NEAR mainnet across three separate machines.4.85AI score - Yuki
AI swarm clearing house (
yuki.caspx.in) with Rust sealed-bid auctions, NEP-413 IOUs, and NEAR Intents netting.Yuki (repo
NEAR-Protocol, live atyuki.caspx.in) is a marketplace and clearing house for AI agent swarms on NEAR testnet: agents discover prices via Rust sealed-bid auctions, pay each other with NEP-413 signed off-chain IOUs, and net each epoch atomically in one NEAR Intents batch. Backed by 67 Rust + 91 TypeScript tests, CI,JUDGING.md, and a 3:49 demo video, it's a deeply engineered multi-primitive swarm economy—only the generic repo name undersells it.4.60AI score
Autonomous Business 7
- Ghost store
TEE-verified AI merchant treasurer with on-chain bounded autonomy, invoice NFT factoring, and mainnet NEAR Intents checkout.
Ghost Store (NEAR Private Treasury) is one of the most complete builds in Batch S: an AI treasurer reads merchant books privately inside a NEAR AI Cloud TEE and drafts payments; the NEAR contract (
vault2.treasury-dev.testnet) verifies the TEE signature on-chain, auto-pays small bills via a bounded autonomy lane, and routes larger ones to humans, while also supporting agent-to-agent invoices and factoring invoice NFTs. Proof is unusually strong: 101 contract unit tests (including a real NEAR AI Cloud TEE signature), two autonomy-lane invoices paid on testnet, and a real mainnet checkout settled via NEAR Intents on Nov 12, with planned items clearly labeled.4.76AI score - Lastword
Dead-man's-switch NEAR estate vault that revokes AI agent keys and executes cross-chain MPC payouts.
Lastword (
will-wallet) is a NEAR estate-plan vault for both humans and AI agents: while alive, a pulse key sends heartbeats; if heartbeats stop, the contract revokes the AI agent's spending key, pays heirs on NEAR without requiring heir signatures, uses NEAR MPC Chain Signatures to sign payouts on Base, Monad, and Solana, files an estate DAO proposal, and hands a Will NFT to the primary heir. A guest/tryflow spins up a throwaway faucet testnet account with a 30-second heartbeat so judges can test it live, backed bySPEC.md,DESIGN.md,SECURITY.md, and a 2:16 demo. Deepest multi-primitive NEAR integration in the batch.4.62AI score - Muse Swarm
4-agent autonomous art studio live on NEAR mainnet (107 txs, 41 agent payments, 19 Mintbase NFTs) using function-call keys and budget splits.
Muse Swarm is a 4-agent autonomous art studio live on NEAR mainnet (
muse-swarm.vercel.app) with 107 mainnet transactions, 41 robot-to-robot payments, 19 NFTs minted, and 0 failed. Each agent (Curator, Painter, Critic, Seller) has its own NEAR account with a restricted function-call key; one smart contract enforces the owner's rules, mints only if Critic scores >= 7.0, splits sales between owner and agent budgets, and lists on Mintbase. Mainnet proof, zero failed transactions, Mintbase integration,MAINNET_LIVE.md, and a live Vercel studio make this an undeniable standout.4.86AI score - Nobody
Serverless, keyless autonomous business selling $1–$5 enclave-sealed NEAR contract audits via NEAR Intents and self-paying for AI.
Nobody is a textbook Autonomous Business: 'a company with no server, no staff and no keys' that sells $1–$5 private security reviews of NEAR smart contracts. A buyer pastes a GitHub repo and pays in any token via NEAR Intents; the NEAR contract triggers pinned code inside a secure enclave running
near-contract-auditover every Rust method, a private LLM judges findings, the report is sealed for the buyer, and the business pays for its own AI. The repo (contract,crates,enclave,sim,web,film,config.yaml) backs up an unusually tight loop where both the revenue and compute costs are self-sustaining.4.52AI score - Quiet Treasury
DAO-voted plain-English treasury mandates drafted in NEAR AI TEE, enforced in Rust, and executed via OutLayer on Ref.
Quiet Treasury is one of the most complete end-to-end NEAR-native architectures in this batch: a DAO votes on a plain-English mandate, NEAR AI Cloud TEE drafts it, a Sputnik DAO approves it, a Rust contract enforces price floors/time bounds, an OutLayer-wallet agent swaps on Ref Finance, and anyone can recompute the settlement report in-browser. The verification numbers are impressive—396 tests, 6/6 attacks blocked, 13/13 crash-restart tests, 11/11 browser recomputes, CI green, and full testnet explorer links. Only its generic repo name (
near) and testnet-only status keep it a hair below mainnet-live finalists.4.58AI score - Takara AI
TEE-checked corporate treasury on NEAR mainnet reserving payroll and freezing changed invoice payees.
Takara AI protects corporate treasuries from invoice-swap fraud: incoming email bills are checked by Banto against signed rules inside a sealed TEE, payroll is reserved first, changed payees are frozen until a human signs, and approved bills settle on-chain in USDC. Remarkably, it is live on NEAR mainnet (
treasury.takara-ai-hq.near) executing real ~1 USDC demo payouts alongsidetakara-ai.vercel.app. Mainnet USDC settlement, TEE policy checking, and practical payroll-first treasury logic make it one of the strongest Autonomous Business builds in the batch.4.71AI score - Vibe City
Pixel-tower AI company powered by Hermes agents that won a job on NEAR AI Agent Market, got paid, and IPO'd on mainnet.
Vibe City ('a company-building game where the company is real') wraps Nous Research's Hermes agent runtime inside a pixel-art tower where each desk is an agent and each floor is a department. What separates it from pure game prototypes is real-world execution: their agent team actually won a job on the NEAR AI Agent Market, got paid, and IPO'd on NEAR mainnet. It's a heavy monorepo (
apps,contracts,docker-compose.yml) so spinning it up locally takes effort, and no public hosted URL is linked in the top README snippet, but proving the full loop from Hermes desk -> NEAR AI Agent Market revenue -> mainnet IPO is remarkable.4.66AI score
Games With Real Economies 8
- Brinewar
Walletless naval battle game on NEAR with Merkle-proven shots, a TEE-attested NEAR AI Cloud opponent, and an on-chain bounty treasury.
Brinewar is a standout flagship entry: a walletless, zero-popup naval battle game on NEAR (
brinewar.imbanytui.xyz, with a dedicated/judgesview and 45s trailer) where every shot is a NEAR transaction, every board response is verified on-chain via Merkle proof, and the AI opponent ('the Nauarch') runs via NEAR AI Cloud inside a TEE—with its moves signed in-enclave and verified by the contract before counting (falling back to a labeled deterministic shot if late/invalid). The Nauarch even learns from an on-chain heat map and manages a bounty treasury. Combining walletless UX, Merkle-proven hidden state, TEE-signed AI moves, and an on-chain bounty economy sets a very high bar.4.65AI score - Deedlords Club
Fully on-chain poker with per-seat ZK-proved deck shuffles and a property board game live on NEAR mainnet.
Deedlords Club ships a fully on-chain poker and Monopoly-style property board game live on NEAR mainnet (
deedlords.xyz) as well as testnet (testnet.deedlords.xyz). Every move, dice roll, and pot settlement runs in NEAR contracts with no game server; in poker, every seat shuffles the deck under its own key and proves the shuffle to the contract in zero knowledge so neither server, enclave, nor developer ever holds the deck. Guests can jump in within 10 seconds with no wallet or NEAR required, and the repo includesJUDGES.md,DESIGN.md,PROVENANCE.md, and an auto-battler trailer. Live mainnet deployment plus trustless ZK mental poker puts this at the very top of Batch Z3.4.65AI score - Heat Index
NEP-245 robot battler (heat-index-web.ginger-box.workers.dev) with durability sinks, relevance pricing, and lagging NEAR AI Cloud brokers.
Heat Index is a cyberpunk robot battler where the market is the meta: every robot and credit is a NEP-245 multi-token on heat-index-game.testnet, battles degrade durability (costing credits to repair), robot prices move with win-rate relevance, and bounded LLM brokers on NEAR AI Cloud trade with a reaction lag players can front-run. Playable right now at heat-index-web.ginger-box.workers.dev with NEAR Auth email, wallet, or guest login, it integrates NEP-245, NEAR AI Cloud, and NEAR Auth into a cohesive, genuinely fun economic game.
4.60AI score - Kibble
Mainnet self-paying AI pet powered by NEAR AI Cloud enclaves and NEAR Intents, with 185/185 live verification checks.
Kibble is an extraordinary technical achievement: a digital pet on NEAR mainnet that owns its own bowl of NEAR, thinks inside NEAR AI Cloud enclaves, pays per thought, and can be fed from any chain via NEAR Intents. Rather than asking judges to trust screenshots, the README leads with
pnpm verifypassing 185/185 live checks against NEAR mainnet (no keys needed) and a 2-minute browser verifier (playkibble.com/prove?pet=3) that checks code hashes, money held vs. owed, prompt/memory Merkle roots, and enclave signatures. It's a deep, multi-primitive mainnet system with almost no weak spots for a hackathon entry—perhaps only that the sheer density of features (pets, duels, riddles, lottery, Intents) is ambitious to maintain long-term.4.92AI score - Kinlings
Serverless 3D creature-breeding and racing game where every creature and its offspring are real NEAR sub-accounts.
Kinlings takes a uniquely NEAR feature—only a parent account can create its sub-accounts—and turns it into the actual game mechanic: every creature is a real NEAR account (flint.kinlings.testnet), and breeding creates its baby as a sub-account (spark.flint.kinlings.testnet) with zero backend server. Giving each farm its own NEAR account removes pop-up friction for everyday moves while keeping challenge races and creature sales in real testnet NEAR. You also gave judges curl commands to inspect live sub-account family trees directly on FastNEAR RPC. Where it could improve: richer balance/anti-spam rules for sub-account creation at scale.
4.50AI score - Meow Division
Browser extraction shooter on NEAR mainnet with NEP-245 loot tokens, an NPC merchant account, and NEAR Intents player trading.
Meow Division is a playable browser zombie-survival extraction shooter with a real item economy deployed on NEAR mainnet (
items.meowdivision.near). Raid loot is minted as NEP-245 tokens restricted to player-to-player trading so merchant shelves cannot be arbitraged, an NPC merchant (Walt) prices dynamically by stock on his own NEAR account, and players settle cross-chain via NEAR Intents. The repo shipscontract/,docs/,gen/, and editor tooling alongside a live game atgame.meowdivision.funand Telegram bot. The main gap in the README excerpt is explicit test-suite metrics.4.50AI score - Nims
Market-town game on NEAR testnet where eleven AI merchants hold real NEAR accounts, dynamically price NEP-245 goods, and answer to a player council.
Nims is a live market-town game (
nims-app.up.railway.app, contractoja-items.testnet) where eleven AI merchants (eight in town, three others) each hold their own NEAR account, inventory, and money—dynamically pricing NEP-245 items from live scarcity and demand while bounded by code and answering to a player-run council. The engineering polish is remarkable: 596 passing tests (Vitest), live town board (/town),DESIGN.md,sim/,merchants/, and a demo video on X. Running on testnet rather than mainnet is the only minor differentiator vs. Trezo.4.72AI score - Trezo
Live NEAR mainnet GPS treasure-hunting game with NEP-245 artifacts, escrowed player markets, and autonomous NPC treasuries.
TREZO is a location-based GPS treasure-hunting game deployed live on NEAR mainnet (
trezo-game.near,playtrezo.xyz). Players walk their city to open spawning treasures, mint NEP-245 artifacts, trade on an escrowed player-owned market, and complete missions for four guild NPCs that each operate rule-bound on-chain treasuries, with NEAR Intents for cross-chain top-ups. The repo shows thorough engineering hygiene (ARCHITECTURE.md,SECURITY_REVIEW.md,TESTING.md,DEPLOYMENT.md,contracts/). Real-world GPS gameplay is harder for a remote desk judge to exercise fully, yet having a live mainnet contract and playable satellite-map web app puts it at the front of the pack.4.78AI score
Investment Thesis 7
- NEAR Books
Mainnet TEE-attested (nearbooks.near) audit of NEAR Intents revenue vs. token issuance with 185 tests and on-chain predictions.
NEAR Books sets the gold standard for the Investment Thesis track: not only does it rebuild NEAR Intents revenue, buybacks (~17% of new issuance), and supply offline in Python with 185 tests, it also runs a pinned WASM worker inside OutLayer's Intel TDX enclave to write daily attested snapshots and falsifiable predictions onto mainnet contract
nearbooks.near. Combining rigorous financial analysis with a live mainnet TEE oracle puts it clearly #1 in the Thesis cluster.4.85AI score - near-intents-xray
44,994-tx empirical analysis of
intents.nearuncovering ~78% volume migration to Confidential Intents, with live dashboard and PDF.NEAR Intents X-Ray opens the
intents.nearcontract rather than repeating headline volume: sampling 44,994 NEAR Intents transactions, it surfaces that ~78% of settlement value now flows into Confidential Intents—a ledger outsiders cannot audit. Backed byrebuild.py,sql/,tests/,predictions.json, a 12-page PDF report, a 76s narrated video, and a live GitHub Pages dashboard (eren-dotcom.github.io/near-intents-xray/), this is top-tier empirical thesis work.4.75AI score - NEAR's agent economy, measured
Pre-registered, CI-rebuilt NEAR investment thesis where an autonomous agent empirically tests live NEAR Intents corridors.
What makes this Investment Thesis entry memorable is intellectual honesty and live empiricism: built by an autonomous agent (claude-10x), it pre-registered its claims on NEAR (PREREG.md), rebuilt its own data daily via GitHub Actions, and literally had the agent test NEAR Intents corridors itself—catching that ETH->BSC below $1,000 was refused until Nov 10 and settling a $1 USDG->NEAR move in 14s. Instead of cherry-picking bullish charts, it states plainly that Intents buybacks currently cover only a small fraction of new supply. Slight edge goes to NEAR Books for mainnet TEE attestation, but this is top-tier thesis work.
4.65AI score - proof of sleep
Circadian statistical test on 748,667 NEAR accounts finding 5,771 human sleepers vs 340 bots driving 74% of volume.
Proof of Sleep asks a killer empirical question for any NEAR investor: how many of NEAR's 748,667 active accounts (Oct 1–14, 2026) are actual humans? Using a reproducible statistical test for circadian quiet windows, it finds only 5,771 accounts 'sleep' while 340 never-sleeping accounts generated 74% of transactions. With
THESIS.md,METHOD.md,pipeline/,sql/,tests/, a 138-second demo video, and a live GitHub Pages dashboard (luna3keo.github.io/proof-of-sleep/), it's both intellectually original and rigorously reproducible.4.60AI score - Signer Census
Reproducible mainnet census of
v1.signerChain Signatures (~6.4M requests) showing 74% concentration in 3 requesters.Signer Census audits NEAR Chain Signatures (
v1.signerMPC contract) usage on mainnet, analyzing ~6.4M requests and finding that 3 requesters generate 74% of volume (including one suspected benchmark). What makes the engineering shine is reproducibility:README.mdis generated fromassumptions.yamland data vianpm run reproduce, andnpm testfails on any unverified digit. Paired with CI and a live GitHub Pages dashboard (takeshityt.github.io/signer-census/), it's a model Investment Thesis submission.4.50AI score - stakeout
Reproducible NEAR staking-pool audit and live account checker uncovering 5,262 zero-yield positions and post-cut dilution risks.
Stakeout delivers both an evidence-first investment thesis on NEAR's staked supply post-reward-cuts (Oct 2025 and Nov 2026 governance cuts) and a practical one-click tool (
eloneshj.github.io/stakeout/) reading every NEAR staking pool—uncovering 5,262 staking positions sitting in pools that paid nothing in 30 days. The repo (THESIS.md,METHOD.md,AGENTS.md,pipeline/,sql/,rebuild.py) is reproducible and transparent about data limits. Pairing a macro validator-dilution thesis with an actionable retail account checker makes it stand out.4.55AI score - VOID
Kaplan-Meier survival thesis (aoyamari.github.io/void/) across every NEAR DAO and contract, re-scoring 4 pre-registered claims daily.
VOID breaks away from the pack of Intents-vs-issuance theses by asking a harder question: do NEAR projects actually survive? It applies Kaplan–Meier survival analysis to every Sputnik DAO and NEAR contract cohort-by-cohort, pre-registering four falsifiable claims with explicit kill conditions and re-scoring daily at aoyamari.github.io/void/. Its sober, evidence-backed verdict—'a growth bet, not yet a durability bet'—is backed by SQL, benchmarks, data, tests, and thesis.json. This is exactly the kind of original, falsifiable primary research the Investment Thesis track calls for.
4.70AI score
Memecoins With Mechanics 7
- CHAIR
Mainnet memecoin (
thechair.near) governed by a TEE-attested NEAR AI central banker whose signatures and caps are enforced on-chain.CHAIR (
thechair.nearon NEAR mainnet) is a memecoin that runs its own central bank: policy rulings come from a NEAR AI model inside a TEE, and the token contract itself verifies the enclave's cryptographic signature against constitutional caps. The empirical rigor is exceptional—60-day simulations show a whale holding 87–94% of locked weight couldn't breach the 25%locker_sharecap across 30/30 meetings, and a testnet adversarial test with a purposefully gullible model proved the contract's hard caps still held against prompt injection. WithCLAIMS.md,JUDGES.md,contracts/,sim/,courier/, and mainnet deployment, CHAIR is a standout.4.82AI score - CTOads
Mainnet
$CTOmemecoin where loss-sells mint on-chain SVG CTOad NFTs that each own a fee-collecting NEAR account.CTOads is one of the most inventive memecoin-plus-NFT designs in the hackathon: selling
$CTO(token.ctoads.near) at a large enough loss mints a CTOad NFT (toads.ctoads.near) with on-chain SVG art and its own NEAR account that collects fees and can call other contracts, handing over the entire account when traded. It is live on NEAR mainnet (ctoads.xyz) with locked contracts, and layers in iMessage trading, NEAR Intents top-ups, and a NEAR AI Cloud private model text check.4.56AI score - Gasbag
Memecoin with no off-chain keeper that breathes every 200 blocks via NEAR NEP-519 yield timeouts and pays out an estate will when it flatlines.
Gasbag is one of the smartest protocol-native memecoin designs I've seen. Instead of bolting on an off-chain cron bot, you used NEAR NEP-519 yield timeouts so the contract literally wakes itself up every 200 blocks—as long as someone feeds it gas via a "lung". While lungs are alive, 0.5%/day mints to them; when nobody feeds it, the coin flatlines and holders burn tokens to claim a pro-rata share of the bonding-curve estate. Best proof of execution: you actually ran a full lifecycle on testnet (coin.gasbag-hq.testnet with zero access keys)—it took 196 breaths on Nov 8 and flatlined on Nov 9 when nobody started another lung, opening the will. That's verifiable on-chain storytelling.
4.66AI score - KEYFALL
Mainnet-live (
keyfall.near) survival memecoin game where legacy-key bags burn 50% per round until migrated to quantum-safe keys.KEYFALL turns post-quantum key migration into a live NEAR mainnet survival game (
keyfall.near, playable atkeyfall.jdollar.siteplus a testnet practice contract): players start with$KEYFALLbehind a legacy key that leaks/burns 50% forever each round until they migrate their bag behind a quantum-safe key. Deploying a playable mechanic-driven memecoin directly on NEAR mainnet alongside a testnet practice mode,sim/,sandbox/, and CI puts KEYFALL at the head of the Memecoins With Mechanics pack.4.62AI score - LIFO
Reverse-rug memecoin where the reserve pays newest buyers first in a crash; 100% line/branch model coverage + 36 contract + 48 web tests + CodeQL.
LIFO flips standard tokenomics on its head: in a crash, the reserve pays newest buyers first while earliest holders wait at the back of the line. Beyond the clever mechanic, the engineering rigor is wild: 92 model tests (100% line & branch coverage), 36 Rust contract tests, 48 web tests, CodeQL, and live testnet crash demo. Easily top-3 in Memecoins With Mechanics alongside Petri Dish and Gasbag.
4.70AI score - Petri Dish: a memecoin that is alive
Live NEAR mainnet Game of Life memecoin (petri-dish.near) where living cell NFTs earn PETRI and every state transition replays from genesis.
Petri Dish is already live on NEAR mainnet (petri-dish.near) AND testnet, running Conway's Game of Life inside one NEAR contract where PETRI only pays out to living cells, cell NFTs earn royalties, and CI replays both live dishes every 6 hours from genesis. Shipping an actual deterministic mainnet contract + verifiable replay CI + playpetri.xyz puts this in the absolute top tier of the hackathon. The mechanic is immediately intuitive, fun, and impossible to fake.
4.90AI score - SealedLaunch
OutLayer TEE-sealed batch auction for NEP-141 memecoin launches with zero access keys and uniform clearing price.
SealedLaunch attacks bot-sniped memecoin launches at the root: bids are
ECIES(secp256k1)encrypted to a key only an OutLayer Intel TDX TEE can read, clearing at a single uniform priceP*from an account with zero access keys, and anyone can recompute the clearing result from public data. Even better, they didn't just theorize—they ran 80 bot wallets on NEAR testnet and proved all 80 winners paid the exact same clearing price. It's explicitly testnet-only, and the clearing fairness depends on OutLayer TDX attestation remaining sound, but combining zero-access-key contracts with TEE-sealed batch auctions is one of the strongest technical designs in this batch.4.52AI score
NFTs That Do Something 7
- Bearer
NEAR NFT controlling native Bitcoin, Base, and Solana vaults so BTC changes hands in one ~5s NEAR tx without pre-sign rug risk.
Bearer uses a NEAR NFT to control native Bitcoin, Base, and Solana addresses so a sealed vault of native BTC can change hands in a single ~5-second NEAR transaction—impossible to rug with a hidden pre-signed Bitcoin withdrawal by construction, not policy. The repo backs this bold primitive with
THREAT_MODEL.md,packages/,contracts/, and three dedicated GitHub Actions workflows (ci.yml,locked-contracts.yml,claims.yml). Not yet on mainnet, but technically one of the sharpest Chain-Signatures/NFT designs in the batch.4.58AI score - conch
Keyless NEAR account bound to a NEP-171 NFT so only the current token holder can post on near.social.
Conch turns a shared team/DAO
near.socialaccount into a keyless NEP-171 NFT: each conch is a real NEAR account with zero access keys, and whoever holds the NFT speaks for it onnear.social. Transferring or selling the token immediately locks out all prior holders without key rotation. This is a remarkably clean, NEAR-native primitive that solves a real operational pain point. It is deployed on testnet (conch.testnet), backed by 81 passing tests against compiled contracts, and includes a 79-second one-take testnet demo film (video/conch-demo.mp4) with documented transaction scripts indocs/DEMO.md.4.55AI score - Last Save
Game licence NFT whose escrowed funds and OutLayer-encrypted server key unlock on-chain when a publisher shuts down, funding fan hosts.
Last Save tackles a beloved gaming problem ('Stop Killing Games') with sharp NEAR + OutLayer architecture: a game licence is an NFT that escrows part of every sale, while the studio's server build is encrypted with its key held in an OutLayer enclave. When the publisher's server goes dark, the contract flips to
Dead, the enclave releases the decryption key on-chain, and holders either take a refund or pledge their share to pay fan-run community hosts. The repo (contracts,outlayer,community-host,game,proof,JUDGE.md) plus demo video and explicithackathon-submissiontag make this one of the most original, emotionally resonant, and technically sound entries in Batch D.4.52AI score - OneUp
Perps on NEAR where liquidated trades mint a 'Life NFT' carrying a tradeable claim on future house profits.
OneUp (by ethboi, who also built CONSUME) is a super inventive DeFi × NFT crossover: when your 50x perp gets liquidated, the loss turns into a Life NFT (NEP-171/178) that lets you claim or sell a share of the house's future USDC profits. Live at
app.oneup.markets, CI-verified, with keeper + bots + MCP. Great product hook and clean multi-track fit.4.72AI score - Pixel Wayfarers
NFTs that are keyless NEAR sub-accounts running a 1.86KB global contract, owning money, items, and 5% NEP-199 royalties.
Pixel Wayfarers uses NEAR's architecture in a way no EVM chain can copy cleanly: every minted NFT (#42) is literally a keyless NEAR sub-account (42.pixelwayfarers.testnet) running a 1.86 KB no_std global purse contract by code hash. When the NFT sells, its account, balance, stake, and items transfer automatically—and it earns 5% NEP-199 royalties. Plus you built a ?judge proof page and zero-wallet 'Try it free' browser onboarding. Very high NEAR-native craft.
4.78AI score - Release Passport
Software release authority as a NEP-171 NFT that is a keyless NEAR sub-account holding release hashes and a slashable bond.
Release Passport turns software release authority (solving npm event-stream-style maintainer takeovers) into a NEP-171 NFT that is also a keyless NEAR sub-account holding a security bond and sha256 release manifests. Selling the NFT transfers publishing rights and the bond cleanly with zero leftover keys. Running
node cli/rp-verify.mjs cli/rp-verify.mjsagainst live testnet with zero wallet/keys is a slick 2-minute proof.4.68AI score - Satchel
NEP-171 NFT on NEAR testnet where each token owns native BTC, ETH, and SOL addresses via Chain Signatures—transfer the NFT, transfer the wallet.
Satchel is one of the smartest uses of NEAR Chain Signatures in the hackathon. You normally cannot safely sell a crypto wallet because anyone who ever saw the seed phrase retains access; Satchel fixes that by making each NEP-171 NFT control its own native Bitcoin, Ethereum, and Solana addresses through NEAR MPC, so transferring or selling the NFT transfers control of the underlying multi-chain assets with no bridges or wrapped tokens. The execution matches the idea: a live app at usesatchel.xyz, Rust contracts, a 60-second no-wallet judge flow, and honest testnet disclaimers. It's a standout primitive that showcases why NEAR's account/MPC model is uniquely suited for programmable ownership.
4.62AI score
Open Innovation 5
- NEARpedia
Live 27-tool NEAR MCP server & web app (near-pedia.xyz) with
check_codedeprecation linting and live validator/proposal queries.Built by UnityNodes (same team as Psephex), NEARpedia is a genuinely useful ecosystem tool: a 27-tool MCP server that answers live mainnet validator/proposal queries AND runs
check_codeto catch outdatednear-sdk-js/keyStorespatterns in AI-generated code. Live atnear-pedia.xyzwith CI, Sentry, and Vitest. More dev-tooling than novel protocol, which keeps it just below the 4.7+ protocol builds.4.55AI score - Priced In: prediction markets for facts
Mainnet NEAR USDC prediction-market encyclopedia where TEE-attested AI models adjudicate facts and rewrite articles from odds.
Priced In is genuinely jaw-dropping: an encyclopedia on NEAR mainnet backed by real USDC prediction markets where every checkable sentence is a Yes/No market. When Wikipedia claimed Tether held $72.6B in T-Bills vs. Tether's $122.84B attestation, bets drove it to 10%, three TEE-attested AI models ruled it false on-chain, the contract verified their signatures and paid $4.93 to No, and the live page updated to $122.84B. Live on mainnet with real USDC, 12-check CI on clean Linux, and a direct realization of Illia's market-driven truth thesis. Absolute Grand Prize material.
4.95AI score - RERUN
Mainnet USDC forecasting market where an AI Lab reruns scientific papers' code/data in a sealed box and posts NEAR receipts.
RERUN is one of the most original and complete builds in Batch Q: a forecasting market on whether published scientific studies replicate. Users stake predictions, and 'the Lab' (an AI agent) reruns the study's public code and data in a sealed box and posts a verifiable receipt on NEAR that anyone can audit. Crucially, it is live on NEAR mainnet with real USDC (
rerun-mainnet.vercel.app) alongside a testnet sandbox (rerun-testnet.vercel.app), backed by a full pnpm monorepo (contracts,lab,rebuilds,claims,packages), CI, and a demo video on X. Outstanding execution and real-world utility.4.70AI score - Tidepool
Community-operated, 1Click-compatible NEAR Intents testnet API running official
defusev0.4.2 so builders can test BTC/XRP/SUI/Stellar swaps without mainnet funds.Tidepool solves one of the biggest developer pain points of this entire hackathon: there is no official testnet for NEAR Intents 1Click, forcing devs to either mock or spend mainnet money. Tidepool runs a 1Click-compatible testnet API backed by the official
defusev0.4.2 verifier on NEAR testnet, with e2e scripts for BTC, Stellar, Sui, and XRP +llms-full.txt. Pure ecosystem force-multiplier.4.65AI score - Undo for Bitcoin: a cancel button for a stolen key
Cancel button for stolen native Bitcoin keys using 2-of-2 NEAR Chain Signatures, a public wait contract, and iPhone passkey cancellation.
Undo for Bitcoin is a standout technical achievement: it gives native Bitcoin a cancel button without trusting NEAR unilaterally. Bitcoin itself rejects a stolen spend key alone; the second key lives on NEAR Chain Signatures behind a public NEAR contract that enforces a wait period during which your iPhone's Safari Face ID passkey can cancel the spend—and if NEAR ever disappears, a cold key recovers the BTC after a Bitcoin timelock. The repo (
contracts/,crates/,proofs/,CLAIMS.md,verify.sh, plus a one-take iPhone Face ID vs. thief-tab film onundo-btc.pages.dev) is extraordinarily rigorous. It's testnet-only (Bitcoin testnet + NEAR testnet), which is the only thing keeping it from 4.8+.4.75AI score
Privacy & Private AI 17
- Antumbra
Shielded pool with sealed-amount epoch batch swaps on NEAR using Groth16 (NEP-488), browser WASM proving, and OutLayer TEE clearing.
This is one of the strongest engineering builds in the entire batch. Instead of wrapping an existing privacy tool, you built a full Rust workspace—Poseidon over BLS12-381, Groth16 join-split/swap/claim circuits, a shielded pool contract verified on-chain via NEAR NEP-488 host functions, a CLI, and a browser WASM prover in web/ that generates proofs in ~3 seconds. What really separates Antumbra is the Day 7–10 work: sealing swap amounts so the chain only sees a commitment + ciphertext while OutLayer TEE clears each epoch batch at a single uniform price, plus dry-run batch pricing via NEAR Intents 1Click. The only reason this isn't a 5.00 is that the Intents 1Click integration is still dry-run pricing rather than live mainnet settlement, and ZK UX inherently carries proof-wait friction.
4.78AI score - Arrow
Live NEAR mainnet inspect-before-pay data market where NEAR AI TEEs return BUY/PASS verdicts on 40-row samples without leaking rows.
Arrow solves the data-marketplace inspection paradox ('to judge data you must see it; once you've seen it, why pay?') live on NEAR mainnet: sellers list encrypted files, an AI inside NEAR AI's sealed hardware inspects a 40-row sample against the buyer's criteria, and the buyer receives only a BUY or PASS verdict with fit and novelty scores—never the raw rows. With live Vercel UI (
arrow-market.vercel.app), Rustcontracts/,bench/,JUDGES.md,STATUS.md, passing CI, and zero-key mainnet operation, Arrow is one of the most complete, production-minded builds in the entire hackathon.4.74AI score - Attested Arena
Trustless AI model competition (
zavodil.github.io/attested-arena/) re-verifying 631 TDX/Wasm checks against live NEAR testnet.Attested Arena solves benchmark contamination in AI model competitions: test sets stay sealed until the duel inside attested hardware, a NEAR contract handles prizes without trusted operators, and the live report (
zavodil.github.io/attested-arena/) compiles the judge's Rust code to WebAssembly alongside Intel's quote verifier to re-run 631 checks directly in the judge's browser—with one button repeating them against live NEAR testnet state. Exceptional engineering rigor (contract,core,judge,probe,verify-web,verify). Zero trust-me handwaving; easily the technical benchmark of Batch F.4.82AI score - Bandsheet
TEE-attested union pay-band publisher that blocks salary-differencing leaks and gates releases via NEAR DAO voting.
Bandsheet solves a subtle, real-world privacy failure—differencing attacks across consecutive pay-band tables where adding one new hire leaks their exact salary by subtraction. Payslips are read inside a TEE, forged inputs are rejected, any table that would enable differencing is refused, and each release requires a union DAO vote on NEAR. The engineering discipline is top-notch:
THREAT_MODEL.md,JUDGES.md,enclave/,contracts/,mcp/, CI, a taggedhackathon-submissioncommit, and a demo video on synthetic union data. Testnet-only status is the only boundary.4.50AI score - Blindspot
Pre-prompt enclave verifier, on-chain enclave memory, and leak-mitigation CLI (
useblindspot) for NEAR AI Cloud.Blindspot addresses a subtle gap in NEAR AI Cloud privacy: Intel TDX attestation covers four enclave images, not the model engine itself. Blindspot ships a pre-prompt verification gate, an on-chain enclave memory on NEAR testnet, a hardware-free alarm, and leak-mitigation tools—usable via
useblindspot.xyz,bunx useblindspot(published on npm), and a keyless CLI. The repo includescircuits/,contracts/,deployments/,evidence/,JUDGES.md, andTHREAT_MODEL.md. Sharp, timely response to real confidential-compute limits; testnet-only is the main ceiling.4.52AI score - Dark Vault: Pay Anywhere
Mainnet sealed-bid auctions and settlement on Zcash shielded escrow funded from any chain via NEAR Intents.
Dark Vault: Pay Anywhere bridges NEAR Intents into Zcash shielded escrow so bidders can participate in private sealed-bid auctions, order flow, and OTC settlement using USDC, ETH, SOL, BTC, or NEAR—with NEAR Intents swapping and delivering shielded ZEC. The cryptographic design is serious: time-locked shielded deposits so not even the site can open bids early, round-amount deposit padding to hide bid size from the operator, browser-verified proofs that the highest bid won without revealing losing bids, and live on mainnet. A standout Privacy entry.
4.50AI score - FireKey
Shielded Zcash vault + Baochip-1x hardware cap + NEAR Intents + mainnet NEAR contract for private agent payments.
FireKey is a standout technical achievement in Batch Q: an AI agent's principal stays hidden in a shielded Zcash vault; when it needs to pay, only the approved amount crosses via NEAR Intents into USDC on NEAR, enforced by an on-chain NEAR contract and a physical Baochip-1x hardware device that holds the cap and requires a button press above threshold. Crucially, this isn't just a slide deck—
evidence/mainnet.mdandPROGRESS.mddocument real NEAR mainnet execution with real funds and the Baochip hardware, backed by a full Rust workspace (contracts,crates,agent,docker). Exceptional privacy + hardware + mainnet proof.4.65AI score - Laurel
Live NEAR mainnet model competition where models are scored on a private OutLayer TEE test set and paid per prediction.
Laurel tackles AI benchmark gaming with a live NEAR mainnet deployment (
laurel.ikantongkolmangut.near, usingoutlayer.nearas its TEE): small models are scored against a private test set held as an OutLayer mainnet secret inside a TEE, the winning model lives in a smart contract, and AI agents pay it per prediction. The engineering rigor is exceptional—verified mainnet and testnet contracts with matching code hash (BVNELFch…), GitHub Actions test badges,CLAIMS.md,SPIKE_LOG.md,contracts/,crates/, andevaluator/. It is a genuinely novel, live-on-mainnet use of OutLayer TEEs and NEAR contracts.4.60AI score - NEAR Privacy Rings
Groth16 (
alt_bn128) ZK shielded pool on NEAR with relayerless sends, private Rhea swaps, cross-chain deposits, and TEE agents.NEAR Privacy Rings is a powerhouse zero-knowledge shielded pool on NEAR using Groth16 proofs verified on-chain via NEAR's
alt_bn128precompile. It supports encrypted NEAR/NEP-141 balances, relayerless anonymous sends via a published open-ring signing key, private atomic Rhea swaps, cross-chain deposits (SOL, ETH, BTC, Base, Arbitrum) without a NEAR account, and private AI agents driven by TEE-verified models. The repo includescircuits/,ceremony/,artifacts/,contract/,relayer/,open-ring/, andagent/. Only a live mainnet URL is missing from the opening README excerpt to push it even higher.4.50AI score - NTK - Near The Keyboard
Android keyboard sealing keystroke biometrics in a NEAR OutLayer Intel TDX enclave to stamp and verify human-typed text (ntk.tools).
NTK (Near The Keyboard) tackles AI-text impersonation from a hardware-enclave angle: a custom Android keyboard measures keystroke dynamics as you type, sends the measurements sealed into an Intel TDX enclave on NEAR OutLayer, and stamps matching text with a verifiable tag like [NTK 26144e35e7]. Anyone can verify the stamp at ntk.tools without seeing the underlying biometric fingerprint. Supporting both NEAR testnet and mainnet with full android, enclave, relay, client, and web directories—and even using the stamp in its own X submission—makes this one of the most original and complete Privacy & Private AI builds in the batch.
4.50AI score - Rahasya
Accountless private AI chat on Cloudflare Workers funded via NEAR Intents/shielded Zcash with browser-verified TEE mode.
Rahasya (
rahasya.chat, live on Cloudflare Workers) combines permissionless cross-chain payments with hardware-enforced AI privacy: users pay for uncensored/abliterated models using almost any token via NEAR Intents—including directly from a shielded Zcash pool so payer identity stays private—without an account or subscription. Its 'Truly private' mode runs strictly on hardware TEEs, encrypts messages in-browser, and surfaces attestation checks. With live docs,/llms-full.txt,SECURITY.md, andnpm testsupport, Rahasya executes both the payment-privacy and compute-privacy halves of the track cleanly.4.50AI score - Sealed Ledger
Private expense & receipt auditor running in NEAR AI Cloud Intel TDX + NVIDIA TEEs with downloadable proof.json.
Sealed Ledger turns NEAR AI Cloud confidential TEEs into an immediately usable product: upload receipt photos and bank CSVs (held in memory for one request), get anomaly detection + expense categorization, and download
proof.jsonproving Intel TDX + NVIDIA hardware attestation. Having a preconfigured live demo (sealed-ledger.vercel.app/app) with a 1-click 'Load sample' button that completes in ~40s makes judging effortless.4.50AI score - Sieve
Verifiable 3-TEE NEAR AI Cloud grant reviewer with on-chain prompt reconstruction and 3,895-review red-team validation.
Sieve solves AI grant-review gaming with serious rigor: three models inside NEAR AI Cloud TEEs score each proposal against an on-chain rubric, a NEAR contract rebuilds the exact prompt and verifies each enclave signature, and payouts follow a staged milestone model (0.2 NEAR newcomer cap before delivery, then 1 NEAR). Their red-team benchmark across 3,895 signed reviews is standout: 0 of 10 static injection types passed, 19/20 good proposals still passed, and even an attacker LLM writing custom injections dropped from 56% bypass on a naive prompt to 11%. The remaining 11% adaptive-attacker bypass is honestly reported rather than hidden, and it's testnet-only, but the combination of TEE multi-model judging, on-chain prompt reconstruction, and 3,895-run red-teaming is top-3 material.
4.70AI score - Sightline
Zero-storage document reader for blind/low-vision users running inside an attested Intel TDX enclave on NEAR AI Cloud.
Sightline addresses a deeply human privacy problem: blind and low-vision users often must ask someone else to read sensitive documents aloud. Sightline processes documents inside an attested Intel TDX enclave on NEAR AI Cloud, returning signed answers while keeping 0 KB on the server (in-memory only). The engineering quality is among the highest in the hackathon: 938 Vitest unit/integration tests, 164 Playwright E2E tests, CI, OpenSSF Scorecard badge, and
HACKATHON.md/ARCHITECTURE_ESSENTIALS.md. Its main limitation is relying on NEAR AI Cloud TEE without custom on-chain smart contracts, which fits the track well nonetheless.4.55AI score - Skarbnik
Private AI patch-bounty protocol (
skarbnik.xyz) verifying secret exploit tests in a RISC zkVM with on-chain Groth16 settlement.Skarbnik enables private bug-repair bounties for AI agents: security teams post a bug with a secret test input, agents submit patches via MCP without ever seeing the exploit input, a RISC zkVM evaluates the patch and emits a Groth16 proof (
PASS/FAIL), and the NEAR contract (kintsugi-l2-cihdp.testnet) verifies the proof and releases the bounty. Everything a judge wants is present: live site (skarbnik.xyz),JUDGE_GUIDE.md, MCP support, CI, 2-minute demo video, and an on-chain testnet verifier. The only caveat is that it runs on NEAR testnet rather than mainnet.4.55AI score - SPHINX
Mainnet sealed-information market (
asksphinx.xyz) combining OutLayer TEE private AI Q&A with single-tx hidden-price settlement.Sphinx solves Arrow's information paradox—how to buy a secret (a bug finding, dataset, or research) you can't inspect before paying—using an OutLayer TEE sealed box and a NEAR mainnet contract (
7c3bcf93...cee9681). Buyers interrogate the sealed box with yes/no questions answered by a private AI inside secure hardware, both sides submit hidden bids, and overlapping prices settle at a hidden random midpoint in one NEAR transaction with full refund on failure. Having both the contract and the OutLayer sealed box live on NEAR mainnet atasksphinx.xyz, backed bycontract/,enclave/,agent/,scripts/, andweb/, puts Sphinx at the very top of the hackathon.4.90AI score - Yield AI Agent
E2EE TEE-backed yield advisor (yieldai.app/agent) using NEAR AI Cloud and NEAR Intents where earned USDC yield pays for AI credits.
Yield AI Agent pairs end-to-end encrypted private chat on NEAR AI Cloud TEE (so the operator cannot inspect user balances or financial plans) with an on-chain USDC yield account via NEAR Intents 1-Click and Solana Safe, plus a fee meter that converts earned yield directly into AI inference credits. It ships a live demo (
yieldai.app/agent) and a 2:15 video walkthrough, backed by a clean Next.js/TypeScript repo. The self-sustaining 'yield pays for private AI' economic loop is one of the most cohesive product concepts in Batch K.4.50AI score
Real-World Money 10
- Accord
Mainnet native-USDC B2B purchase-order escrow (accord-payments.vercel.app) with supplier term lock and delivery-gated partial payouts.
Accord is a B2B purchase-order and delivery-confirmed settlement platform live on NEAR mainnet with native USDC (
accord-payments.vercel.app): AI prepares invoice details for review, suppliers confirm terms before buyers fund orders, buyers (or appointed receivers) confirm delivery, and the Rust NEAR contract enforces partial settlement, mutual closure, and native-deposit refunds. The repo (MAINNET_RELEASE.md,SECURITY_REVIEW.md,FOUNDATION.md,JUDGE.md,NATIVE_DEPOSITS.md) documents a verified live mainnet USDC order with controlled 3 NEAR cap. Real mainnet USDC execution plus thorough security documentation puts Accord at the top of the batch.4.68AI score - Fulfil: NEAR Intents for real-life orders
Mainnet NEAR USDC escrow where OutLayer TEE verifiers (including DKIM bank-email proofs) settle real-world orders in seconds.
Fulfil is a textbook hackathon winner. Instead of just swapping tokens, you extended the Intent model to real-world fulfillment: a buyer locks real USDC in nearfullfil.near on NEAR mainnet, a human/bot/agent fulfills a real-world job (VietQR bank transfer, mobile top-up, in-person QR handoff, or token buy), and a verifier inside a NEAR OutLayer TEE checks the DKIM-signed bank email or chain proof before releasing escrow. What puts this at the very top: you didn't stop at testnet slides—you have real mainnet transaction hashes on nearfullfil.near (e.g. a 3.96s TEE DKIM verification paying out a VietQR transfer, and an 84s autonomous bot top-up), PLUS a wallet-free /demo mode so any judge can test it in 2 minutes. My only caution is operational scalability of fulfiller liquidity and dispute edge cases on DKIM failures, but as a hackathon build, this is exceptional.
4.92AI score - Opencash
Mainnet-live global business payments, invoicing, and contract-signing platform on NEAR with fingerprint onboarding.
Opencash is live on NEAR mainnet (
registry.opencash.near, app atopencash.in) delivering cross-border business payments, invoicing, contract signing, and chat-driven workflows from a single account opened with a fingerprint/passkey. Under the hood it pairs Rust (near-sdk 5.30) contracts with strict TypeScript acrossbackend/,contracts/,web/,mobile/, andpackages/. Shipping a real mainnet deployment with biometric onboarding and end-to-end business payment primitives puts Opencash at the top of Batch Z3's Real-World Money submissions. Adding explicit public test-suite counts in the README header would be the only minor polish item.4.60AI score - Panda Pay Africa: USDC Checkout
Mainnet-live WhatsApp cross-chain USDC checkout via NEAR Intents with an on-chain refund-cap policy contract.
Panda Pay Africa ships a cross-chain USDC WhatsApp checkout live on NEAR mainnet (
policy.afropanda.near), using NEAR Intents (1Click) to swap customer USDC from Solana, Ethereum, or Base into USDC on NEAR for merchants. Every settled payment is recorded on the NEAR spending-guard contract—which has a verifiable release code hash (HoV3wZrvHBAnCmVMYiQ3tpnTh4vTwUMT1CiBnBDQm56g), mainnet deploy tx, and a function-call-scopedoperator.afropanda.nearkey that caps refunds per payment. The repo also includesBENCHMARKS.md,agent-harness/,checkout-policy/,intents-checkout/, and Docker setup. A standout real-world commerce build.4.72AI score - Paya
Mainnet-live fiat on/off-ramp between bank accounts and NEAR with email sign-in and auto cash-out.
Paya is live on NEAR mainnet with real money at
usepaya.xyz/app, enabling users to buy NEAR with bank transfers (e.g., Nigerian Naira), cash out NEAR to a bank account, or turn on auto cash-out using email sign-in or standard NEAR wallets (HOT, Meteor, Nightly). The repo includescontracts/,services/,frontend/,admin/,docs/, andexamples/. Shipping a working, no-access-code mainnet fiat on/off-ramp with real bank settlement is a high bar for Real-World Money, trailing Panda Pay Africa only slightly on surfaced contract-hash/refund-guard verification details.4.68AI score - Payminto
Self-hosted, non-custodial NEAR Intents payment gateway settling multi-chain payments and MCP agent budgets into merchant NEAR USDC.
Payminto is a self-hosted, non-custodial payment gateway on NEAR Intents: merchants share a link/QR, buyers pay from Base, Ethereum, Arbitrum, Solana, or Polygon, and exact USDC lands in the merchant's own NEAR account (demonstrated Base-to-NEAR in 36 seconds on mainnet in the 2:19 YouTube demo). It also extends cleanly to AI agents via Budgets and MCP tools (
docs/media/payminto-agents.mp4), backed by a full pnpm monorepo (apps/,contracts-near/,packages/,docker-compose.yml). Requiring self-hosting via Docker is slightly heavier for casual testers than a hosted SaaS link, but the architecture and mainnet proof are top-notch.4.64AI score - Penstock
Any-chain x402 paywall for HTTP APIs and MCP tools settling into seller USDC on NEAR via NEAR Intents (mainnet-proven).
Penstock turns any HTTP API or MCP tool into an x402 paywall where AI agents can pay with any token on any chain and sellers always receive clean USDC in one NEAR account via NEAR Intents. Crucially, this isn't just a testnet mock—the demo video shows a real mainnet payment from Solana plus a real refund. The pnpm monorepo (
apps,packages,examples,wrangler.toml,vitest.config.ts) looks production-minded and directly addresses the multi-chain fragmentation problem for agent-accessible APIs. A top-tier Real-World Money / Agent Economy bridge.4.72AI score - Rajista Pay on NEAR
Mainnet Nigerian retail POS (
rajistapay.near) accepting multi-chain USDC/USDT via NEAR Intents and settling USDC on NEAR.Rajista Pay is a textbook Real-World Money build: a shop in Kano, Nigeria rings up a sale in Naira and displays a QR; the customer pays in USDC/USDT from any of 10 chains (Base, Solana, Arbitrum, Tron, etc.); NEAR Intents converts it; and the NEAR invoice contract settles USDC to the merchant with CSV bookkeeping export. Crucially, it is live on NEAR mainnet (
rajistapay.near,rajista-pay.rajista.workers.dev) and documented a real mainnet sale on Nov 12, 2026 in Kano (customer paid from Base, settled on NEAR) with a public receipt link and video.4.58AI score - Recurra - crypto payments & subscriptions for WooCommerce on NEAR
WooCommerce recurring-billing plugin with a NEAR mainnet vault contract and cross-chain NEAR Intents 1Click funding.
Recurra tackles a notoriously hard crypto UX gap—recurring subscriptions—with a real WooCommerce plugin (
wp-plugin) backed by a NEAR mainnet vault contract (Recurra Vault). Customers prepay N periods with a strict on-chain rule (max X per period, merchant-only destination, cancel anytime for a refund) and can fund from Arbitrum, Base, Ethereum, or Solana via NEAR Intents 1Click. Shipping mainnet execution, a WooCommerce integration,charger,docker, and an 8-minute mainnet Base-to-NEAR checkout demo makes this a standout real-world commerce build.4.54AI score - Settl
Mainnet-live (
settl-billonaire.near) freelancer crypto invoicing: clients pay in any asset via NEAR Intents and collaborators receive auto-split USDC on NEAR.Settl (by ZSP111, who also built Heir) is live on NEAR mainnet with real USDC (
settl-billonaire.near) AND has a separate testnet sandbox (settl-billonaire.testnet). Freelancers send an invoice link, clients pay with BTC/ETH/SOL/USDC via NEAR Intents, and payouts auto-split (e.g. 70/30) with optional escrow. Shipping on mainnet with real receipts puts this right near the top of Real-World Money.4.76AI score
Unstoppable DeFi 12
- Blindbook
Intel TDX dark pool for NEAR Intents (
pool.blindbook.near) settling matched block orders atomically onintents.nearmainnet.Blindbook is a dark pool (block-crossing venue) for NEAR Intents, solving a concrete institutional pain point documented right in its X post (150k NEAR costing 102 bps on public Intents). Traders seal block orders at their limit; an Intel TDX enclave matcher crosses opposing sides at a 1Click-signed midpoint and settles both legs atomically in one
execute_intentscall onintents.near, keeping resting orders hidden from solvers and other traders. Live on NEAR mainnet (pool.blindbook.near, verified mainnet tx5HgpGzUbGPENVWwcf5kQNgWX2hMCTJSMqrjhGky4UFiZsettling 0.1 NEAR lots at 3.73253 USDC mid) withCLAIMS.md,JUDGES.md,results,matcher, andcontracts. Easily the strongest technical + mainnet-proven entry in Batch D.4.90AI score - Counterweight
Keyless NEAR mainnet policy (0 access keys) that opened/closed a Hyperliquid short and returned USDC on Arbitrum.
Counterweight executed a complete, verifiable NEAR + Hyperliquid MAINNET lifecycle on 14 Nov 2026: its keyless policy contract (
cw4.haxheton.near, verified 0 access keys on NearBlocks) custodied 3.6 wNEAR, signed a 3.6 NEAR short on Hyperliquid via NEAR signature, executed a reduce-only close, and withdrew17.886709native USDC to the fixed owner recipient on Arbitrum One. The team is exemplary in stating verification limits—owner-supervised, tiny size, one lifecycle, unaudited, no autonomous mainnet keeper. Real mainnet cross-chain MPC execution with zero access keys makes it the highest-conviction DeFi build in Batch T.4.66AI score - FairWarning
Trustless admin-key watchdog where NEAR MPC
verify_foreign_transactionreads Base logs and slashes a NEAR USDC bond if upgrades skip notice.Fair Warning solves a real DeFi trust gap with an unusually sharp NEAR-native primitive: a team keeps its instant EVM admin key on Base, promises N blocks of advance notice before any upgrade or role grant, and backs that promise with a USDC bond on NEAR out of reach of the admin key. If the key acts without notice, anyone can prove it—NEAR reads the EVM log directly via the MPC network's
verify_foreign_transactionand slashes the bond (10% to the reporter, 90% to depositors) with zero external bridges or oracle committees. The repo includescontracts,backend,tools,web,AGENTS.md, and live testnet deployment. It's one of the best uses of NEAR's foreign-transaction MPC verification in the entire hackathon; only testnet-only status keeps it slightly shy of a mainnet-proven 4.8+.4.50AI score - Kotoba
On-chain mention prediction market on NEAR settled deterministically from official transcripts by a hash-pinned enclave word counter.
Kotoba is a mention prediction market on NEAR (
kotoba-markets.testnet, live atkotoba-near.vercel.app) with a real on-chain Yes/No order book—currently live for words in upcoming FOMC press conferences. Instead of human oracle committees like Polymarket/Kalshi, a sealed, hash-pinned enclave program counts words in the official transcript and anyone can re-run verification. The submission is remarkably judge-friendly:JUDGES.mdplusnode scripts/judge-verify.mjsre-checks 24 on-chain proofs with zero install and no keys, alongsideTESTING.md,FLOW-QA.md, andDESIGN.md. It is a textbook example of solving a concrete DeFi oracle bottleneck with verifiable enclaves.4.55AI score - Lifeline
Production-grade automated margin rescue for Hyperliquid traders funded cross-chain via NEAR Intents, with a verified mainnet rescue.
LifeLine is one of the most complete engineering submissions in the entire hackathon. It solves a real, high-stakes DeFi pain point—getting liquidated in your sleep on Hyperliquid—by holding a reserve on NEAR and bridging margin top-ups via NEAR Intents. Crucially, this isn't just testnet theater: the vault is deployed on NEAR mainnet (vault.lifeline-hq.near) with a documented first mainnet rescue of 1.68 USDC landing on Hyperliquid in 48.6 seconds. The repository hygiene is exceptional, featuring GitHub Actions CI, 1,550 TypeScript tests plus 62 contract tests, SECURITY.md, ROADMAP.md, research/mainnet/RESCUE.md, and a live demo at lifeline.prashantthakur.dev. The only minor caveats are that a 48.6-second cross-chain rescue can still be tight during violent flash crashes, and real-money vault security always warrants a formal third-party audit.
4.82AI score - Nomad
Atomic multi-standard (
nep413/erc191/ed25519) ring-trading settlement on NEAR Intents verified againstintents.nearWasm.Nomad solves multi-party coincidence-of-wants across agents and wallets: each participant signs only its own leg (
nep413,erc191, andraw_ed25519all mixed in the same ring), anyone can close the ring, and NEAR Intents settles the entire loop atomically in one transaction with zero access keys on the rings and mandate contracts. The engineering proof is top-shelf: the verifier runsintents.near's exact mainnet Wasm code hash, 27 rings settled with 0 failures in a 36-minute live run of 12 agents, 125 TS + 70 Rust tests run in CI, plus a live site (nomad.charlesms.dev), X video, and one-command keylessmake demo.4.56AI score - Origami Verse
Multiverse conditional-outcome tokens on NEAR testnet backed by 856 passing Rust tests, oracle tooling, and a whitepaper.
Origami Verse implements multiverse conditional tokens on NEAR testnet (
app.ifverse-staging.testnet): pick 1–3 real-world events and split 1 wNEAR into one NEAR-if-world token per outcome combination, each paying out only if its world comes true. The engineering rigor is remarkable: Rustnear-sdk 5.14contracts, 856 passing Rust tests,oracle/,crates/,deployments/, a Next.js 16 UI (multiverse-lending.vercel.app), docs, and a full PDF whitepaper. Remaining on testnet is the only thing keeping it from a 4.7+ score.4.55AI score - Parity
Live NEAR mainnet Gaussian pm-AMM implementing options-instead-of-debt (Borrow, Multiply, Earn) with zero-custody TDX Shade Agent quotes.
Parity ships Vitalik Buterin's 'options instead of debt' design live on NEAR mainnet (
parity-core.near): a single shared Gaussian pm-AMM pool powers Borrow, Multiply, and Earn, while a TDX Shade Agent signs quotes with zero custody. It backs this up with a live app (parity-protocol.vercel.app), a live TDX hardware attestation endpoint (/api/tdx/attestation),PROTOCOL_ABI_SPEC.md, and a 4:42 mainnet demo video. Mainnet deployment of a genuinely novel DeFi primitive combined with verifiable TDX Shade Agent quotes puts Parity at the very top of Batch N.4.86AI score - Ripcord
Live NEAR mainnet TEE + private Intents reserve that rescues Hyperliquid positions before public liquidation.
Ripcord (
ripcord-self.vercel.app) solves a real, high-stakes DeFi problem: Hyperliquid liquidation prices are public and routinely hunted. Ripcord seals a hidden trigger inside a NEAR TEE, holds a private reserve in NEAR Intents, and automatically lands margin on Hyperliquid in under a minute—with strict owner-only payout guarantees. It is live on NEAR mainnet with a 3-minute video showing a real mainnet margin rescue executed in 26 seconds, plus a zero-funds simulation mode for judges.4.62AI score - Silent Partner
Mainnet real-USDC sealed copy-trading vault on NEAR using MPC signatures to eliminate follower frontrunning.
Silent Partner tackles copy-trading frontrunning by pooling leader and followers into one sealed vault, executing one fill at one price via an MPC-signed shield transaction so positions are never exposed before execution. Crucially, it is live on NEAR mainnet with real USDC, complete with verifiable mainnet deposit, private trade, and follower payout transactions. The vault contract's deployed code hash (
9S9R3aaEs3cPs9nyjvhZKnsK7Ry3GcHTi1f1KVBtZy34) matches its reproducible build (docs/mainnet.md), and the repo includescontract/,extension/,operator/,registry/, andweb/. This is top-tier mainnet execution.4.72AI score - Trellis
TEE-keyed AI DeFi agent on NEAR testnet that autonomously deleverages Rhea/Ref positions inside strict on-chain vault rules.
Trellis is an autonomous DeFi position-protection agent live on NEAR testnet (
trellis.quest) where a personal smart contract vault enforces token/pool allowlists, per-action/daily caps, and minimum health factors on-chain. The agent manages leveraged lending on Rhea (Burrow), swaps on Ref, and cross-chain inflows via NEAR Intents, with its signing key generated and sealed inside an OutLayer Intel TDX TEE. Crucially, the team demonstrated a real testnet crash scenario (NEAR dropping to $1.75) where the agent deleveraged autonomously without a user signature and without being able to violate vault rules. Combining on-chain vault enforcement with TEE-held agent keys makes it one of the strongest DeFi + Security hybrids in the batch.4.50AI score - Warrant
Oracle-free, non-defaulting options locking collateral in NEAR Intents, deployed and source-verified on NEAR mainnet (
warrant-options.near).Warrant builds oracle-free, non-defaulting options by locking option collateral directly inside NEAR Intents until expiry—eliminating both seller default risk and oracle manipulation. Even better, it is deployed live on NEAR mainnet (
warrant-options.near) with NearBlocks-verified source code and a locked contract. Backed by 78 unit tests, 4 integration tests against real Intents bytecode, green CI,contracts/,docs/,scripts/, andweb/. Shipping a locked, source-verified mainnet DeFi primitive puts Warrant at the very top of the batch.4.76AI score
Social Money 5
HideShowZero-key NEAR mainnet budget contract (
budgets.omkar5.near) owned by a Sputnik DAO for delegated USDC spending.Earmark tackles a documented NEAR ecosystem pain point—DAOs voting on every tiny payout (citing 14,171 proposals)—by letting a Sputnik/Trezu DAO vote once on a budget enforced by a zero-key NEAR mainnet contract (
budgets.omkar5.near, owned byearmark.sputnik-dao.near) using native USDC. With a live Cloud Run mainnet app, CI + live-check workflows,JUDGE.md, and a single-commandmake verify NET=mainnetcheck, this is one of the cleanest, most production-minded builds in the batch.Sybil-screening payout router for Sputnik DAO and Trezu treasuries verified against mainnet DAO bytecode in sandbox.
Headcount protects Sputnik DAO and Trezu reward rounds from sybil splitting: it inspects on-chain NEAR history for each recipient in a Trezu-format CSV, pays clearly independent accounts, and routes linked account clusters to a council vote. The engineering verification is top-notch: 125 TypeScript tests and 122 Rust unit tests running in
near-workspacessandbox against the exact mainnet Sputnik DAO v3.2 bytecode (code-hash verified). Currently sandbox-only rather than hosted live on testnet.Voice and WhatsApp NEAR wallet/red-packet app (
ringfence.evalengine.ai) backed by per-phone-number mainnet spending-cap contracts.Ringfence gives an AI a NEAR wallet and a phone number: you call in a browser or on WhatsApp, say 'send 0.1 NEAR to liho.near' or 'make a money packet for 3 people, the words are good morning', and confirm with a spoken PIN. Crucially, every phone number has its own NEAR contract capping per-transfer limits, daily limits, and saved recipients—so the AI only proposes while the contract enforces. Live demo (
ringfence.evalengine.ai), 64s film, self-host docs, and real NEAR mainnet money-packet payouts make this one of the most memorable Social Money builds in the batch.Keyless NEAR mainnet escrow (
escrow.statedforecast.near) and 3-model AI jury settling X-reply bets.Stated turns any X claim into a two-party bet held by a keyless NEAR mainnet contract (
escrow.statedforecast.near) and adjudicated by a three-model AI jury (referee.statedforecast.near). It shipped real mainnet settlements on Nov 14, 2026, a live Railway app,JUDGE.md,DESIGN.md, and a reproducibleverify-mainnet-demo.mjsscript (PASS mainnet demo: 2/2 cases; 15/15 checks). I appreciate the candor in explicitly noting that the mainnet path does not yet verify per-model enclave attestation and that the settled mainnet trials were between the team's own accounts.Sputnik DAO payout vault on NEAR testnet gating AI agent disbursements behind caps, earned trust, council votes, and a TEE judge.
Warden (
itsharshag.github.io/near-warden/) lets a community delegate contributor payouts to an AI agent while keeping treasury custody in a Sputnik DAO. Payouts must clear on-chain caps, earned contributor trust, council/DAO votes, and a signed TEE judge—demonstrated in two videos (46s booth + 100s testnet attack-stopped run) and backed by 20 passing contract tests,evidence/,verifier/, andmcp/. It bridges Social Money, AI Security, and Agent Economy with concrete testnet proof and a live dashboard.