Tune in, and every second of stream is measured by both sides and paid for as it arrives. Stop, and the meter stops — mid-song, to the byte.
A live illustration of the rule flume enforces — not a real stream. Hit Stop and watch the bill freeze.
Every way we pay for streams today bills the whole thing — a monthly plan, a track, an album, a movie. Leave halfway and you still paid for all of it. flume's unit isn't the whole thing. It's the byte. So the price tracks exactly what was delivered, and the moment you walk away, the charging stops with you.
The meter is net.bytes_delivered.v1, exact to the octet. The broadcaster counts
what it sent; you count what you received; the two must agree or the stream halts. Nobody can
overstate the bill, because your own count refuses it.
You drive your own position through the stream. A dropped connection is just a reconnect from where you left off — no renegotiation, no double charge, no gap you paid for. Stopping is simply the last byte you accepted.
flume is spigot — pay-per-byte file delivery — with one change: the source is open-ended instead of a fixed file. A recording, a radio feed, a video: all just bytes arriving over time, which is what the metered protocol already meters.
Everything else is identical, because a chunk of a stream and a chunk of a file are the same thing: a range of bytes both sides can count.
| On-demand | Live | |
|---|---|---|
| is | a recording — a fixed buffer | a feed still being produced |
| length | known up front | grows; unknown until it closes |
| the end | the last byte | only when the broadcaster closes it |
| rewind | any offset, always | only within a bounded window; older bytes are gone |
| at the edge | — | you wait a beat and ask again — billed for none of the empty moments |
Paying by the second means thousands of tiny amounts. You can't touch a chain for each one — so flume doesn't. It opens one escrow channel, streams against it off-chain with signed vouchers, and settles once.
You open an escrow channel with the broadcaster a single time. Every babel after that is an off-chain voucher — instant, free. The broadcaster redeems the vouchers on-chain whenever it likes; you refund whatever you didn't spend.
Opening, claiming and refunding are ordinary Kaspa transactions — fast to confirm and cheap enough that a 0.06 KAS bill is worth settling. flume rides the same kaspa-x402 escrow that spigot does; nothing bespoke.
An autonomous agent can't fill in a signup form or hold a monthly plan. It can open a channel and pay per byte. flume is billing an agent can actually use.
A machine won't argue a bill — so the bill has to be provably right. Both sides count the same bytes with zero tolerance; an overcharge is caught mechanically, not disputed later.
Sample the first two seconds of a thousand feeds; take a whole track from one. The bill follows the bytes, so partial consumption is a first-class, cheap operation.
Agents run on flaky links. A stall is just a reconnect from the last accepted byte — no state to renegotiate, no gap anyone paid for. The stream resumes where it stopped.
Open a channel, tune in paying per second, each babel vouchers as it plays, and the broadcaster claims what the vouchers cover — all on chain, the same rail spigot settles on.