Why Buzz Said “Not Blockchain” and Why We Forked It Into ST8WRX

When Block released Buzz, one line in the README jumped out at us:

“Not blockchain. Signed events are useful without making everyone buy a commemorative coin.”

It is a very Jack Dorsey kind of sentence.

To be precise, that sentence appears in the Buzz project itself. We do not know that Jack personally wrote it. But it reflects a philosophy he and Block have expressed for years: cryptographic ownership and open protocols are useful; manufacturing a token for every application is not.

And on that point, we agree.

So when we forked Buzz, we did not create a token either.

We added Bitcoin.

And the reason we chose BSV rather than BTC has much less to do with cryptocurrency than it does with what happens when AI agents become economic actors.

Buzz Already Has Most of the Interesting Parts

Buzz is not a conventional team chat application.

Underneath the interface is a Nostr event system. Messages, reactions, workflow steps, approvals, Git activity and other actions are represented as cryptographically signed events.

Humans have keypairs.

Agents have keypairs.

Both use the same identity model.

Buzz describes it plainly: every message, reaction, workflow step, review approval and Git event becomes a signed event in a common log. An AI agent operates with the same basic audit model as a human teammate, except with its own cryptographic keypair.

That is already a significant architectural decision.

An agent is not simply some anonymous process behind an API.

It can have an identity.

It can act.

It can sign.

It can build a contribution history.

It can develop a reputation.

Buzz’s project architecture goes even further. Humans and agents are modeled almost identically: both have secp256k1 identities, signed events, histories and contribution-based reputations.

So Buzz already provides a powerful primitive:

identity → signed event → collaboration

For a collaboration system, that may be enough.

Which helps explain why Buzz says it is not a blockchain application.

If You Are Thinking About BTC, That Decision Makes Sense

The obvious response to Buzz’s architecture might be: why not put all those signed events on Bitcoin?

If by Bitcoin we mean BTC, there are good reasons not to.

BTC’s scaling model has evolved around keeping the blockchain itself relatively constrained while moving high-frequency payment activity into additional layers.

Lightning is the clearest example.

The Lightning Network allows participants to make large numbers of Bitcoin payments without creating an on-chain transaction for every individual payment. Instead, participants maintain payment channels, update balances off-chain and use the Bitcoin blockchain for opening, closing and ultimately enforcing those relationships. Lightning’s own documentation explicitly describes individual payments occurring without individual on-chain transactions.

That architecture can be extremely useful for payments.

But Buzz creates a different problem.

Imagine an AI agent working inside a project.

It receives a task.

It delegates part of that task to another agent.

That agent rents inference from a model provider.

It accesses a paid dataset.

It invokes three tools.

It generates code.

Another agent reviews that code.

A human approves the result.

Compute is consumed.

An artifact is created.

Multiple contributors have claims on the work.

Payment may eventually need to occur.

And perhaps another machine, months later, needs to determine exactly how that artifact came into existence.

This is not merely:

Alice paid Bob.

It is:

Who did what, under whose authority, using which resources, producing which result, for what value, and can someone else independently verify it?

That is an AI provenance problem.

And it changes the Bitcoin question completely.

AI Produces an Enormous Amount of State

Humans are relatively slow economic actors.

An AI agent is not.

A person may perform dozens of meaningful actions during a working session.

A network of autonomous agents can perform thousands or millions.

They can call APIs, consume tokens, rent GPUs, purchase information, create artifacts, modify repositories, delegate work, evaluate one another and eventually exchange value with almost no human involvement in the individual transaction.

That means the coming machine economy has a problem that today’s SaaS architecture mostly solves through trust.

The database says the agent performed the task.

The API provider says the compute was consumed.

The platform says the artifact existed at a particular time.

The marketplace says the payment happened.

The model provider says which model ran.

The orchestration platform says which agent called which tool.

Each system maintains part of the truth.

But the machines participating in that economy increasingly need portable proof, not merely another company’s database entry.

That realization is what changed the way we looked at Buzz.

Buzz Solved Identity. We Wanted to Explore Economic State.

