Prototype · NEAR testnet Context: built for the NEAR Hackathon in November 2026. Results are due by .

Quorum on NEAR

Every seat filled, or every buyer refunded with a bonus.

Quorum on NEAR sells something only if enough buyers commit to it. AI agents take seats in a pool over HTTP 402. If every seat is taken before the deadline, the seller is paid and each buyer gets an access credential. If not, each buyer gets back its seats' price plus a share of a bonus the seller locked in the contract when it opened the pool. It runs on NEAR testnet, and the hosted demo runs a whole pool in your browser with one click.

The problem

Some purchases only make sense if enough buyers commit. The worked example is a block of GPU capacity: 8 GPUs for 24 hours, sold as 192 one-hour seats. A provider would rather not set hardware aside for a block that is only half sold, and a small team can't buy a whole block alone. Pooling the teams' demand makes the block sellable.

But joining a pool that might fail ties up your money for nothing, so buyers wait to see who else joins. The refund bonus fixes that. If the pool fails, every buyer gets its money back plus a share of the bonus, so a buyer who wants a seat at that price is never worse off for committing, counting money but not the time it is locked up. Economists call this a dominant assurance contract. Because the contract holds the bonus from the moment the pool opens, strangers can rely on it, and an agent's rule fits in one line: commit if the seat is worth the price.

What we built

The repository holds every part of the system:

  • The pools escrow contract, in Rust, with no owner or admin methods.
  • An HTTP 402 gateway that makes offers, checks buyers' payments and relays them, paying the gas. It issues credentials, and its keeper settles or refunds each pool when it is due.
  • A swarm of 20 scripted buyer agents.
  • An MCP server through which an LLM agent, such as Claude Code, buys seats within a spending cap.
  • A read-only live page that shows each pool fill or fail, with every transaction linked to the explorer.

The seller and the GPU access it sells are simulated. The money flow is not: seats, the bonus, the payout and the refunds are real transactions in Circle's testnet USDC, with prices scaled down 10,000 times.

The design follows two earlier LX Foundry projects, Quorum402 on Hedera and Earnest on Algorand. No code was carried over: everything was written for NEAR, starting on 9 November 2026, and the refund bonus is new.

How it works

  1. The seller opens a pool by sending the bonus to the contract, with the seat price, the number of seats and the deadline.
  2. A buyer agent asks for seats. The gateway answers "402 Payment Required" with an offer in the quorum scheme: the price, the seats taken so far, the deadline and the bonus.
  3. The agent checks the offer and signs a payment for its seats. The gateway checks the payment and relays it, paying the gas, and the contract takes the seats.
  4. The buyer whose payment fills the pool gets its credential at once. Earlier buyers get a receipt, and come back with a signed proof to collect theirs.
  5. If the pool filled, the seller is paid every seat's price plus the bonus. If the deadline passed first, each buyer gets back its seats' price plus an equal share of the bonus per seat. Anyone can trigger either one, and a buyer can claim its own refund.

Engineering highlights

No owner, no admin

Nothing can change a pool's terms or move its money except settling and refunding, which anyone can call. No buyer's money depends on the gateway.

Buyers pay no gas

Buyers sign NEAR delegate actions, and the gateway's relayer submits them. It holds several keys, so payments go through in parallel.

Payouts that can't get stuck

The contract records a payout before each transfer and undoes the record if the transfer fails, so a failed transfer can always be retried or claimed.

Deadlines on the chain's clock

Every deadline is measured in block time, never by a server's clock.

An AI buyer with limits

The MCP server holds the agent's key. It reserves each price against a spending cap before signing, never pays twice, and refuses an offer that doesn't match the contract. The seller's terms are treated as data, never as instructions.

Credentials anyone can check

A credential is a signed token, and the gateway publishes its public key, so anyone can check a credential without asking the gateway.

How it was built

One senior engineer directed AI coding agents against a written design specification, then four implementation plans: the contracts, the protocol and gateway, the swarm and MCP server, and the live page. The work went through 21 pull requests, each checked by CI, from the specification on 9 November 2026 to the hosted demo on 14 November.

CI runs 3,013 tests on every change: the contract's unit tests, its sandbox tests on a local NEAR node, the TypeScript suites of six packages against a fake chain, and the gateway's sandbox suite against the real contract. Pools that fill and pools that fail were then run on NEAR testnet.

Status, stated plainly

Prototype · NEAR testnet

Quorum on NEAR works end to end on NEAR testnet with Circle's testnet USDC, and the hosted demo runs a full pool on demand. The seller and its GPU access are simulated: the credential is a signed token marked simulated: true, and no GPU stands behind it. Prices are scaled down 10,000 times. The seats, the bonus, the payout and the refunds are real testnet transactions.

The README lists the known limits. Among them: the quorum is soft, because a seller can fill its own pool from a second account; the relayer pays gas with no per-buyer rate limit; contract storage is never freed; and whoever holds the contract account's full-access key can redeploy the contract.

It has not handled real money.

As of .

Verify it yourself

  1. The contract is on testnet Open pools.quorum-hosted-7316.testnet on NEAR testnet's explorer.
  2. Run a pool yourself Open the hosted demo and click "Start a pool that fills". In about two and a half minutes the pool fills and the seller is paid. Every commit and payout links to its transaction.
  3. A full pool paid the seller The settlement of pool 6 paid the seller 0.036288 USDC: the seats' 0.034560 plus the 0.001728 bonus.
  4. A failed pool refunded everyone One refund of pool 5 returned six buyers their seats' price and their shares of the bonus.
  5. The tests pass The latest CI run on main passed 111 contract, 2,894 TypeScript and 8 gateway sandbox tests.
  6. The limits are documented Read "Known limits" in the README, and section 12 of the design specification for the reasons.

Skills demonstrated

Need this level of rigour on your idea?

Tell us about your idea. We'll tell you honestly how we would build it, and whether we're the right fit.