Why Our CLI and Desktop Agent Are Source Available
Why HookDeploy's CLI and desktop agent are source available under BSL 1.1, not fully open source: full code transparency for the software that runs on your infrastructure, an intact git history, and a pre-launch resilience audit that caught real bugs before customers could.
Asking someone to install an agent on their own infrastructure is a big ask. You’re inviting a piece of our software to run on your machine, with visibility into traffic you’re choosing to route through it. We understand exactly how much trust that requires, and we don’t think you should have to take our word for how that software behaves. So we made both hookdeployed (our CLI) and hookdeploy-agent (our desktop app) source available, under BSL 1.1.
Source available, not open source, and that distinction matters
We’re precise about this because the terms mean different things, and blurring them is its own small trust violation. Fully open source software carries a permissive license that allows anyone to do essentially anything with it, including build a competing hosted product on top of your own code. BSL 1.1 is different: the source is fully public and fully inspectable, but restricted from one specific use, standing up a competing hosted service. It converts to Apache 2.0 in 2030, so the restriction has a runway, not a permanent lock.
We’re not chasing an open source community or contributions. We’re not trying to look like something we’re not. The point of publishing this code isn’t to build in public for its own sake. It’s so that anyone with the skills to read it can verify, directly, exactly what happens on their machine before they decide to trust it there.
What we actually did before publishing
Making agent code public isn’t a switch you flip. Before either repo went live, we ran a full pre-publication git history scan, checking every commit, not just the current state of the code, for anything sensitive that shouldn’t be visible. We kept the full history intact rather than squashing it into a single clean “day one” commit. That was a deliberate choice: a suspiciously tidy history reads as more suspicious, not less, to the exact security-conscious audience this openness is meant to reassure. If you’re going to publish, publish the real record.
We also ran a dedicated resilience pass across both codebases, specifically looking for two failure classes: retry loops with no real termination condition, and error messages too generic to reveal what’s actually wrong when something fails. That pass caught real, pre-launch bugs. An enrollment failure summarizer that collapsed four distinct causes, expired, already consumed, invalid, rate limited, into one identical unhelpful message. A dead renewal token that could cause the connection process to retry placement forever with no path back to re-enrollment. A clock-skew condition that looked identical to a generic network failure until we specifically distinguished it. None of these were exotic. They’re exactly the kind of thing that erodes trust quietly if nobody goes looking for them before a customer finds them the hard way.
Why this specific piece of software, specifically
We didn’t make everything we build public. We made the CLI and the desktop agent public, because those are the two pieces that actually run on your infrastructure and touch your traffic before it reaches us. The dashboard, the API, the ingestion pipeline, those are our concern to secure and yours to trust through behavior and track record. The agent is different. It’s software you’re running, on hardware you own, with a level of access we’re asking you to grant directly. That’s the one place where “trust us” isn’t good enough on its own, and where “here’s the code, go read it” actually means something.
What this doesn’t mean
Being source available isn’t a substitute for the rest of what we’ve built. It doesn’t replace fail-closed encryption, break-glass access controls, or regional data residency. It’s not a claim that the code is bug-free because it’s public, plenty of real bugs made it into that code before we found them ourselves. What it means is narrower and more honest: if you’re deciding whether to run our agent on your infrastructure, you don’t have to take our description of its behavior on faith. You can go verify it yourself.
That’s the whole point. Trust that has to be taken on faith isn’t really trust. Trust you can verify is.