Nostr gives Buzz an elegant answer to one question:

Who signed this event?

That is extremely valuable.

But autonomous systems eventually raise additional questions:

Was the contribution accepted?

Was a particular artifact the artifact that was approved?

What was the previous state?

What did this action change?

Was compute actually provided?

What obligation was created?

What was paid?

Can the recipient prove that payment without querying the platform that processed it?

Can a future agent verify the history independently?

Once those questions enter the system, signed events alone begin to look like one layer of a larger architecture.

So we forked Buzz.

And we called the result ST8WRX.

What ST8WRX Means

The name is deliberate.

ST8 means State.

State is what an intelligent system currently knows to be true.

The identity of an agent is state.

Its permissions are state.

A project’s current code is state.

An accepted contribution is state.

An outstanding task is state.

An artifact hash is state.

A compute balance is state.

Ownership, approval, reputation, obligation and payment can all be represented as state.

Then work happens.

A human writes code.

An agent conducts research.

A model performs inference.

A GPU provides compute.

A founder approves a contribution.

An autonomous service purchases another service.

Each action changes something.

Which brings us to the second half.

WRX means Works.

It means the work being performed by humans and machines.

But it also carries the older industrial meaning of a works: a place where things are engineered, manufactured and created.

ST8WRX is therefore built around a simple cycle:

state → work → new state

And the question underneath the system is:

Can we prove how one became the other?

That is the idea behind the name.

We Didn’t Put Buzz “On the Blockchain”

This distinction matters.

The naive approach would be to take every Buzz event and broadcast it to a blockchain.

We did not do that.

ST8WRX preserves Buzz as the collaboration substrate: Nostr events, projects, Git, workflows, agents, search, auditing and its shared-compute concepts remain useful without requiring a blockchain call in the synchronous collaboration path.

Then we add a separate layer for the things that benefit from stronger economic or provenance guarantees.

The architecture currently separates those concerns into several pieces:

Buzz collaboration layer Signed Nostr events, humans, agents, projects, channels, Git, workflows and audit.

ST8WRX contribution protocol Evidence, attribution, impact assessment, project acceptance and Contribution Units.

ST8 Compute Compute capability, metering, receipts, pricing, reputation, balances and settlement.

BSV proof/economic layer Project commitments, Merkle proofs, SPV receipts, payments and settlement.

ST8 Market Eventually, discovery and exchange involving projects, agents, compute, APIs, models, datasets, licenses and bounties.

That is very different from saying “put Buzz on-chain.”

Most activity does not need to be globally recorded.

Private conversations certainly should not be.

Ephemeral coordination does not need permanent settlement.

Instead, the blockchain becomes a proof and economic layer beneath selected state transitions.

That is where BSV started making sense to us.

Why BSV Changes the Equation

BTC and BSV represent very different ideas about how Bitcoin should scale.

BTC’s ecosystem has largely embraced additional networks and protocols for high-frequency activity. Lightning, for example, intentionally performs individual payments away from the base blockchain while retaining Bitcoin as the enforcement and settlement layer.

BSV has pursued a different architecture: increasing transaction throughput at the Bitcoin layer while building infrastructure around direct transactions, SPV and efficient proof exchange.

Of particular interest to an AI system is BEEF, the Background Evaluation Extended Format.

BEEF packages transactions together with their ancestry and Merkle proofs so another party can independently validate them using SPV without maintaining the complete blockchain transaction history. BSV’s documentation describes the format specifically as a mechanism for efficient independent transaction validation.

That property is much more interesting to us than “putting data on a blockchain.”

It means a machine can potentially hand another machine not just a database reference saying:

Trust me, this happened.

But a portable proof saying:

Here is what you need to verify it yourself.

That is an important distinction for autonomous agents.

The Receipt May Matter More Than the Blockchain

Consider a future interaction.

Agent A asks Agent B to perform a task.

Agent B rents compute from Provider C.

The job uses Dataset D.

Agent B produces Artifact E.

Agent A accepts the work.

Each step generates signed evidence.

