intro / hero
00 intro/hero #hero

b3nd — digital spellcraft. A data substrate for apps built with AI.

digital spellcraft.

01 intro/shape #shape

Capture once. Use it everywhere.

Build the backend once. Ship apps on top forever — throw them away when you want. The information underneath stays yours.

02 flow/simple #simple

Building is the easy part.

Pick a verb. Pick where it goes. The wiring is already here — what's left is the app.

receive
{} .json .jpg .mov .proto
read
doc docs search target
observe
SSE * path/** notify
show
web cli mobile agent skill
move
mcp http ws grpc
save
postgres mongodb posix sqlite
send
resend whatsapp claude openai
free
cloudflare vercel digital ocean hetzner
03 go/try #try

Try it now.

Three doors. Pick one.

install
$ npx jsr add @bandeira-tech/b3nd-core @bandeira-tech/b3nd-save @bandeira-tech/b3nd-move
import { connection, Rig } from "@bandeira-tech/b3nd-core";
import { LocalStorageStore } from "@bandeira-tech/b3nd-save/localstorage";
import { passThroughRecord, SaveClient } from "@bandeira-tech/b3nd-save/clients";
import { TYPE_TAGS } from "@bandeira-tech/b3nd-save/entity";
import { httpClient } from "@bandeira-tech/b3nd-move/http";

const notes = {
  name: "notes",
  fields: [{ name: "text", type: [TYPE_TAGS.STRING] }],
};

const save = new SaveClient(passThroughRecord, notes, new LocalStorageStore());
await save.init();

const rig = new Rig({
  routes: {
    receive: [connection(save, ["local://**"])],
    read:    [connection(save, ["local://**"])],
    send:    [connection(httpClient("https://api.example.com"), ["api://**"])],
  },
});

await rig.receive([["local://notes/hello", { text: "hi" }]]);
$ deno add jsr:@bandeira-tech/b3nd-core jsr:@bandeira-tech/b3nd-save jsr:@bandeira-tech/b3nd-move
import { connection, FunctionalClient, Rig } from "@bandeira-tech/b3nd-core";
import { MemoryStore } from "@bandeira-tech/b3nd-save/memory";
import { passThroughRecord, SaveClient } from "@bandeira-tech/b3nd-save/clients";
import { TYPE_TAGS } from "@bandeira-tech/b3nd-save/entity";
import { httpService } from "@bandeira-tech/b3nd-move/http";
import { mcpService }  from "@bandeira-tech/b3nd-move/mcp";

const messages = {
  name: "messages",
  fields: [{ name: "payload", type: [TYPE_TAGS.JSON] }],
};

const save = new SaveClient(passThroughRecord, messages, new MemoryStore());
await save.init();

const log = new FunctionalClient({
  receive: (msgs) => {
    for (const [uri, payload] of msgs) console.log("received:", uri, payload);
    return Promise.resolve(msgs.map(() => ({ accepted: true })));
  },
});

const rig = new Rig({
  routes: {
    receive: [
      connection(log,  ["**"]),
      connection(save, ["**"]),
    ],
    read: [connection(save, ["**"])],
  },
});

httpService(rig).listen({ port: 8080 });
mcpService(rig).serve();
$ deno add jsr:@bandeira-tech/b3nd-core jsr:@bandeira-tech/b3nd-move
import { connection, Rig } from "@bandeira-tech/b3nd-core";
import { mcpClient } from "@bandeira-tech/b3nd-move/mcp";

const upstream = mcpClient("https://network.example");

const rig = new Rig({
  routes: {
    observe: [connection(upstream, ["event://**"])],
    read:    [connection(upstream, ["event://**"])],
  },
});

const ac = new AbortController();
for await (const uris of rig.observe(["event://**"], ac.signal)) {
  const events = await rig.read(uris);
  for (const [uri, payload] of events) {
    await fetch("https://hooks.slack.com/...", {
      method: "POST",
      body: JSON.stringify({ text: `${uri}: ${JSON.stringify(payload)}` }),
    });
  }
}
04 flow/spine #spine

Many apps. One spine.

Ship an experience tonight.

Ship another beside it tomorrow.

Let the agent ship the next.

Same information underneath.

The store, the wire, the keys, the audit trail, the access rules — already there, already symmetric, already yours. Auth, encryption, replication: built in, not bolted on. Production-ready isn't a deploy step. It's where you start.

05 proof/running #running

Not a sandbox. Running now.

The network is live. The packages are published. The first apps are shipping. None of it is a preview.

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 A marketplace where advertisers bid for attention and money flows to users. soon · α 0.0.1·
dogfood k3p Capture anything from the command line. Your data, your machine, your b3nd-save store. open soon · ~/.local/bin/k3p·
06 proof/sketch #sketch

The whole shape, in five lines.

One import. One Rig. Three verbs you call. The protocol-side three live in the routes. If your agent has ever written against an SDK, it already knows this shape.

import { Rig } from "@bandeira-tech/b3nd-core";

const rig = new Rig({ routes: { /* move · save · send */ } });

await rig.receive([[uri, payload]]);
const [data] = await rig.read([uri]);
for await (const u of rig.observe([pat])) { /* react */ }

deno · node · browser · agent · all the same shape.

07 proof/for teams #teams
AI-Native Data-Oriented Architecture

The platform cake folds into one Rig.

Queue, store, broker, observer, identity, access — collapsed into one uniform shape. The integration layer doesn't get smaller on b3nd. It stops existing.

for teams →
08 proof/ownership #ownership

Throw the app away. What you captured stays.

Every message your app makes is signed by your key. Every artifact is content-addressed. The data you capture in one app is the data your next app inherits — portable between any b3nd app: yours, someone else's, one that doesn't exist yet.

Agents read on your behalf only where you say. The access rules travel with the data, not with the app.

And when the network earns, the network earns for the people on it. Listorama is the first app of a marketplace where advertisers bid for attention and money flows to users — not to the platform.

Build like the data is permanent. Build like the next app could read it without asking.

09 who/audiences #audiences

Pick your door.

Four ways in. The same Rig under each.

builders shipping with ai You ship many apps. They share one spine. Every prompt-built app, every late-night experiment, every demo that survives the weekend — they land on the same information. Your next app inherits everything the last one earned.
new devs · vibe coders · prompt-first You want the web to feel direct again. Prompt the app. Ship the system. Your agent and you read through the same shape, signed by the same key.
architects · ops The integration layer was a job. Now it isn't one. Queue, store, broker, observer — they used to be components you composed. They become operations of one uniform shape. The boilerplate doesn't shrink. It stops existing.
creators · attention workers Your audience should follow you — not the platform. The marketplace pays you, not the feed. Your audience comes with you when you move — no platform holds them hostage.
10 in/community #community

Built in the open. Built with the people building on it.

Monthly mini-hackathons. Bi-weekly recorded training. Open bounties. Office hours every week.

Prizes for best video demo, most serious business, funniest, community choice, your language.

If any of this rang true, you already half-know what we're doing.

no spam · your email lives on a b3nd store, what else

jsr · @bandeira-tech · github · bandeira-tech · firecat testnet · bandeira.tech
free · open source · MIT-licensed · all of it
© b3nd · digital spellcraft · amsterdam · 2026