Spark Program | Bees Network — Decentralized Observation Layer for AI Agents on CKB

1. Project Overview

  • Project name: Bees Network
  • One-line summary: A desktop “bee” node that lets anyone contribute real-world observations (HTTP, DNS, TLS) to AI agents and get paid on-chain for verified work.
  • Positioning: end-user desktop application + on-chain reward protocol (a working MVP already deployed on CKB Pudge testnet).

Bees Network turns ordinary computers into a distributed observation layer for AI agents. Each node runs a small desktop app, receives observation tasks from an orchestrator, executes them, reports results, and is paid per epoch.

2. Team Profile

3. Project Background

AI agents increasingly need fresh, real-world observations. “what does this endpoint actually return”, “is this DNS record live”, “is this TLS certificate valid from where I am”. Today that work is either done by a single centralized fetcher (a single point of failure and a single point of trust) or is economically unattractive for individuals to provide.

Concretely: an agent framework wants to verify a service health check from many network vantage points. There is no simple way for a person with a spare machine to say “I will serve these observations and be paid for the ones I actually delivered”. Existing solutions are either centralized APIs or general compute marketplaces that are far too heavy for a 50 ms HTTP probe.

Relevance to CKB: the reward accounting is a natural fit for the Cell Model. Each epoch is a cell, each payout is a share cell locked by a merkle-gated lock script, and the registry is an operator-gated singleton. CKB gives us cheap, auditable, non-custodial settlement for micro-work, something a database + Stripe backend cannot do without trust.

Category reference

Grass is the strongest proof that this category is real. It is a desktop/mobile/browser-extension client that lets 8.5M+ people share unused internet bandwidth; verified institutions consume that bandwidth to reach live web data for real-world and AI applications, and contributors earn Grass Points that convert to GRASS tokens or USDC. In other words, Grass already convinced millions of ordinary users to run a lightweight background node as part of an AI data layer.

That validates the three assumptions Bees is built on: (1) people will run a small client for an AI data layer; (2) demand for fresh, real-world web observations is real and paid for; (3) a downloadable desktop node is a viable distribution channel.

Bees is deliberately adjacent, not a clone:

Grass Bees Network
Unit of work shared bandwidth / proxied traffic an explicit, typed observation task (HTTP GET/POST, DNS, TLS)
Accounting off-chain points, periodic token/USDC distribution on-chain epoch + share cells, merkle-committed each epoch
Settlement token/USDC distribution native CKB/RUSD, non-custodial, claimed from the app
Buyer institutions buying bandwidth/data access AI agents and developers buying verifiable observations
Trust model institution-gated access wallet-attested nodes, on-chain registry, per-epoch audit

Grass proves the demand and the distribution; Bees supplies the missing primitive, verifiable, individually settled observations that an agent can call directly, with the accounting itself living on.

4. Solution

Core approach. A user downloads the app, the app generates/links a wallet, and the node registers with the network. The orchestrator hands out small observation tasks; the node executes them and reports results (“beats”). A coordinator periodically closes an epoch: it reads the live tally, computes each node’s points, and mints one epoch cell plus one reward share cell per earner. The node claims its share directly from the dashboard (auto-claim is on by default).

User perspective. Download → open → start earning. No funds, no keys from us, no configuration. The dashboard shows live beats, bytes served, epoch history, and claimable CKB.

Differentiation. (1) It is an observation network, not a general compute market, tasks are tiny and latency-bound, so a laptop is enough. (2) Payouts are on-chain and auditable (epoch + share cells), not an internal ledger. (3) The desktop client holds no operator secrets; registration and epoch closing are server-side protocol roles, so a compromised client cannot mint. (4) Against Grass (the category’s benchmark), Bees is not a bandwidth resale marketplace: it sells verifiable observation results, settles every epoch natively on CKB, and needs no speculative token to pay contributors.

