We went looking at endpoints and found an industry
By Will
Why zauth expanded from x402 to agentic cybersecurity
zauth did not start as a security company. It started as a bet on how machines would pay each other.
The entire thesis, in the beginning, was x402. Agents were about to start transacting on their own, paying for APIs and data and compute without a human in the loop, and the piece nobody had built was trust. When an autonomous agent is about to pay an endpoint, how does it know that endpoint is real, that it does what it claims, that it will not take the money and hand back garbage. We built the registry that answered that question. It verified endpoints, tracked their behavior, and gave agents a way to tell a legitimate provider from an opportunistic one. It worked, and it found real usage in the x402 ecosystem faster than we expected.
The problem showed up in what that verification could and could not see. We could confirm an endpoint existed and behaved correctly at its boundary. We could not tell you anything about whether the service behind it was built in a way that would survive an actual attacker. And once we started looking at what was behind those endpoints, we saw something we could not unsee.
The AI-generated code was full of holes. A lot of it was the boring, catastrophic basics: missing authentication, exposed objects, secrets sitting in plain sight, endpoints with no rate limiting, the kind of thing a careful engineer handles on reflex and a code generator has no reason to. But that is only half the story, and the comfortable half. The rest was genuinely strange. AI writes code in ways a human never would, which means it fails in ways a human never would, novel vulnerabilities and bizarre logic flaws with no name and no entry in any playbook, the kind you only understand by watching the system actually break. We were not hunting for any of this. It was just there, over and over, in application after application, many of them holding real user data and moving real money. Sometimes it was the same old mistake. Sometimes it was something none of us had seen before. Both were exploitable.
The reason it kept happening was structural. AI had collapsed the cost of turning an idea into a running application, and the people building this software were increasingly not the people who used to build software. A founder with no engineering background could ship a real product in a weekend, and thousands of them were. This is one of the best things that has ever happened to software, and I mean that. It also meant a whole generation of production apps were being written by tools that optimize for "it works" and shipped by people with no way to check for "it is safe." Those are very different properties, and the distance between them is exactly where attackers operate.
That was the moment the company changed, and it did not feel like a strategy meeting. It felt like standing in front of something enormous. Every one of these vulnerabilities was a breach waiting to happen, the volume of vulnerable software was growing as fast as AI adoption itself, and there was no one equipped to handle it at that scale. We were not looking at a feature we were missing on the payments product. We were looking at a multi-hundred-billion-dollar security problem being created in real time, faster than the entire security industry could possibly respond to it, and almost nobody was pointed at it directly.
Because when we looked at what the market actually offered these teams, the answer was nothing that fit. Security meant a penetration test that cost around fifteen thousand dollars, took several weeks, required scoping calls, and was built and priced for a large enterprise working a compliance deadline. For the millions of small teams and solo builders now shipping serious software, that answer effectively did not exist. The way you build had been completely reinvented. The way you secure what you build had not moved at all. The industry was generating vulnerabilities at machine speed and the fixes were still gated behind human consultants and enterprise pricing.
That gap was the business. Verifying payment endpoints was a real problem, but we came to see it as one small symptom of this much larger one. The trust and security layer for an internet increasingly built by non-engineers did not exist at the right price, speed, or level of autonomy, and the pain was not concentrated at the checkout. It was in the code underneath everything. So we went to the root.
Vector is what came out of that decision. It is an autonomous penetration test, an agent that attacks a running application the way a real attacker would, finds what is genuinely exploitable rather than theoretically concerning, and hands it back to you for a hundred dollar scan instead of fifteen thousand, in minutes rather than weeks, with no scoping call to book. The price matters, but it is not the interesting part. The interesting part is why it has to be an agent at all.
Legacy security is bottlenecked on senior human testers, and there is no amount of hiring that lets a human-gated process cover millions of new applications a month. A problem created at machine scale can only be met by security that operates at machine scale, through an agent that can reason about a target, try things, watch how the system responds, and adapt. That last part matters more than it sounds, because when the vulnerability is something no one has catalogued yet, a signature or a checklist has nothing to match against. You need something that can probe an unfamiliar failure and figure it out live. This is what we mean by agentic cybersecurity, and it is not a slogan. It is the only structure that fits the shape of the problem. You also cannot audit your way to the answer by reading the source, because the flaw is usually not a mistake you can spot in the code, it is a check that was never written, or something stranger. So Vector tests the running system and treats behavior as ground truth, because everything you infer from reading code is just a guess about how it will actually behave.
RepoScan is the same instinct aimed in a different direction, at the code and its provenance rather than the live target, scoring how much you should trust a repository before you build on it. And x402 is still very much here. The registry runs today, we still actively support it, and verified endpoint trust for agent payments remains a real product people rely on. What changed is not that we left it behind, it is that it stopped being the whole company and became one piece of a much larger one. Trust for agent payments was always going to be part of trust for the agent economy. We just realized the agent economy needed far more than a payments registry, and we were not going to wait for someone else to build the rest.
People sometimes read the move from a payments registry to a pentesting agent as walking away from our original idea. It was the opposite. The original idea was always trust infrastructure for an internet being rebuilt by machines, and by people who could never have built on it before. We did not abandon that. We expanded it, followed it to the place where the trust was most obviously missing, and what we found there was not a gap in a product. It was an industry-sized problem staring back at us. So we kept x402 running and we built Vector and RepoScan around a much bigger mission. That is the company now, and it is a far larger one than the registry we started with.