Endpoint Guard
The Endpoint Guard is the HYPR endpoint client running on a managed workstation. It discovers the AI tools running there and reports what it sees under a signed device identity. For the tools you choose to manage, it makes sure their traffic reaches the HYPR AgentPass™ gateway instead of going to the provider directly.
It gives you two capabilities, each configured in the console.
| Capability | What it does | Configure it in |
|---|---|---|
| Agent Observability | Enrolls workstations and reports the AI tools they run, whether or not their traffic reaches the gateway | Enabling Agent Observability, Observation Manifest |
| Managed Desktop Tools | Routes a tool's inference through the gateway, provisions your MCP connectors into it, and blocks its direct provider egress | Managed Desktop Tools |
Platform Support
The client runs on macOS and Windows, with different components on each.
| Platform | Components | Agent Observability | Managed Desktop Tools |
|---|---|---|---|
| macOS 13 or later | A per-user background service, plus a system network extension. The extension attributes connections to the application that made them, and enforces egress blocks | Yes | Yes |
| Windows 11 | A Windows service. It also enforces egress blocks | Yes | Yes, except Claude and Codex channels |
On macOS, the client ships as a signed installer package or disk image, or with HYPR Passwordless for Mac. On Windows, it ships as a single installer that a user double-clicks or a deployment tool runs silently. It needs two values at deployment time: your gateway address, and an enrollment token from the console. Confirm packaging for your device-management tooling with your HYPR representative. Platform Support has per-capability detail.
How It Discovers an Agent
The client works from the observation manifest your organization publishes. The manifest lists tools, each described by the signals that identify it. The client recognizes a running program when any one of these signals matches:
| Signal | What it identifies |
|---|---|
| Process and executable names | The running program, such as claude or codex.exe |
| Paths | Where the program was launched from |
| Command line | Text in the command line. This is how the client recognizes an agent inside a general-purpose runtime such as Node.js or Python |
| Code signature | The code-signing identifier on macOS, or the signed publisher on Windows. High confidence, because a look-alike process cannot forge it |
| Application identity | A macOS bundle identifier, or a Windows packaged-app identity |
| Network connections | On macOS, the signed application that opened a connection to an AI provider's hosts |
| Tool events | For Cursor, the tool's own event hooks, which report each action |
The client matches the strongest signals first, and each report records which signal matched. A program that matches no tool is discarded on the workstation. It is never recorded, queued or sent.
Adding a tool to the manifest is a console change, not a client update. Workstations pick it up on their next check-in.
Discovery runs continuously while a workstation is enrolled and observation is on:
- macOS scans the signed-in user's processes every few seconds, and reports connections and Cursor hook events as they happen.
- Windows subscribes to process start and stop events.
On busy fleets, the manifest's sampling rate reports a deterministic fraction of matched activity.
What a Report Carries
Each report the client sends carries these attributes.
| Attribute | Source |
|---|---|
| Tool | The manifest tool that matched, with its display name and category |
| Owner | The user signed in to the workstation |
| Device | The enrolled workstation, established cryptographically at enrollment |
| Activity | Start, stop or action, with a timestamp and process identifiers |
| Matching signal | Which signal recognized the tool, as a measure of confidence |
| Command-line details | Arguments after redaction, and the working directory where available |
| Destination | For a network connection, the provider host reached |
Reports become rows in Discovered, tagged Endpoint. When a tool is also seen routing through the gateway, the two collapse into one Gateway + Endpoint row.
Observation never blocks a tool. A managed tool that has not been onboarded is still routed, and the connector's onboarding mode decides what happens when its traffic arrives.
How It Routes and Enforces
The gateway makes the routing decision, and the workstation applies it.
You set intent in Desktop Tools: which tools are managed, which connector each routes through, which have direct egress blocked, and how a tool behaves in an outage. The gateway resolves this into a configuration for each workstation, from platform defaults, your settings and per-device overrides.
The client adds one check the gateway cannot make: whether the tool is installed and signed in. It defers configuring a tool that is not signed in, and reports the deferral.
The client applies three controls:
- Routing configures the tool itself to send inference to your gateway. It uses an environment variable, the tool's configuration file or, for Claude Desktop on macOS, managed preferences. It prefers an enterprise-managed location. Nothing is proxied. See Routing and Observation.
- MCP provisioning adds your published MCP connectors to the tool's configuration. See Provisioning MCP Tools.
- Egress enforcement blocks the tool's direct connections to its provider hosts. On macOS, the block is scoped to the tool's code-signing identity and the listed hosts. Sign-in endpoints stay reachable. On Windows, the block applies to every process on the workstation, browsers included. See Egress Enforcement.
Routing is applied before enforcement, so a tool is never left without a path to its provider.
The client checks in every 60 seconds by default. Each check-in fetches the manifest and, in managed mode, the endpoint configuration. Before changing a tool's settings, the client backs them up, and it merges changes instead of overwriting.
Turning managed mode off, or disabling management for one device, removes the egress blocks and restores the backups on the next check-in. Managed Devices shows what was applied to each tool.
Identity and Transport
The client generates its signing key on the workstation, in the Secure Enclave or TPM where present. The private key never leaves the device. After enrollment, every call carries a short-lived signed assertion, and every activity event is a signed security event token.
The gateway verifies each signature and rejects stale or replayed events. It then reapplies your redaction rules and rate-limits each device. Rejected reports appear in the ingest-activity log.
All communication is outbound HTTPS to your gateway, and the client opens no listening ports. Revoking a workstation on the Agent Observability tab rejects its next report until it enrolls again.
Agent Observability uses the OpenID Shared Signals Framework (SSF). The gateway is the receiver, and each client is a transmitter of signed events. To build your own client, ask your HYPR representative for the endpoint-client integration guide.
What Is Not Collected
The client limits what it collects:
- No prompts, model responses, file contents or network payloads. The network extension sees only encrypted connections.
- Only tools in your manifest and, on macOS, only the signed-in user's processes.
- Command-line arguments are redacted on the workstation under your manifest's redaction rules. The working directory is truncated to the depth you allow.
- Cursor hook events are reduced to the event name, working directory, conversation identifier and redacted command.
- The enrollment token, signing key and report contents are never written to the client's logs.
Related
- Enabling Agent Observability — enroll workstations and manage them
- Managed Desktop Tools — route, provision and enforce the tools the client discovers
- Discovering Unmanaged Agents — where endpoint-observed activity appears