b3nd
the framework · firecat testnet live

Build. Share. Own.

b3nd is the data-first foundation underneath apps that ship faster, stay yours, and pay you back.

One uniform surface — bend, move, save — across ten storage backends and four transports. Your data, encrypted on your key, portable between apps, worth money to the people generating it. Not the platforms hoarding it.

no spam · we tell you when the first build sprint opens, and when the network goes live for new apps

composed from open foundations
01 the shift

The internet got built on rented data. We're building one where the data is yours.

For twenty years, the deal was simple: bring your attention, bring your work, bring your audience — we'll keep the data, we'll set the rules, we'll take the margin. The scarcity wasn't in the storage or the compute. It was in the lock-in. Your followers couldn't follow you out. Your records couldn't move. Your messages lived on someone else's server. That's the moat.

b3nd dissolves it. Same internet. Same protocols. Same ads, if you want them. But the data is signed by you, encrypted to your key, replicated across stores you can pick, and addressable by content hash — not by the URL of whoever owns the door. Apps become interchangeable. Audiences become portable. The money for your attention lands in your pocket.

02 who it's for

Three people we built this for.

ai-native entrepreneurs

You're shipping a product, not a company hierarchy.

Your stack should compose the way your team does — small, fast, owned. b3nd gives you a backend that works the same across Postgres, SQLite, S3, IPFS, browser storage. Your app speaks HTTP, WebSocket, gRPC, and MCP simultaneously — humans and agents read the same surface without you forking the protocol. Deploy once to Firecat testnet and the network keeps the copy. No per-request bills. No vendor lock-in. No moat the platform owns instead of you.

  • Same Rig across in-process, HTTP, WS, gRPC, MCP
  • Ten storage backends behind one SaveClient
  • Ship to Firecat free-tier in one wrangler deploy
new devs · script kids · vibe coders

You want the web to feel direct again.

The web's heavy. Frameworks fight you. Cloud bills sneak up. b3nd is the version where you write the read, the write, the observe — and the framework wires the rest. Three verbs. One import. The CLI runs the same Rig in your terminal that runs on the network. Your first app deploys in an afternoon. If you make something people actually want, the attention marketplace can pay you while you sleep.

  • One deno install for the bnd CLI
  • Tutorials, recorded office hours, monthly build sprints
  • Open bounties — well-scoped, paid in crypto
creators · attention workers

Your audience should follow you — not the platform.

Every list, every post, every channel you make on a b3nd app belongs to you. Cryptographically. Portably. When advertisers bid for your audience's attention, the money lands in your account — no 30% house cut. If the app you're on goes weird, you move your audience to the next one and they come with you. This is the same internet you already use. Different pockets.

  • Audience is content-addressed, not platform-locked
  • Direct attention marketplace — no platform middleman
  • Encrypted on your key — the network can't read it, can't sell it
03 how it works

A foundation for data-oriented systems.

Most stacks pin you to a database, a cloud, a transport, a permission model. b3nd separates the wiring from the substrate. You declare what flows where; the Rig composes it. Ship a new user flow without rewriting infrastructure.

3.1fast deployment

New capabilities ship as wiring, not infrastructure.

Adding a feature should not require migrating a database. In b3nd, capabilities are programs (classifiers) wired to handlers (pure transforms) on a Rig. New flow = new wiring. Storage stays where it is.

// add a capability to an existing rig
rig.bend("comment://*", /* program */);
rig.on("comment://*", /* handler */);
rig.move.http(8080); // already serving
3.2security model

The server is blind on purpose.

Ed25519 identity. X25519 envelopes. RFC 8785 canonicalization. The data is signed and encrypted before it leaves the device. The network operator cannot read what it stores — so it cannot sell it, leak it, or be served a subpoena for it. Privacy is a property of the data, not a policy.

  • Ed25519 — every message carries an author signature
  • X25519 — recipient-encrypted envelopes
  • content-addressedhash://sha256/… over canonical bytes
  • no impersonation — keys verify on read, every time
3.3data operations

Ten storage backends. One contract.

EntityStore is the contract: put, get, list, delete. Memory, Postgres, SQLite, Mongo, Elasticsearch, S3, FS, IPFS, localStorage, IndexedDB — all the same surface. Multi-store writes broadcast. Reads try each in order. Swap substrates by config, not by rewrite.

const store = multi([
  indexedDb({ name: "local" }),
  httpStore({ url: "https://firecat" }),
]);
await store.put(entity); // → both
await store.get(uri);   // → first hit wins
3.4safe-and-scalable i/o

Every flow is the same shape.

receive what came in. read what's there. observe what changes. That's the entire surface. It works in-process. It works over HTTP and WebSocket. It works over gRPC for service meshes, MCP for agents. Ship a new flow: write the program, write the handler, choose the surface. The rest is already correct.

in-process http websocket grpc mcp
3.5 what it looks like

A rig. Three verbs. Ship.

Receive what came in. Read what's there. Observe what changes. The same surface in-process, over the wire, and for agents. Here's a tiny one.

define my-app/rig.ts
// b3nd-core gives you the foundation. b3nd-save the store.
// b3nd-move the surfaces (http, ws, grpc, mcp).
import { Rig }      from "@bandeira-tech/b3nd-core";
import { sqlite }   from "@bandeira-tech/b3nd-save";
import { http }     from "@bandeira-tech/b3nd-move";

const rig = new Rig({ store: sqlite("./.b3nd") });

// classify incoming messages by their URI shape ...
rig.bend("note://*", (uri, payload) => ({
  code: "note.created", payload,
}));

// ... and react. pure functions in, Output[] out.
rig.on("note.created", (msg) => [
  { code: "save", payload: msg.payload },
]);