5. Technical Approach

  • Client: Tauri v2 + Rust, Next.js/React frontend, system keyring for wallet keys, Linux .deb/AppImage today.
  • Chain integration: Rust ckb-sdk, hand-audited molecule encoders (registry / epoch / share), secp256k1_blake160_sighash_all, data2 type scripts.
  • Contracts:
    • registry-type: operator-gated singleton; allows exactly one append per transition (Sybil/double-write protection).
    • epoch-type: mints one epoch cell per id, commits the points merkle root and rewards root.
    • rewards-lock: releases a share only to the wallet named in the epoch’s rewards ledger.
  • Services: an HTTP orchestrator (task queue, tally, /stats) and a coordinator loop that closes epochs, deployed on a hosted testnet environment; both already live.
  • Key challenges (and current solutions):
    1. Molecule correctness — hand-rolled serializers drifted; solved by reference-encoding with ckb-cli and byte-exact tests.
    2. Fee/capacity edge cases — sub-minimum change must be folded, not emitted (fixed); registry appends need a minimum fee (fixed).
    3. Key custody — operator signing moved entirely server-side; the client never sees it (fixed in the distribution build).
    4. Remaining (this grant): epoch cells are currently burn-proof (300 CKB locked per epoch), which is economically unsustainable; the coordinator is stateful/restart-fragile; rewards are funded by a bootstrap treasury; there is no quorum/canary/stake verification yet.

6. Economic Model — Where Rewards Come From

Honest starting point. In the current MVP, rewards are paid from the project’s own operator treasury on testnet. That is a bootstrap subsidy for development, not the long-term model, and we state it plainly rather than implying a working revenue engine already exists.

Sustainable source: demand-side payment. Observation results are the product. AI-agent developers and data teams pay for them, either as prepaid credits or per-call, in RUSD — a CKB-native stablecoin (sUDT) — so prices are stable for buyers and settlement still happens on CKB. We borrow x402’s HTTP 402 handshake (the buyer is quoted a price, pays, and retries with a receipt) but settle in RUSD on CKB through our own verifier. x402’s published facilitators only support EVM, Solana and similar chains, not CKB, so a real-USDC x402 rail is an optional secondary path rather than the primary one. Each payment is split:

  • 75% → provider reward pool, paid to nodes per epoch.
  • 25% → protocol/operations fee, covering orchestration, hosting and maintenance.

Why a stablecoin. Pricing in RUSD removes CKB volatility for buyers while keeping settlement on CKB. RUSD is issued by Stable++; we disclose that issuer and liquidity risk openly, and keep CKB as fallback rails if RUSD liquidity is insufficient. The beta uses testnet RUSD; the mainnet RUSD rail is confirmed at launch, and if mainnet liquidity is not ready by then we launch with the CKB fallback and switch to RUSD when available.

Replenishment and sizing. Consumers deposit into a protocol treasury cell. At each epoch the coordinator sets the reward budget from actual inflow since the last epoch, never from minting:

B_epoch = min(B_cap, inflow_since_last_epoch + reserve_draw)
payout_i = B_epoch × points_i / Σ points

with a reserve floor (keep roughly N epochs of runway), a per-epoch cap, and a dynamic reward rate: if inflow falls, rewards fall; there is no promised fixed yield. If inflow is zero, the epoch pays zero rather than inflating. This makes the pool self-funding once demand exists and makes the trade-off visible instead of hidden.

Why this can work. The unit economics are simple and disclosed in the app: a consumer price per observation, of which 75% goes to providers. Break-even is reached when paid volume covers provider rewards plus operations; below that, the treasury (or an ecosystem grant) covers a bounded deficit, and above it the reserve grows. An illustrative figure: 20,000 observations/day at 0.3 RUSD each is 6,000 RUSD/day of inflow, i.e. 4,500 RUSD/day into the provider pool (illustrative only; the dashboard reports real numbers).

Bootstrap, stated separately. During the beta, a capped treasury budget plus testnet RUSD and valueless testnet CKB funds the pilot. The $2,000 grant pays for engineering and beta operations, not the reward pool. On mainnet, the pilot reward budget comes from the project treasury and early customer prepayments, under the same inflow-based cap.

What the grant builds here. A RUSD treasury/budget module (inflow accounting, reserve floor, per-epoch cap, dynamic rate), an x402-compatible 402 Payment Required endpoint so agents can pay per observation, a public budget dashboard (inflow → epoch budget → payouts), and load tests on testnet. This turns “rewards come from somewhere” into a measurable, auditable rule.

