b3nd — digital spellcraft. A data substrate for apps built with AI.
digital spellcraft.
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.
Building is the easy part.
Pick a verb. Pick where it goes. The wiring is already here — what's left is the app.
Try it now.
Three doors. Pick one.
$ 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)}` }),
});
}
}
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.
Not a sandbox. Running now.
The network is live. The packages are published. The first apps are shipping. None of it is a preview.
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.
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
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
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.
Pick your door.
Four ways in. The same Rig under each.
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