await http(rig, { port: 8080 });
// → ready over http, ws, mcp. one rig, three doors.
consume any-client
// the surface is symmetric.
// in-process, http, ws, mcp: same three verbs.
import { httpClient } from "@bandeira-tech/b3nd-move";

const app = httpClient("https://app.example");

await app.receive([
  "note://2026/06/20/first",
  { title: "build, share, own" },
]);

const n = await app.read("note://2026/06/20/first");

for await (const n of app.observe("note://*")) {
  render(n); // live, signed, content-addressed.
}
install the cli
deno install -A -gf jsr:@bandeira-tech/b3nd-cli/bnd
or run a node image
docker run ghcr.io/bandeira-tech/b3nd/b3nd-node:latest
or ship to firecat
bnd push --to firecat
~/ws/my-app · bnd firecat · evergreen
~/ws/my-app $ bnd push --to firecat → packaging rig (sqlite store + http surface) → signing manifest ed25519 · 64b9…1c0a → uploading to firecat://evergreen → ready · 124 ms · cold start → open https://app-64b9.firecat.run bend ▸ comment://* ▸ note.created move ▸ http :443 · ws :443 · mcp :443 save ▸ broadcast → memory · sqlite · evergreen ~/ws/my-app
one command

From your laptop, to a public, paid network.

bnd push packages your rig, signs the manifest with your key, ships it to the network, and gives you a live URL. No build pipeline. No CI. No "what region should I pick." The same surface runs locally and on the wire.

built for the next interface

Agents and humans read the same surface.

The Rig speaks MCP natively. Every capability you ship to humans is already available to agents — same verbs, same shapes, same content-addressed I/O. No second protocol. No second backend. No "agent SDK" tacked on. Just three verbs over a uniform surface, every door you open opens both ways.

Deterministic verbs

receive · read · observe. Predictable enough for tools to compose, free enough for agents to invent.

Content-addressed I/O

hash://sha256/… over RFC 8785. Agents can quote, cite, and reference without forgery.

Signed by default

Every message is Ed25519-signed. Agents act on their own keys. Audit trails are free.

04 proof, not pitch

Running, today.

No whitepaper. Live testnet. Published packages. Apps you can use this afternoon.

testnet · live

Firecat — evergreen testnet

The public B3nd network. Running now. Your apps deploy here.

testnet-evergreen.fire.cat →
packages · published

JSR — @bandeira-tech

b3nd-core · b3nd-move · b3nd-save · b3nd-canon · b3nd-cli. One import each.

jsr.io/@bandeira-tech →
lighthouse app

Listorama

Lists for the things you love. Audience-portable, end-to-end encrypted, with a built-in attention marketplace that pays out to you.

soon · v0.0.1 alpha
dogfood

k3p

The capture-anything CLI. URLs, notes, snippets — saved on a personal b3nd-save store at ~/.k3p/data. We use it daily.

open soon · ~/.local/bin/k3p
05 how to get in

Builders are showing up.

We run b3nd like a community machine, not a launch event. Monthly mini-hackathons. Bi-weekly recorded training. Open bounties for well-scoped work. Office hours every week. The first round of prizes rewards the best video demo, the most useful business, the funniest meme app, and the apps shipped in the builder's own language.

Small rewards, often, in crypto, paid directly. No 30% house cut on the way out. If you're an entry-level builder — or a "new script kid" wielding AI — this is the right place to ship your first app on a real, paying network.

06 what's next

Already shipping. Here's the order.

Public motion, public dates. Every line below is a thing we're shipping, not a roadmap promise.

  1. now

    Firecat evergreen testnet · live

    Open testnet hosting B3nd nodes. Public endpoints, free-tier deploy targets, fair-use throttling.

  2. this month

    Listorama v0.0.1 alpha · public

    The lighthouse app — lists, audience, attention marketplace — opens its waitlist to the early-signal list first.

  3. first sprint

    Monthly build sprint · round 01

    One brief, one week, five prize categories. Best video demo · serious business · funniest · community choice · your language.

  4. rolling

    Bounty board opens

    Well-specified work. Small-and-often payouts in crypto. Documented in the open.

  5. later this year

    Flagship hackathons · co-located

    Tier-2 events once the community machine is running steadily. DevPost / MLH / ETHGlobal / lablab.ai tracks.

three steps

From scrolling, to shipping.

  1. 01

    Install the CLI

    One Deno install gets the bnd binary on your path. Works the same on macOS, Linux, Windows.

    deno install -A -gf jsr:@bandeira-tech/b3nd-cli/bnd
  2. 02

    Wire a rig

    Pick a store, declare a handler, choose a transport. One file. No CI, no config, no schema migrations.

    bnd init my-app && cd my-app
  3. 03

    Push to the network

    One command. Live URL. Already speaking HTTP, WebSocket, and MCP. You're on Firecat.

    bnd push --to firecat
a short note

Software has spent a decade getting more complicated to do fewer things — more dependencies, more renderers, more opaque platforms, more rented data. The interesting work has been sitting underneath, in the wiring: how data moves, where it persists, what proves it's yours.

b3nd is what falls out when you make that wiring explicit. Three verbs. One Rig. A small, uniform surface that agents can use as easily as humans. Storage that's portable. Identity that's cryptographic. A network whose economics flow to the people doing the work.

We're building it in the open. If you're a builder, a creator, or anyone tired of the moats — get on the list. We'll bring you in as the doors open.

early signal

Get on the list before the first build sprint opens.

One email. We tell you when the first sprint goes live, when new apps open to the network, and when the bounty board posts work that pays. Nothing else.

no spam · unsubscribe with a single click · your email lives on a b3nd store, what else