Stake, not a token. Node stake is CKB or RUSD; no network token is required to participate. A governance token is explicitly out of scope for this grant — if one is ever introduced, it would be for staking/governance only, never as the source of reward payments, to avoid circular economics.

7. Observation Authenticity & Verification

The limitation, stated plainly. Wallet signatures, Merkle proofs and on-chain claims prove who claimed and submitted a result; they do not prove the observation was made from the claimed network location. No purely cryptographic scheme can prove physical position on the open internet. We therefore do not claim a location proof. Instead we add layered probabilistic + economic assurance, and expose the resulting confidence to buyers.

Layers added by this grant:

  1. Task binding. Each assignment carries a random nonce, target and deadline, signed by the orchestrator. Results must echo the nonce, preventing replay and pre-computation.
  2. Signed evidence bundle. The node returns, signed by its node key: nonce, timestamp, status, response/header hashes, TLS certificate fingerprint, DNS answers and timing. The coordinator checks internal consistency and plausibility (latency bounds, content-type vs. body, certificate validity).
  3. Replication + quorum. Every task is sent to k ≥ 3 independent nodes. Only quorum-agreed results (majority hash of status/body) are accepted and paid; disagreements trigger re-probing and flag the outlier. A single lying node cannot get paid alone.
  4. Hidden canaries. The orchestrator injects tasks with known ground truth (controlled endpoints, known DNS/TLS answers, expected bodies). Continuous canary accuracy per node is tracked; nodes below a threshold lose eligibility and rewards. This is the strongest practical check, because it measures whether a node reports reality rather than merely whether it signed.
  5. Diversity / Sybil resistance. Quorum members must differ in ASN, IP prefix and, where possible, geography; per-operator node caps and cluster detection prevent one operator from filling a quorum. Registration is wallet-attested and operator-gated.
  6. Stake, dispute window, slashing. Nodes stake CKB or RUSD to participate. Payouts carry a short dispute window; proven fraud (canary failure plus quorum disagreement, or a verified consumer challenge) slashes the stake. Honest nodes are unaffected.
  7. Consumer-side confidence. Each observation carries an explicit confidence score derived from quorum size, canary accuracy and diversity. Buyers can pay more for additional replicas or more diverse vantage points.

What we explicitly do not claim. We cannot stop a determined node from proxying through a VPN. The defense is redundancy, ground-truth canaries, diversity requirements and skin-in-the-game — the same trust model used by crowdsourced measurement networks such as RIPE Atlas, and by Grass, rather than an impossible cryptographic location proof. The beta report will publish canary accuracy and quorum-disagreement rates so the claim is measurable.

8. Execution Plan

8 weeks.

  • Week 1 — Protocol economics. Implement inflow accounting, reserve floor, per-epoch cap and dynamic reward rate; treasury cell handling; regression tests on a local devnet. Milestone: rewards are sized by revenue, not minted.
  • Week 2 — Service resilience. Persist orchestrator tally + coordinator state; make the epoch loop restart-safe and idempotent; add health/metrics endpoints. Milestone: restart the services without losing nodes or double-closing.
  • Week 3 — Verification I. Signed evidence bundles, replication/quorum acceptance, and the hidden-canary harness with per-node accuracy. Milestone: a single lying node cannot be paid alone.
  • Week 4 — Verification II. Diversity/Sybil checks, CKB stake + dispute window + slashing, and per-observation confidence scoring. Milestone: fraud is economically penalized, confidence is explicit.
  • Week 5 — Packaging + beta onboarding. Windows .msi and macOS .dmg builds, code signing, an auto-update feed, in-app onboarding, diagnostics, one-click claim; ship v0.2.0-beta. Milestone: signed installers + beta build.
  • Weeks 6–7 — Beta distribution & user testing. Recruit 20–30 testers; run structured test scripts (install, register, earn, claim, restart, canary challenge); privacy-preserving telemetry; publish canary-accuracy and disagreement metrics; fix top issues. Milestone: beta test report with metrics.
  • Week 8 — Close-out. Final v0.2.0 release, demo video, docs, completion report, public results post.

9. Required Funding & Breakdown

Requested: USD 2,000 — payable in CKB.

