Identity for a World Run by Agents

For most of the internet’s history, identity has been built around a simple assumption: there is a person on the other side of the login screen. We type passwords, tap security keys, approve two-factor prompts, and receive permission to enter.

AI agents break that model.

An agent might need to log into a bank account, update a CRM, access a production database, place an order, or interact with dozens of other systems on someone’s behalf. Giving it the same credentials and permissions as a human creates an obvious problem. An agent needs access to get work done, but that access has to be tightly controlled. It should be able to perform a specific task, within specific boundaries, without possessing the keys to everything around it.

That is the problem Multifactor is solving.

Identity Without Handing Over the Keys

Multifactor is building identity infrastructure designed for a world where humans and software increasingly share access to the same systems.

The company’s platform handles three fundamental questions: who or what is requesting access, what exactly should it be allowed to do, and what happened after access was granted. In security terms, that means authentication, authorization, and auditing. Multifactor has designed all three around agents from the beginning. Multifactor

Traditional identity systems were created to decide whether Chris should be allowed into Salesforce or whether an engineer can access AWS. Agents introduce a much more granular problem. An agent might need permission to read one account but not change it, generate a report but not send it, or initiate a transaction but require human approval before completing it.

And the number of these identities could grow quickly. If knowledge workers eventually have many agents operating on their behalf, companies could find themselves managing far more software identities than human ones. Some agents might persist for years. Others could exist for a single task. Each could require access to a different combination of applications, accounts, and data, with permissions that change constantly.

Multifactor’s underlying technology comes from years of cryptography research and is designed to make credentials themselves less central to the security model. Instead of handing an agent a password or session token, Multifactor can give it permission to perform specific actions while keeping the underlying credentials protected. Multifactor on YC

That becomes increasingly important as agents move from retrieving information to taking consequential actions.

Built by Cryptographers

This is the kind of security problem where the founders’ backgrounds matter enormously.

Vivek Nair started working on authentication research remarkably early. He completed his undergraduate work at UIUC before earning his Ph.D. in computer science from UC Berkeley at 22, and went on to work on cyber operations for the Department of Defense and CIA. His career has been spent thinking about authentication and security in environments where the consequences of failure can be considerably higher than forgetting a password. Multifactor founders on YC

Colin Roberts came to the problem through mathematics and cryptography. A Ph.D. mathematician and applied cryptographer who previously worked as a scientist at NASA, Colin first encountered Vivek in 2022 when Vivek presented his MFKDF research at San Francisco Blockchain Week.

Colin immediately recognized what was interesting about the work. MFKDF offered a different approach to authentication and key management, using multiple authentication factors to derive cryptographic keys rather than relying on conventional credential storage. The two began collaborating, and that underlying research eventually helped form the technical foundation for what became Multifactor. Colin Roberts on joining Multifactor

That history is what makes the team particularly compelling to us. There are plenty of companies entering agent security because the category has suddenly become important. Vivek and Colin arrived from the other direction. They had already spent years working on the underlying cryptographic and identity problems before agents made those problems urgent.

Multifactor is being built from the cryptography up by two people who have spent much of their careers thinking about trust.

When the Trust Boundary Moves

I’ve seen an identity transition like this before.

More than a decade ago, I invested in ScaleFT, one of the earliest companies built around zero-trust security. The insight at the time was that the traditional corporate perimeter was disappearing. Employees were accessing infrastructure from everywhere, and identity needed to become a new control point. ScaleFT was eventually acquired by Okta, and the ideas behind zero trust became foundational to modern enterprise security.

I think agents are creating another shift in the trust boundary.

Today, much of agent identity is being improvised. Agents inherit browser sessions, API keys, employee credentials, or broad permissions that were designed for people. That can work while companies are experimenting. It becomes much harder when agents start moving money, modifying databases, communicating with customers, changing production systems, or running real business processes.

Every useful agent eventually needs permission to do something. Companies will need to know which human or organization it represents, what systems it can access, which actions it can perform, when it needs approval, and exactly what it did afterward.

Existing identity platforms will remain critical for managing people. But we believe agents create a sufficiently different set of requirements that a new layer of infrastructure can emerge alongside them.

If Multifactor becomes that layer, it could sit between agents and the enormous collection of software, accounts, data, and services they’re being asked to operate.

Why We Invested

My experience with ScaleFT gave me a front-row seat to what happens when a new computing architecture forces the security model underneath it to change.

When I met Vivek and Colin, I saw some of the same ingredients: assumptions embedded in the existing architecture beginning to break, a rapidly expanding new attack surface, and a deeply technical team that had been thinking about the underlying problem long before the market arrived.

What made Multifactor particularly compelling was how directly the founders’ experience matched what needed to be built. Vivek has spent his career thinking about authentication in high-stakes environments. Colin is an applied cryptographer and mathematician. The technology at the foundation of the company grew directly out of years of work on authentication and cryptographic key management.

If agents are going to act across our businesses and digital lives, giving them intelligence isn’t enough. We also need a reliable way to decide what they’re allowed to do, give them only the access required to do it, and know exactly what happened afterward.

That is a new identity problem.

Multifactor is building for it.

Visit Multifactor at https://www.multifactor.com.