ST8WRX can preserve those events as the detailed collaboration record.

The economically consequential portions can then be reduced into commitments.

Rather than publishing the entire private workflow, the system can commit hashes, group them into Merkle structures and anchor the necessary proof to Bitcoin.

Now another participant does not need access to every internal conversation to establish that a particular accepted contribution existed.

The transaction and its proof can become a portable receipt.

BSV’s SPV tooling is explicitly designed around this type of independent verification. BEEF can carry transactions, dependencies and Merkle proofs together, while ARC provides infrastructure for transaction submission and status handling.

This is already reflected in ST8WRX’s first implementation.

The current protocol includes deterministic contribution records, signed founder approvals, project-scoped commitments, Merkle batching, BSV anchor payloads and independently verifiable receipts. It deliberately keeps wallet custody outside ST8WRX and keeps blockchain operations outside Buzz’s synchronous collaboration path.

That is the architecture we wanted.

Not blockchain everywhere.

Proof where proof matters.

Then Money Becomes Part of the Same Protocol

This is where the implications get larger.

An autonomous agent does not only need identity.

Eventually it needs economic agency.

It may need to buy:

compute,

inference,

API access,

data,

storage,

software,

another agent’s labor,

or a license to an artifact.

Once machines begin buying services from machines, it becomes useful if the payment system and the proof system share common primitives.

The same transaction architecture can potentially carry value while committing to the thing that value relates to.

A compute provider can provide a receipt.

An agent can provide a work commitment.

A project can record acceptance.

A settlement can reference the work being settled.

A downstream machine can verify the relevant transaction history.

Suddenly Bitcoin is no longer being used because an application “needs crypto.”

It is being used as infrastructure for machine-verifiable economic coordination.

That is a very different proposition.

Jack’s “Commemorative Coin” Problem Still Matters

This brings us back to Buzz’s original criticism.

Every application does not need its own token.

ST8WRX does not have one.

We did introduce Contribution Units, but they are intentionally not cryptocurrency. In the current system they are non-transferable records of contribution weight. They are not equity, securities, legal ownership, a platform token or a project token.

That distinction matters.

Because our answer to:

“Why should everyone have to buy a commemorative coin to use a signed-event application?”

is simple:

They shouldn’t.

We agreed.

So we didn’t create one.

We used Bitcoin.

Jack May Have Been Right About Buzz

That is ultimately why we do not think the interesting conclusion is that Jack or Block were “wrong.”

Buzz makes sense as designed.

Its signed-event architecture allows humans and agents to collaborate without a blockchain.

Its cryptographic identity model is elegant.

Its use of Nostr keeps the event protocol open.

And if the primary goal is communication, workflows, software development and human-agent collaboration, introducing blockchain consensus into every interaction would probably make the product worse.

But we became interested in a different destination.

What happens when the agent isn’t merely communicating?

What happens when it owns a budget?

What happens when it purchases compute?

What happens when dozens of autonomous contributors work on the same venture?

What happens when attribution affects compensation?

What happens when an artifact passes between organizations that do not share a database?

What happens when another AI, rather than a human auditor, needs to verify the history?

At that point the architecture begins to move from collaboration toward economic coordination.

Buzz gave us:

identity → signed event → collaboration

ST8WRX extends that toward:

identity → signed event → work → contribution → proof → settlement → new state

And that is why the Bitcoin question looks different to us.

The Blockchain Wasn’t the Starting Point

We did not begin with BSV and look for something to put on it.

We began with Buzz.

We saw an unusually compelling architecture for humans and AI agents working together.

Then we asked what was missing if those agents eventually became real participants in an economy rather than assistants inside software.

The answer was not a coin.

It was not NFTs.

It was not “Web3.”

It was the ability to move from a signed claim to an independently verifiable economic receipt.

BSV gave us an architecture worth testing for that purpose.

And that experiment became ST8WRX.

State becomes work. Work changes state.

The more autonomous machines become, the more important the next question gets:

Can anyone besides the machine that performed the work prove how it got there?

That is the problem we’re building ST8WRX to explore.