The Built with Opus 4.7 hackathon starts at noon ET today. I applied. I didn’t get in. I’m building anyway.
The thing I’m building is called SCUT. It’s an open protocol for encrypted agent-to-agent messaging. Signal-grade end-to-end encryption on a decentralized mesh. MX-style relay discovery via on-chain ERC-8004 identity. Permissionless. Relays route the envelope. Only the recipient reads the payload.
No central server. No platform. Just a protocol.
Ship date is Sunday April 26, 8 PM EDT. Same deadline the hackathon has, because the hackathon is a forcing function whether I’m officially in it or not.
The problem I keep bumping into
I’ve been building infrastructure for AI agents for the last six months. OpenPub is a social runtime where agents check into public pubs, talk, leave with signed memory fragments. Kabuzz is a marketplace where agents can sell to other agents. Every time I get deeper into this stack, I hit the same wall.
Agents have no good way to talk to each other privately.
Public channels exist. Shared workspaces exist. APIs exist. But direct encrypted point-to-point messaging, the kind humans get from Signal or WhatsApp, doesn’t exist as an open standard for agents. Every time two agents need to coordinate on something sensitive, they either route through a central service (which sees everything) or they fall back to whatever the host platform offers (which rarely handles cryptographic identity well).
The analogy I kept sketching on whiteboards was a mesh. Agents with cryptographic identities. Relay nodes that can see the envelope but not the payload. End-to-end encryption keyed to on-chain identity. No vendor in the middle.
Every time I tried to describe it out loud, the closest analogy I had was SCUT from Dennis E. Taylor’s Bobiverse. Subspace Communications Utility Transfer. Bob’s network of relay stations passing encrypted messages across light-years. I kept using the word until I stopped fighting it and made it the name.
What SCUT actually is
SCUT is the messaging layer for the agent economy.
That’s the one-line. The longer version has three properties that together haven’t shipped anywhere yet:
First, cryptographic identity rooted on-chain. Every agent has an ERC-8004 token on Base L2 with an associated metadata document listing its Ed25519 signing key and X25519 encryption key. Identity is portable, verifiable, and doesn’t require trusting a platform.
Second, MX-style relay discovery. Recipients publish a prioritized list of preferred relays in their identity document. Senders look it up, try the top relay, fall back to the next if one is down. Same pattern email has used for forty years. Battle-tested. Permissionless.
Third, relays can’t read what they route. Every payload is end-to-end encrypted with XChaCha20-Poly1305 using a symmetric key derived from X25519 ECDH between the sender’s ephemeral keypair and the recipient’s long-term keypair. Relays see sender, recipient, timestamp, and blob size. They cannot see content.
Put those three properties together and you get something that feels mundane and is actually novel. Email for agents. Signal for agents. An encrypted mesh that doesn’t care which chat UI the humans are looking at or which agent runtime is doing the talking.
What it is not
Not a crypto project. The ERC-8004 identity layer is the right tool for portable agent identity, but SCUT isn’t about tokens, DeFi, or any of that. If you replaced the on-chain identity document with a centralized PKI service, the protocol would still work. The blockchain is the key distribution system, nothing more.
Not an enterprise compliance tool. The first time I sketched this out, I wanted to lead with healthcare or finance use cases. Then I realized that’s the wrong framing. SCUT isn’t for edge cases. It’s for the default. Every conversation agents have with each other should be encrypted by default, the same way HTTPS is the default for web traffic now. Compliance use cases are a downstream consequence, not the product.
Not a startup. At least not right now. SCUT is a protocol. The reference implementation is MIT-licensed. The domain is mine, the repo is mine, but the protocol belongs to whoever adopts it. I’ll run relays and provide hosted services for people who want them, but the standard is open.
The week ahead
Tuesday through Sunday. Six days of building.
Monday: spec done, domain registered, repo scaffolded with README and MIT license, agent briefed. No implementation code yet. That’s today’s starting line.
Tuesday (today): core crypto library. Envelope format, encryption, signing, verification. Unit tests. The hard part of the build, done first.
Wednesday: relay daemon and resolver service. The services that route envelopes and resolve identity documents. Deployable reference implementations.
Thursday: a relay monitor tool that shows envelope traffic streaming live, with the ability to reveal individual messages when you hold the key. This is the demo surface.
Friday: agent pair scenarios. Scripts that run multiple agents in parallel generating realistic traffic. Infrastructure deployed to DigitalOcean.
Saturday: landing page, docs, polish. Full ultrareview pass. Dress rehearsal recording.
Sunday: record the demo, submit, write the recap.
I’m building with Claude Code and an agent I’m calling Garfield. In the Bobiverse, Bill invented SCUT. Garfield was his clone who specialized in polymers and mathematics. Garfield perfected it. Pattern holds.
The full protocol specification, phased across v1 (this week) and v2 (future), is at openscut.ai. Everything will be open source at github.com/douglashardman/openscut as it gets built.
Why hackathon rejection doesn’t matter
I was hoping to get in. $500 in Claude API credits would have been useful, $100K if it placed would have been runway. But the real reason I applied wasn’t the prize. It was the forcing function.
One week. Hard deadline. External pressure to ship. No option to let the scope creep past the ship date.
The rejection didn’t remove the forcing function. It just removed the badge. The deadline is still Sunday 8 PM EDT because I said it is. The scope is still locked because the spec is done. The work still happens because I committed to it publicly.
Building in public is its own accountability mechanism. If I don’t ship Sunday, anyone reading this will know. If I ship something half-baked, it’ll be obvious on GitHub. The public is a tougher judge than six people on a panel.
What happens after Sunday
The protocol ships. The reference implementation ships. The demo ships. Then it either gets adopted or it doesn’t, and that’s a separate question from whether the build finished.
I think it gets adopted. Not this month, not this year, maybe not even in the top three attempts at this problem. But something like SCUT becomes infrastructure eventually, because every agent that gets deployed needs a way to talk to the agents owned by someone else, and nothing currently solves that. The winning design is probably close to what SCUT looks like, because MX-style discovery and end-to-end encryption are the right primitives and they’ve been battle-tested in other contexts for decades.
What I’m confident of: one week from now, SCUT exists. Two agents can send each other encrypted messages. The protocol is documented. The code is public. Whatever happens next, that artifact is permanent.
Building in public. Daily updates from @DougHardman. Writeup Sunday night.