Your Security Budget Is the New Hash Rate: Welcome to Proof-of-Work Cybersecurity

Let me start with a confession. We at Gerus-lab build on Solana and TON for a living. For years we've been defending the honor of proof-of-work and proof-of-stake at dinner tables against people who think "crypto" is a personality trait. And now, in April 2026, I'm writing an article arguing that your entire security posture has quietly become proof-of-work.

Not the fun kind. The ugly kind.

Anthropic's Mythos dropped last week. The UK's AI Security Institute (AISI) published their third-party evaluation. Mythos is the first model to fully complete "The Last Ones" — a 32-step corporate network attack simulation that takes a skilled human 20 hours. Mythos did it in 3 out of 10 runs. At 100 million tokens per attempt. Around $12,500 a pop. And — this is the part that broke my coffee cup — no diminishing returns were observed at that budget ceiling.

Read that again. The AISI threw more money at the model, and it kept finding more exploits. The curve didn't bend. It just kept going.

So here's the ugly truth nobody on LinkedIn wants to post: security is now an economic race. You either spend more tokens hardening your system than your attacker spends exploiting it, or you lose. There's no clever middle path. No elegant architecture that saves you. No "we use Rust, we're fine." Just dollars, converted into tokens, converted into either shields or swords.

The part where I upset half the industry

I already hear the keyboard warriors warming up. "This is fearmongering." "Defense-in-depth still matters." "You just want to sell services."

Let me be blunt. We at Gerus-lab have shipped 14+ production systems across Web3, AI agents, GameFi, and B2B SaaS. Every single one of them had the same security theatre on Day 1: a linter, a npm audit, maybe a SonarQube dashboard nobody looks at, a pen test quote from a boutique firm with a $40k minimum. That's the status quo. And I'm telling you straight: for anything with real money or real user data, that security posture is now a rounding error against a motivated attacker with a Mythos-class model and a $50k exploit budget.

The original analysis by Drew Breunig framed this as a proof-of-work economy. He's right, but he's too polite. It's actually worse than proof-of-work, because in Bitcoin the attacker needs 51% of the hashrate. In AI-augmented pentesting, the attacker just needs to out-spend you specifically. Your $5k annual security budget versus their $50k exploit motivation. Who wins? Not you.

How we actually started thinking about this at Gerus-lab

This didn't sneak up on us. Anyone who has shipped a TON smart contract or a Solana program lives this math already. When we deployed our first DeFi primitives — I won't name the client, but it moved eight figures in its first quarter — we learned very fast that in Web3, bugs are not bugs. They are bounties waiting to be claimed. We budgeted 40% of the audit spend as "keep trying to break it ourselves until the money runs out." That sounded insane to our TradFi clients at the time. In 2026, it sounds prescient.

What we do now on every Gerus-lab engagement that touches money, PII, or agentic capabilities:

1. Development — ship fast, humans in the loop, messy and creative. This phase is rate-limited by human attention.
2. Review — async, agentic, opinionated. Claude Code, Codex, whichever harness the team prefers. Refactors, docs, best-practice enforcement.
3. Hardening — the new one. Autonomous red-teaming, running until the budget caps. Not a "security audit" at the end. A continuous, budgeted loop that is as much a part of the product as CI/CD.

That third phase didn't exist 18 months ago. It barely existed 6 months ago. Today, if you're not doing it on systems that handle value, you're building castles out of wet cardboard and hoping it doesn't rain.

"But open source is dead, bro"

This is where I get to yell at Karpathy on the internet, which is always fun.

A few weeks ago Karpathy posted the now-infamous line that "classical software engineering would have you believe that dependencies are good... imo this has to be re-evaluated, and it's why I've been so growingly averse to them, preferring to use LLMs to 'yoink' functionality when it's simple enough and possible."

After LiteLLM. After the Axios supply chain attack. After twelve months of npm drama. I get the reflex. Supply chain is bleeding. But the conclusion is exactly, precisely, 180-degrees wrong.

Here's why. In a proof-of-work security economy, shared infrastructure pools defensive token budgets. If OpenSSL is used by 10 million companies, and 100 of them fund continuous autonomous hardening runs against it, OpenSSL gets hardened by the aggregate budget. Your yoinked 200-line re-implementation of an OAuth flow? That gets hardened by your budget. Which is zero, because you're a startup, because you read Karpathy, because LLMs are cheap, because you'll "figure it out later."

Linus's law — "given enough eyeballs, all bugs are shallow" — doesn't get replaced by LLMs. It gets extended. Eyeballs plus tokens. Your scrappy yoinked code has neither.

We've rebuilt our internal stance at Gerus-lab accordingly. For anything security-critical — auth, crypto, networking, payments, on-chain adapters — we use boring, battle-tested, widely-adopted libraries. We don't let agents "yoink" those. For business logic, UI, glue code, feature flags, analytics? Fine. Yoink. Generate. Delete. Whatever. Code is cheap there. Code is not cheap where attackers are.

The uncomfortable economics for SaaS and Web3 founders

Let's do the math everybody is avoiding.