Why > $1,000 (required justification). This is not a single-category request. It combines (a) protocol-level work on on-chain contracts and coordinator economics — an actually funded reward model plus a real anti-fraud verification layer (quorum, canaries, stake/slashing) — with (b) a distribution/beta program that recruits and supports outside users. The two are coupled: the beta cannot run safely until the economics and verification exist, and neither can be validated without real users. A $1,000 budget funds roughly one of those halves, not the delivered whole.

Item Amount Use
Protocol & economics hardening (W1–W2) $600 Inflow-based budget, reserve floor, dynamic rate, epoch reclaimability, change/fee correctness, restart-safe services, tests, CI
Security, verification & anti-fraud (W3–W4) $600 Evidence bundles, quorum, canary harness, diversity/Sybil checks, stake + slashing, confidence scoring, threat model
Cross-platform packaging & signing (W5) $350 Windows/macOS builds, signing, auto-update feed, onboarding, beta build
Beta distribution & user testing (W6–W7) $350 Tester recruitment, support, telemetry, canary/disagreement metrics, feedback synthesis, fixes
Docs, demo video, completion report (W8) $80 Documentation, demo, reporting
Test infra / contingency $20 CI runners, hosted testnet, test tokens
Total $2,000

10. Deliverables + Verification

Deliverables (with acceptance criteria).

  1. Open-source repo at v0.2.0 (existing repo continues) — builds from a clean checkout; license present.
  2. Economic model + budget dashboard — inflow, reserve, per-epoch budget and payouts visible; rewards never exceed reported inflow/cap.
  3. Verification layer — signed evidence bundles, k-of-n quorum, canary harness, diversity checks, stake/slashing, per-observation confidence.
  4. Signed installers for Linux, Windows, macOS + a download page — all install and launch.
  5. Test suite + CI — cargo test and frontend tests pass in CI on every push.
  6. On-chain evidence on Pudge testnet — explorer links for a registry append, an epoch close, and a share claim.
  7. Beta report — N≥20 testers, canary accuracy, quorum-disagreement rate, tasks completed, issues found/fixed, retention, verbatim feedback.
  8. Demo video + docs — architecture, run instructions, “verify in 5 minutes” guide.
  9. Completion report — plan vs actual, fund usage, lessons.

How to verify without code review (key requirement).

  • Download an installer, run it, complete onboarding, and watch beats appear on the dashboard / /stats (compare with the live-MVP dashboard screenshot in §11).
  • Open the budget dashboard and confirm epoch payouts never exceed reported inflow/cap.
  • Read the beta report and check canary accuracy and quorum-disagreement metrics.
  • Open the provided explorer links and confirm the registry, epoch, and claim transactions on-chain.
  • Run the published test commands (or open the CI run links) and see them pass.
  • Watch the demo video.

Expected output: a running node earning testnet CKB and claimable shares, a reward budget bounded by real inflow, and published verification metrics, plus green CI and on-chain tx hashes.
Environment: any desktop Linux/Windows/macOS with internet; no node software or funds required to verify.
Verification cost: ~5 minutes per item; no committee code review needed.

11. Current State vs Funded Work

Already done (unfunded MVP).

  • Working Tauri desktop node + Next.js dashboard; Rust CKB integration.
  • Three contracts deployed on Pudge testnet; registry, epoch, and rewards-lock validated on-chain.
  • A complete reward cycle has run: epochs closed, share cells minted, and shares claimed from the app.
  • Hosted orchestrator + coordinator; multi-node registry appends; server-side registration so the client holds no operator key.
  • Public linux v0.1.0 release (.deb + .AppImage): Release Bee Network Node v0.1.0 (Linux testnet preview) · NOrththebear/Bees-Network · GitHub

The existing MVP, running live: node active and eligible, epoch 497638, 1.66K earned credits / 146 observation points, 4,106 requests served and 0.29 MB transferred.

Onchain Evidence

Funded by this Spark grant (the delta).

  • Rewards funded by a measurable inflow-based budget instead of an unbounded treasury subsidy.
  • Stablecoin-priced demand: buyers pay in RUSD on CKB through an x402-compatible 402 handshake, so the reward budget tracks real revenue.
  • A verification layer that measures whether a node reports reality: quorum, canaries, diversity, stake + slashing, per-observation confidence.
  • Epoch economics fixed so the protocol stops permanently burning CKB per epoch.
  • Restart-safe, observable services; security/abuse hardening; documented threat model.
  • Signed cross-platform installers and auto-update.
  • A real beta with 20–30 external users, measured and reported.

