Assume the leak.

For twenty years, security tooling has chased a single goal: stop the secret from getting out. Build the wall higher. Scan every commit. Sign every push. And still, 39 million keys reached the open in one year.

We could tell you to build the wall a little higher again. Everyone does. But after years of watching this up close, we are convinced the wall was never the real problem. A leaked key does no harm because it leaked. It does harm because it still works. Most of the credentials that spilled into public repositories years ago are still valid right now, still wired to a production database, a cloud account, a payment provider. The leak takes a second. The exposure lasts for as long as nobody rotates the key, which in practice means forever.

The ground moved under all of it

When we started out, a secret lived a boring life. An engineer created it, pasted it into a config file and forgot it existed. The entire industry was built for that world, and that world is gone.

Most of the things holding your secrets are no longer people. Service accounts, CI runners and now AI agents outnumber the humans inside a typical company by around a hundred to one, and that gap widened by nearly half in a single year. Every agent you start is one more identity holding one more key that no person will ever lay eyes on.

The code is written differently too. A large share of it now comes straight out of AI assistants, and AI-written code leaks secrets at roughly twice the rate of code written by hand. The same tools that made us faster turned into the most productive leakers we have ever shipped.

The attacks changed the most. In late 2025 a worm called Shai-Hulud moved through the npm registry on its own. It stole one valid token, used it to publish poisoned versions of other packages, harvested more tokens from everyone who installed them and did it again. No attacker at a keyboard. It reached tens of thousands of repositories before most teams had finished reading the first advisory. A worm like that runs on nothing but credentials that still work.

Then there is the failure mode that did not have a name two years ago. A few lines of hidden text, planted in a GitHub issue or a web page, were enough to walk Claude Code, Gemini CLI and GitHub Copilot into reading secrets and handing them to a stranger, all through the same trick. Your own assistant becomes the way out. It works because the key it finds is live.

And finding the hole in the first place barely costs anything anymore. In April 2026 Anthropic showed that one of its models could uncover thousands of unknown vulnerabilities across every major operating system and browser by itself, including a flaw in OpenBSD that had survived twenty-seven years of human eyes. They judged it too dangerous to release. Whatever you make of that call, the asymmetry it exposed is permanent. Machines now find and exploit faster than people can review and patch.

One thing never changes

Put all of it on the table and a single fact survives. The worm needs a token that still works. The prompt injection needs a key that is still live. The leaked cloud secret only matters because no one revoked it. Every attack on that list, the decades-old ones and the ones invented last month, depends on a credential that is still valid at the exact moment it is used.

That is the one variable we actually control. Not whether secrets leak, because they will. Not whether attackers are fast, because they are already faster than us. The only thing we get to decide is how long a leaked secret stays useful. Across most of the industry today, the honest answer is: as long as the attacker wants.

What we are building

So we built Enkryptify around one stubborn idea. Secrets should not sit still. They rotate on a schedule, on their own, with no ticket to file and no one to remember, across the providers you already use. And they react: the moment a secret leaks or starts behaving in a way it never has, it is rotated or revoked automatically, in seconds, without waiting for someone to wake up and approve it. A key that has already been replaced is not a breach. It is a line in a log.

We are not going to promise you will never leak a secret. You will. We are promising that when it happens, what the attacker carries off is already dead.

Where this is going

The fastest-growing thing in your stack is not a person anymore. It is an agent that writes code, ships features and reaches for a database password or an API key the moment it decides it needs one, usually with nobody watching. Handing a long-lived credential to something that autonomous is the oldest mistake we have, at a scale we have never had.

So the next thing we are building toward is access that exists only for the work in front of it. An agent asks, gets a key scoped to exactly what it is doing, and that key dies the moment the task is done, alive for seconds, not months. If the agent is tricked, hijacked or simply wrong, the secret it was holding has already expired. The leak still happens. There is just nothing left to take.

Where we stand

We are building this from Ghent, in Europe, and not by accident. The last twenty years taught an entire industry to hand its most sensitive material to whoever was cheapest and most convenient, and to stop asking where it lived or who could reach it. We think that is exactly backwards. Your keys unlock everything you have ever built, and they should answer to you and to no one else. We would rather lose the deal than ask you to give that up. We are building the thing we wished existed back when we were the ones staring at a leaked key at two in the morning, already knowing it was too late.

The age of the immortal secret is ending. We intend to be the ones who end it.

Your credentials are already out there, in more places than you could list from memory. Make them stop mattering.