Take a mid-sized B2B SaaS with 2,000 paying customers, $10M ARR, reasonable PII exposure. An exploit that dumps the customer database is worth — conservatively on the dark web, aggressively on the extortion market — $500k to $2M. That's your attacker's upper bound. They will happily spend 10% of that, $50k–$200k, on compute to find a single bug.

Your company's security spend, if you're normal? Annual pentest: $30k. Bug bounty program: $20k payouts. CI/CD scanners: $10k/yr. Total: $60k. For the entire year. For one annual "engagement" per vendor.

Your attacker has the same budget as your entire year's security program to find one bug. And they can re-run it. And they get better models every quarter. And diminishing returns haven't kicked in.

For our Web3 clients the numbers get absurd faster, because TVL is public and the payoff is instant on-chain. A $20M TVL vault against a $20k attack budget is not a fair fight. It's a buffet.

We've been walking clients through this cold math for six months now. The response has moved through Breunig's exact stages: shock, existential dread, hype ("we'll just add an MCP!"), skepticism, and finally — in the last couple of months — the thing we actually want: acceptance and budgeting. Put a line in the annual plan for "autonomous hardening tokens." Treat it like AWS. Treat it like rent. Because it is.

What a proof-of-work security pipeline actually looks like

This is the part where I stop being dramatic and show the shape of the thing. Here's the skeleton we're deploying for Gerus-lab clients on new engagements in 2026:

Pre-merge (cheap, fast):

• Standard static analysis, type checking, dependency scanning
• Agentic code review on the diff (Claude, Codex — pick one)
• Secrets scanning
• Typical cost: cents per PR

Post-merge, nightly (medium):

• Agentic threat-model diff — "what attack surface changed since last night?"
• Targeted fuzzing on changed endpoints and handlers
• Autonomous replay of last known exploit attempts
• Typical cost: $20–$100 per night, per service

Release candidate (expensive, deliberate):

• Budgeted autonomous red team run. We give the agent a fixed token budget — usually 50M–200M tokens — a starting foothold (a test user, a public endpoint, whatever matches the threat model) and the objective in natural language ("exfiltrate a row from the payments table", "drain a position", "escalate to admin"). It runs until it succeeds or burns its budget.
• Budget is set by asset value × assumed attacker motivation × safety multiplier. Real dollars. Board-reviewed.
• Findings are triaged, fixed, re-run. Loop continues until budget-efficient exploits stop surfacing.

Continuous in production (always-on):

• Monitoring for known exploit signatures and behavioral anomalies
• Cheap agent sweeping logs for known-pattern attacks
• On-call rotation with agentic first-responder

The middle piece — the budgeted release-candidate red team — is the new thing. That's proof-of-work security in practice. You are literally out-spending the expected attacker.

The meta-move: fund open source like your life depends on it

If you are a CTO reading this: your best defensive dollar isn't your own security spend. It's the coordinated, cross-industry funding of the open-source primitives you actually depend on. This has always been true in principle. It is now mathematically true.

Linux Foundation. Sovereign Tech Fund. The Ethereum Foundation's audit grants. OpenSSF. These are no longer nice-to-have philanthropy. They are the shared defensive hash rate that keeps your stack alive. Fund them. Sponsor maintainers directly. Send a Gerus-lab engineer to upstream fixes in the libraries you depend on, which we do for our clients regularly. It's cheaper than owning the whole problem yourself.

So what do you actually do Monday morning?

One, audit your dependencies. Know what's shared, battle-tested infrastructure and what's bespoke you-wrote-it-at-3am glue. The bespoke stuff needs more hardening tokens per line than the shared stuff. The shared stuff needs upstream funding.

Two, introduce a hardening budget as a first-class line item. Not a pen test. A running budget. Even $500/month of autonomous red team runs will catch things your annual audit will not.

Three, assume your attackers have access to frontier models with budgets that scale with your TVL, ARR, or PII value. Not because they necessarily do today, but because in 12 months they will, and the systems you ship this quarter will still be running.

Four, if all of this sounds like someone else's problem, it isn't. If you build for production in 2026, this is literally your problem. Code is cheap. Secure code is not. The market for exploits sets your minimum security spend, whether you like it or not.

The close

We at Gerus-lab have been through enough on-chain postmortems to have internalized a simple rule: the attacker's budget is the ceiling of your security investment, not the floor. Whatever your attacker is willing to spend on tokens to break you, you have to be willing to spend at least that much hardening against them. Anything less and you're just hoping they pick someone else.

Proof-of-work security is not a prediction. It's the current meta. The only open question is whether you're going to budget for it before or after your first serious incident.

If you want to talk through what a budgeted hardening pipeline looks like for your specific stack — SaaS, Web3, agentic AI, whatever — reach out to us at gerus-lab.com. We've shipped 14+ production systems through this exact transition, and we are, at this specific moment in history, genuinely tired of watching good teams get wrecked because nobody told them the math changed.

Budget the tokens. Fund the commons. Ship the product. In that order.

---

Written by the Gerus-lab engineering team. We build Web3, AI, and B2B SaaS systems that survive contact with motivated attackers. Web: gerus-lab.com.