Not claimed. The MVP currently accepts single-node signed submissions and pays from the operator treasury; §6 and §7 describe exactly what this grant adds, and the beta report will show whether it works.

12. CKB Alignment / CKB

  • Cell Model used for real accounting: the registry is a singleton cell whose type script enforces one append per transition; each epoch is a cell carrying the points merkle root and rewards root; each payout is a cell locked by a merkle-gated rewards-lock script. This is not a token wrapper — the protocol’s state machine is cells and scripts.
  • Treasury and stake as cells: prepaid customer credits live in a treasury cell holding RUSD (an sUDT); node stakes are cells with a maturity/dispute lock; both are auditable on-chain rather than in a private database.
  • Native settlement: contributors are paid in CKB directly, with no custody and no off-chain ledger as the source of truth.
  • Auditability: every epoch, budget and claim is independently checkable on the explorer.
  • Honest scope note: AI observation tasks themselves run off-chain (they are network probes); CKB provides identity, registry, treasury, accounting, and settlement. Absolute proof of network location is not achievable and is not claimed; assurance comes from quorum, canaries, diversity and stake. Planned follow-ups include did:ckb/JoyID login so users can bring an existing CKB identity instead of a generated key.
2 Likes

hello @xingtianchunyan , can’t include links in the proposal body , how should i navigate this?

1 Like

Finally I was able to include the links in the proposal body

1 Like

I suggest you asked for 100% CKB, USDI is no longer on CKB.

2 Likes

很高兴看到你解决了问题。

2 Likes

Thanks, updated

Hello @xingtianchunyan , haven’t received any communication regarding the proposal

Hi @NOrththebear,

Thank you for your continued interest in the Spark Program and for submitting the Bees Network proposal.

After review by the Spark Program Committee, your proposal is currently Pending. This is not a rejection; rather, we invite you to revise your proposal.

The Committee has two main questions:

  1. Reward pool funding and economic model: The Committee would like to understand where the reward pool’s funding comes from. Specifically, please explain how the economic model works: who funds the rewards, how the reward pool is replenished, and what sustainable source funds incentives for observation service providers.

  2. Verifying the authenticity of observations: The Committee has concerns about the reliability of the current verification mechanism. Wallet signatures, Merkle proofs, and on-chain claim transactions can prove that a task was claimed and its results submitted, but they cannot prove that the observation was actually conducted from the claimed network location. Please explain how you ensure that observations are authentic.

Please revise and resubmit your proposal based on this feedback. We will arrange another review as soon as possible.

Best regards
xingtian
On behalf of the Spark Program Committee

2 Likes

Hi @xingtianchunyan

Thank you for the review and the clear feedback. We have revised the proposal with two new sections — §6 Economic Model (reward funding) and §7 Observation Authenticity — and resubmitted it. Short answers:

1) Who funds the rewards, and how is the pool replenished?

The testnet rewards today are bootstrapped from the project’s own operator treasury. That is a development subsidy, not the long-term model, and we say so plainly in the revised proposal.

The sustainable source is demand-side payment. AI-agent developers and data teams buy observations from the network (prepaid credits or per-call), paying in RUSD, a CKB-native stablecoin (sUDT), so prices are stable while settlement stays on CKB (testnet RUSD during beta; mainnet confirmed at launch. We use an x402-compatible 402 Payment Required handshake (quote, pay, retry with receipt) but settle in RUSD on CKB through our own verifier — x402’s published facilitators do not support CKB. Each payment is split into a provider reward pool (75%) and a protocol/operations fee (25%). The coordinator sizes each epoch’s budget from actual inflow — capped, with a reserve floor — and distributes it pro-rata to verified points. Rewards therefore come out of revenue, not inflation: there is no token sale and no fixed yield. If revenue is low, rewards scale down rather than being promised. Node stake is CKB or RUSD; no network token is required.

During the beta, a capped treasury budget plus valueless testnet CKB funds the pilot. The $2,000 grant covers engineering and beta costs, not the reward pool itself. The dashboard will publish inflow, epoch budget, and payouts so the model is auditable.

2) How do we know an observation was really made from the claimed location?

