HYPR's AgentPass Ties Every AI Agent Action to a Named Human
HYPR launched AgentPass on November 18: an identity-first control plane that gives AI agents no standing access, short-lived tool-scoped tokens, and requires passkey human approval before sensitive actions run.

Why it matters
- HYPR launched AgentPass on November 18; the platform is available now.
- Agents start with zero standing access and receive only short-lived tokens scoped to individual tools.
- The platform names Claude Code, Codex, and Cursor among coding tools it discovers and governs on enrolled Windows and macOS workstations.
- Controls include passkey-based approval, remote shutdown, plain-English policies, and an observation mode; a disabled agent's next request is refused mid-session.
- Disabling an agent cannot undo an action already taken — enforcement happens before execution.
HYPR launched AgentPass on November 18, a security platform that gives each autonomous AI agent a distinct identity tied to a verified human supervisor and checks proposed actions before they execute. The product is available now, according to the company. It targets a problem that grows more consequential as workplace AI shifts from answering questions to operating software: deciding not just what an agent can do, but whose authority it is using.
The stakes are real for enterprises. Coding assistants and autonomous agents now touch repositories, terminals, and connected services, often outside centrally purchased software catalogs. HYPR's answer is to make agent deployment an identity and authorization problem — with a control plane that sits between the model and the tools it wants to use.
What does AgentPass actually do?
HYPR describes AgentPass as an identity-first control plane for agents. In its launch briefing, the company says the platform can:
- Discover coding tools on developer workstations
- Apply access policies to those tools
- Request human approval for sensitive actions before they run
- Let supervisors stop agents remotely
The starting point is a distinction the industry has mostly blurred: a person using an application versus software acting on that person's behalf. A shared service account or a developer API key may grant access, but it doesn't explain which agent initiated an operation or which person answers for it. AgentPass gives agents their own identities, each linked to a verified supervisor.
The takeaway: AgentPass tries to make the human-agent relationship operational, not just a label in a dashboard.
How does the access model work?
According to HYPR, agents begin with no standing access at all. The architecture works like this:
- Permitted tools follow the supervisor's organizational role
- Credentials stay inside a governed gateway — they are never handed directly to the agent
- Access comes through short-lived tokens scoped to a single tool
- A supervisor's role change affects the agent's permissions
- Offboarding blocks subsequent requests
That design means the governing question shifts from "did somebody approve this agent's installation weeks ago?" to "does this agent's current authority match the work it's trying to do right now?" The permission follows the person, and the person's employment status follows the organization.
The takeaway: authority expires and tracks the supervisor's role, rather than living forever inside a copied API key.
Which tools does it cover — and where?
HYPR's briefing names Claude Code, Codex, and Cursor among the coding tools AgentPass is built to discover and govern. The launch announcement specifies enrolled Windows and macOS workstations, where administrators can route supported tools through the gateway and block bypass paths. The platform also covers sub-agents launched by coding agents.
The endpoint focus matters because an enterprise's agent inventory rarely confines itself to centrally deployed cloud services. Developers pull assistants into local workflows on their own machines, where those tools interact with source code and connected systems. Governing that activity requires visibility into what is actually running — not a list of centrally purchased applications.
One qualification deserves attention. Discovery and enforcement are different capabilities. Finding a tool establishes that it exists; controlling its behavior requires a supported integration and a path the agent can't simply route around. HYPR's own description distinguishes discovered software from supported tools that administrators select for gateway routing — an important caveat for anyone assessing deployment coverage.
The takeaway: knowing an agent exists and controlling what it does are separate claims, and buyers should read them separately.
Where does the human come in?
HYPR says administrators can write policies in plain English and use them to allow, block, or escalate agent actions. Two controls sit at the center:
- Passkey-based human approval for sensitive actions
- Remote shutdown of an agent
The release also adds an observation mode for testing policies before enforcement kicks in. Once an agent is disabled, its next request is refused — including within a session that's already running.
The timing distinction here is significant. Stopping the next request is not the same as undoing an earlier action. Once an agent has sent a message or modified a system, disabling its access doesn't reverse that outcome. Controls placed before execution serve a different purpose from monitoring that reports a problem afterward.
Approval quality is the other hard part. Requiring permission for every trivial operation undermines the usefulness of automation, while broad approval can hide consequential changes inside routine workflows. A workable policy has to separate low-risk preparation from actions that commit the organization, expose information, or change important systems.
The takeaway: the kill switch works at the action boundary, not retroactively — which is exactly why the pre-execution approval step carries the load.
Why does this matter beyond one product?
AgentPass reflects a broader architectural shift in enterprise AI: agent deployment is becoming an identity and authorization problem as much as a model-selection problem. The model may propose an action, but a separate system can decide whether that particular agent has permission to carry it out.
This separation has limits, and HYPR's framing doesn't overclaim them. It doesn't establish that an agent's output is correct. It doesn't guarantee every integration is covered. It doesn't make security incidents impossible. What it provides is a place to enforce boundaries outside the model itself — which still requires clear ownership, sensible permissions, and review processes people can realistically operate.
For enterprise AI, the practical opportunity is making autonomy more selective. Agents handle routine work within defined limits while humans retain control over consequential steps. HYPR has put that accountability layer at the center of its agent-security proposition, treating supervision as core infrastructure rather than an optional feature added after deployment.
The open question for buyers is coverage: how many of the tools their developers actually run will fall inside the gateway's supported integrations, and how reliably bypass paths stay blocked. The takeaway: accountability for AI agents is becoming something you install, not something you hope for.
Source: unite.ai
More from Sophie Lindqvist
Show full bio
Staff writer covering regulation, policy and their impact on artificial intelligence and machine learning at AI In Context.
777 articles
Related articles
- IBM Buys AuthMind to Watch What AI Agents Do After They Log In
- 83% of Firms Run Unapproved AI Coding Agents, BlueFlag Research Finds
- Airlock Digital adds action-level controls for Codex and Claude
- Cato Networks Launches AgentSense to Block AI Agent Attacks
- 87% of Enterprise Developers Use Low-Code. That Is the Agent Security Problem