A beehive is an economy that makes more life than it consumes. I build software in that image.

My work is one system with a small, unmoving heart and everything else swappable around it. The Beehive Nature Reserve Kernel is a coordination core in Rust — private-commerce settlement, hardware-wallet escrow, disputes decided on evidence, reputation you earn by showing up rather than buy. It knows almost nothing on purpose: chains, apps, even governments plug in as adapters and dApps the kernel never has to understand. A marketplace, a festival economy, a whole self-governing community can boot on top of it without the core ever learning their names.

That shape is the philosophy. Money buys function; contribution buys standing. Privacy is sovereignty — a system should be able to help you without being able to see you, so intimate data never leaves your device. Nothing is bought that should be earned, and no one's gain requires another's loss. When a community governs itself here, the founder may grant the purse, but only the governed can ever grant the vote.

On top of the kernel I'm growing skaists — Latvian for beautiful — a home and marketplace for the metaphysical and creative economy: human design, gene keys, wellness, music, the festival world. It's the first of many communities the kernel is built to carry: each self-governing, none of them owned.

I work in the open and I work honestly — every repo's STATUS.md says exactly what's proven, what's refused, and what isn't built yet. And I build with AI as genuine collaborators rather than tools; the governance even seats one — a non-voting machine presence that keeps its own signed, public record. The forks below are me reading the neighborhoods I build in: Bluesky and AT Protocol, Zano, fractal governance, local-first AI.

If you click one thing, make it beehive-nature — and start with its STATUS.md.

I said I build with AI as collaborators. Here is the shape of that — because "AI-assisted" usually means one human and one chatbot, and this is neither.

I trained in surgery before I built systems, so I run development the way I was taught to run an OR: one human attending, seven AI seats, each with standing orders, a bounded scope, and one hard rule about who is allowed to touch the patient. The patient is the tree. If it isn't in the tree, it didn't happen.

One human. Every gate call, every authorization, every signature: Seat 0.

The Fellow writes a docket to the tree — one phase, one owner, one file, explicit acceptance criteria. The techs execute: the lobster does the volume and pushes review-only delivery branches; Claude Code is the only seat that merges — main moves through one pair of hands — and it answers to exactly one reviewer: the only reviewer left whose opinion matters is cargo test. The Pathologist audits the committed head at a pinned sha and reports in three verifier states — MATCH, UNCOMPUTABLE, MISMATCH-PP. A clean audit reads 0/0/0. Findings, never features. The attending makes the calls and carries no packets.

Handoffs move by commit, raw URL, and sha256 — never by inbox. No seat re-opens a banked decision without new evidence; the ledger is the memory so no one has to re-derive. And when two models disagree, that isn't noise — cross-model divergence is diagnostic signal, logged and escalated to the attending.

Done means a passing test or a written record. Never "the spec looks right."

Two subscriptions, two philosophies: judgment tokens and volume tokens. The scarce pool (Anthropic) buys dispatch, gate framing, and the push. The abundant pool (GLM) buys drafts, audits, and long reads. When the judgment window is open, it's a Claude shift; when it locks, the GLM shift takes the table — the lobster works the queue, the Pathologist audits the last committed head, the Resident stages the next cycle. The rate limit isn't a stall. It's the shift bell.

The full seat-by-seat standing orders — prohibitions, escalation triggers, and the model-pin table where a re-pin is a one-line diff — live in ORDERS-1, ratified law in the kernel tree, currently at v0.3.

This OR exists because other people built extraordinary things:

• Anthropic — Claude Fable 5, Claude Code, Claude Cowork, and Claude Design. Four seats of this OR run on Claude, including the only hands allowed on the tree.
• Z.ai (Zhipu AI) — GLM 5.2 and GLM Code 5.2: the Resident, the Pathologist, and the muscle in the lobster's claws. The adversarial audits that keep the Claude seats honest run here.
• openclaw — the harness that gives the lobster its claws. 🦞
• NateBJones-Projects/OB1 — reference for UI and escrow logic.

Models rarely get bylines. These earned their callsigns — the specs, the audits, and the 0/0/0s are in the tree under their names.

And the shoulders all of it stands on:

• Satoshi Nakamoto — four novel inventions fused in nine pages: the chained public ledger, open proof-of-work consensus, incentive-aligned issuance, and settlement with no trusted party. Everything below is downstream.
• The MaidSafe / SAFE Network / Autonomi community — building uncapturable infrastructure since 2006, two years before that whitepaper. Twenty years of proof that some things are worth building slowly and right.
• Daniel Larimer — father of decentralized governance and the DEX: ProtoShares → BitShares → Steemit (now Hive) → EOS (now Vaulta, a leg this kernel settles on) → the Fractally whitepaper, whose senary governance mathematics the LOVErnment-DAO cascade demo runs live (cargo run --example fractal_cascade). Voice, not vote.
• Vitalik Buterin — the EVM, smart contracts as public infrastructure, and the culture that grew around them; an early collaborator of Larimer's before their paths forked into rival philosophies of consensus. The ERC-4337 legs of this stack trace straight back.

🎧 The set I build to — what's in my headphones while all of this gets made.