We are explicit that no scheme can cryptographically prove physical network location. Instead we add layered, probabilistic and economic assurance:

  • Replication + quorum: every task is sent to k≥3 independent nodes; only quorum-agreed results are paid.
  • Hidden canaries: tasks with known ground truth continuously measure each node’s accuracy; low-accuracy nodes lose eligibility.
  • Diversity: quorum members must differ in ASN / IP prefix / geography, with per-operator caps to resist Sybil clusters.
  • Signed evidence bundles: nonce, response/header hashes, TLS certificate fingerprint, DNS answers and timing are checked for internal consistency and plausibility.
  • Stake + slashing: nodes stake CKB, with a dispute window before payout and slashing for proven fraud.
  • Consumer-side confidence: each observation carries an explicit confidence score, and buyers can pay for more replicas or more diverse vantage points.

This mirrors how crowdsourced measurement networks (RIPE Atlas, Grass) establish trust — replication, canaries and reputation rather than a location proof — and the proposal states that limit openly rather than overclaiming.

The revised 8-week plan adds quorum verification, canaries, and staking to the scope, with accuracy and disagreement metrics published in the beta report.

1 Like

Hello, @NOrththebear,

Thank you for taking the time to revise the proposal based on our earlier feedback. The committee has completed its review and, after careful discussion, regretfully decided to reject the Bees Network proposal at this time.

We would like to be transparent about the reasons for this decision:

Outside the scope of Spark grants: In the committee’s assessment, the success of Bees Network depends heavily on bootstrapping network effects, providing ongoing incentives for node operations, and acquiring demand from AI agents. This type of project is long-term, operations-driven infrastructure and involves significant uncertainty.

We appreciate your team’s efforts on Bees Network—deploying an MVP on the Pudge testnet and clearly explaining how CKB’s Cell Model can be applied to reward accounting are both commendable. Keep building, and feel free to reach out anytime!

Best,
xingtian
On behalf of the Spark Project Committee

1 Like

Hi @NOrththebear,

Sorry to see this one rejected. The MVP and the cell-based accounting are solid work. Reading the committee’s reason (bootstrapping node supply, ongoing incentives, demand), I think there’s a natural overlap with something I’m building, and maybe a way to share the hard part instead of each of us solving it alone.

I’m working on CKB Service Runner (CSR), a side application that runs next to a fully synced CKB node and lets operators run jobs for tips. A public Network Monitor ranks runners by availability, age and network diversity (ASN, region, country). Each runner proves its node identity, and runtime registration is backed by a 10,000 CKB Nervos DAO deposit. Repo: CKB Service Runner · GitHub · Monitor: csr-monitor.chainsolution.net

Several items on your verification list map onto it:

  • Diversity / Sybil resistance (§7.5): instead of building ASN and prefix checks from scratch, Bees could select quorum members from the monitor’s ranking API. It’s already one runner per peer ID, with diversity data per node.
  • Stake (§7.6): the DAO-backed registration could be a Bees eligibility filter. To be clear, it isn’t slashable, so it’s skin in the game for entry, not a penalty mechanism. Your canary and quorum layers would still do the real policing.
  • Coordinator fragility (§5): closing an epoch is exactly the kind of timed job CSR runners are meant to execute. Running it on several runners would remove the single coordinator.
  • Supply bootstrapping: CSR operators already keep machines online 24/7 and are looking for paid work. A Bees probe module would give them a first real income source.

This could work as two tiers in your confidence model. Desktop bees give broad, cheap coverage. CSR runners give always-on, identity-proven, stake-backed vantage points that buyers pay extra for.

For CSR the win is simple: a real app with real demand, instead of a revenue layer that’s still theoretical.

Honest status: CSR is early. The mainnet runtime stays off until we have 20 diverse nodes, so anything we do now would be a testnet pilot. Concretely, that could mean (1) Bees reading the monitor API to pick quorum members, and (2) one Bees probe task type plus the epoch close running as CSR jobs on Pudge.

If that sounds interesting, I’m happy to set it up together. You can find me here or in Telegram: View @ckbrunner. Keep building!

PSBerlin

3 Likes