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
- Applicant / core developer: North Bear — full-stack + Rust, protocol and contract development.
- Github: GitHub - NOrththebear/Bees-Network · GitHub
- Email: [email protected]
- Discord: northbears
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):
- Molecule correctness — hand-rolled serializers drifted; solved by reference-encoding with
ckb-cliand byte-exact tests. - Fee/capacity edge cases — sub-minimum change must be folded, not emitted (fixed); registry appends need a minimum fee (fixed).
- Key custody — operator signing moved entirely server-side; the client never sees it (fixed in the distribution build).
- 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.
- Molecule correctness — hand-rolled serializers drifted; solved by reference-encoding with
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:
- 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.
- 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).
- 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.
- 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.
- 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.
- 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.
- 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
.msiand macOS.dmgbuilds, code signing, an auto-update feed, in-app onboarding, diagnostics, one-click claim; shipv0.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.0release, 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).
- Open-source repo at
v0.2.0(existing repo continues) — builds from a clean checkout; license present. - Economic model + budget dashboard — inflow, reserve, per-epoch budget and payouts visible; rewards never exceed reported inflow/cap.
- Verification layer — signed evidence bundles, k-of-n quorum, canary harness, diversity checks, stake/slashing, per-observation confidence.
- Signed installers for Linux, Windows, macOS + a download page — all install and launch.
- Test suite + CI —
cargo testand frontend tests pass in CI on every push. - On-chain evidence on Pudge testnet — explorer links for a registry append, an epoch close, and a share claim.
- Beta report — N≥20 testers, canary accuracy, quorum-disagreement rate, tasks completed, issues found/fixed, retention, verbatim feedback.
- Demo video + docs — architecture, run instructions, “verify in 5 minutes” guide.
- 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
- Pudge testnet — epoch close: https://pudge.explorer.nervos.org/transaction/0xb3487be3d5f8dffe9513e3d1c43b0242b650297941ccd68467837b5127e940a5
- On-chain evidence, Pudge testnet — contract deployment: https://pudge.explorer.nervos.org/transaction/0xd17ade10703f2c492e8fcf1543ed6723403a6ec2f1b14683ecf8b713bbf62c71
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-lockscript. 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.
