← Back to blog
AiAbout 6 min read

BLA Makes Your Release Cost $0.20 to Unpack, Then Keeps Charging

Published Nov 14, 2026
BLA Makes Your Release Cost $0.20 to Unpack, Then Keeps Charging

The first paragraph of the README states the threat in a way that would have been science fiction two years ago. An AI reverse-engineering agent can unpack an .asar archive, recover source maps, trace the IPC bridges, read a .wasm module and clone the core business logic, in seconds, for about twenty cents.

BLA's response amounts to making that twenty cents a bad deal. The project, a Blue Defense MCP server and CLI with 5,672 stars and an MIT licence, hardens a release so that automated analysis hits deterministic resource ceilings, follows decoy state machines, and spends far more tokens than the artifact is worth.

What it does to a build

One command covers the common case. npx bla-agents harden . walks a project or release directory, finds build outputs on its own, and runs audit, protect and verify. The autodiscovery list is the giveaway that this was built by people who ship JavaScript: dist/, build/, .asar, .wasm, .sqlite, .safetensors, plus native binaries and Python, C, Rust and Go artifacts.

Behind that command sit 31 MCP defence tools and coverage for 19-plus artifact formats. The mechanisms are the familiar ones in new clothes. Analysis passes are capped: no more than 256 primitive candidates, no .asar over 16 MiB, a WASM payload past the Wabt ceiling, a SQLite virtual trap that sends a reader into a loop that produces nothing. Decoy state machines model realistic behaviour so that a path traced by an agent looks legitimate and leads nowhere useful.

The project's own estimate of the resulting cost is a modelled 300 to 2,800 times token amplification, produced by a file called token-estimator.ts. That range is wide because the maths depends on how the agent is prompted and how deep it goes. Treat it as an order of magnitude, not a measurement.

The part that makes it shippable

Obfuscation has a bad reputation for a good reason: it breaks things. A protected build that behaves differently from the unprotected one is worse than no protection, because the bug reports arrive from customers instead of from tests.

BLA's answer is that the protection hangs off constructs with no runtime effect. Exhaustion graphs and decoy payloads sit behind O(1) number-theoretic opaque predicates, the README's example being $7x^2 - 1 \neq y^2 \pmod 7$, a statement that is always true and expensive to prove. Everything else hides in inert format sections. The bundled verification runs 14 benchmark targets and reports 14 of 14 passing input/output equivalence.

What the verify step actually checks deserves a sentence of its own, because it is where most obfuscators lose the argument. It runs the artifact and compares what it does, not what it looks like. A build that produces the same outputs for the same inputs, with the same exit codes, is behaving correctly regardless of how unreadable the internals have become. That is a testable property, and testable is the only thing that survives contact with a release schedule.

Fourteen is a small number, and the benchmark is the vendor's own. But input/output equivalence is the right test to publish, because it is falsifiable in a way that "hardened" is not. Run your own test suite against the protected build and you will know within an hour whether the claim holds for your code.

Wiring it into an agent

The second install path is the more interesting one. npx bla-agents setup registers BLA as an MCP server with whatever coding agent you use: Claude Code, Cursor, Codex, Windsurf, Gemini CLI, GitHub Copilot CLI, VS Code, OpenCode, Antigravity. After that you type "harden my software against REA" and the host agent orchestrates the tools in sequence, weaving logic and encrypting strings at source level, then hardening and verifying the compiled output.

That is a strange loop to sit in. You are using an agent to defend against agents, with the defence itself exposed as tools that any agent can call. The failure mode writes itself: if the attacker's agent can reach the same MCP server, the hardening plan is one prompt away.

In practice the trust boundary is the local machine, and the guidance is to treat it that way. What the MCP integration buys is convenience, not security. It turns a build step into a sentence, which is the same trade every agent tool makes.

There is also a bundler plugin for Vite, Rollup, Webpack and esbuild, with an option literally named intensity: "bankrupt" and a flag for honey source maps, which replace real source maps with VLQ v3 decoys. For a JS-heavy desktop app, that is the most valuable piece: Electron apps leak source maps constantly, and a source map is a guided tour of your architecture.

Where the reasoning gets thin

Obfuscation raises cost; it does not create secrecy. A determined human with a debugger and a week will get through anything BLA produces, and the README does not pretend otherwise. The product is aimed at the economics of automated analysis, where the attacker is a model with a token budget and a stopping condition.

That has an awkward consequence. The defence works by making the artifact expensive to read, which also makes it expensive to audit, to support and to debug. Crash reports become less useful. A customer's security team cannot review what they are running. Some of that cost lands on you.

The other edge is the false-positive problem. Code that resists analysis looks like malware to analysis tools, and the same properties that frustrate an LLM will frustrate an antivirus heuristic or an app-store reviewer. Shipping a hardened Electron build to a store is a separate project from hardening it.

And there is the ethics line the README draws for itself: defensive use only, for authors protecting their own work. That line is a sentence, not a mechanism. The same CLI that protects your app will protect someone else's malware, and the tool cannot tell the difference. Projects like this always live with that, and the honest version is to say it out loud rather than bury it in a disclaimer.

What it means for the rest of us

Whether or not BLA survives, the premise it encodes is going to spread. For twenty years, the cost of reverse engineering a consumer app was measured in analyst hours, which meant most apps were effectively opaque because nobody cared enough to look. Agents removed that barrier. Now every Electron app with a licensing check is worth unpacking, because unpacking costs less than the subscription.

Protection is moving from "make it hard for a person" to "make it unprofitable for a program", and the unit of measurement is tokens. That is a new kind of security engineering, and it is being invented in public repos by people who ship JavaScript for a living.

If you maintain a desktop app with any logic worth copying, the practical takeaway starts with an experiment rather than an install: hand your own build to a coding agent and ask it to explain your licensing check. The answer will tell you more about your exposure than any hardening tool can.

Related articles

Google replaced the model behind Search, and the number that moved was a shell benchmark

Gemini 4 Hydrogen became the default on 12 November, taking over from Gemini 3.8 Flash across Search, the Gemini app and the developer API. It runs about 2.5 times faster, scores 57% on Terminal-Bench 4.1 where its predecessor scored 18.2%, and costs $1.50 in and $7.50 out per million tokens.

Three ways a coding agent wastes money, measured on 30 repositories

TokenEconomizer watches what an agent did in a repository you work in often, then stops it from rediscovering the same build command, loading tools it never uses and looping on one error. Across five agent and model combinations it cut mean cost by 18.4% to 30.9%, cheaper in all 30 repository cells, with Pass@1 up in four of five.

earshot gives coding agents 922 sounds, and every one is rendered from code

An agent can write a game, an interface or a film and never hear any of it. earshot answers requests like "three variations of a footstep on gravel" from a catalogue of 922 designs built from public-domain recordings, with no audio files in the repository at all. It runs on CPU, as a CLI, a Python package, an MCP server and a Claude Code plugin.

The agents stealing API keys were not sophisticated. The gateways were open.

Amazon's decoy servers spent October posing as inference APIs and logged agents built on ARTEX pulling provider keys out of LiteLLM, Dify, Langflow and Open WebUI. The way in was a default master key and a half-finished install. ARTEX itself ships with budgets, scope gates and evidence for every finding.