Securing AI agents demands a new paradigm⁠.

Every agent your teams run acts on the endpoint, so Certiv runs there too. Scroll to see what each layer of security reaches, and why Certiv sits where it does.

  1. 01 In the model

    Why not rely only on the model’s own guardrails?

    A provider’s safety controls screen what goes into and comes out of its own models, and that helps. The risk sits in what an agent does next on the endpoint, through a tool call or a local model, and those controls are blind to it. They also belong to one provider, so protection changes whenever you change models.

    Provider

    • Does: Screens jailbreak prompts
    • Does: Filters harmful model output
    • Doesn’t: See an agent’s tool calls
    • Doesn’t: Govern local models
    • Doesn’t: Stay the same when you change models
    • Doesn’t: Stop a shell command or file change
    • Doesn’t: Apply one company policy across tools
  2. 02 On the network

    Why not add a proxy or a gateway?

    A proxy or gateway inspects the traffic routed through it, a good place to watch data going to model APIs and to block unapproved AI services. It sees only traffic configured to pass through it, so local model calls, shell commands, and a laptop off the corporate network all fall outside it.

    Gateway, if routed

    • Does: Inspects data sent to model APIs
    • Does: Blocks unapproved AI services
    • Does: Reaches jailbreaks and harmful output, if routed
    • Doesn’t: See local model calls
    • Doesn’t: See shell and file actions
    • Doesn’t: Cover a laptop off the network
    • Doesn’t: Reach an agent not set to route through it
    • Doesn’t: Know what the agent set out to do
  3. 03 In the browser

    Why not add a browser extension?

    An extension can watch and control what is typed or pasted into web AI tools, and it governs browser agents inside their tabs. It sees only what happens in a browser tab, so it does not see agents on the endpoint: coding agents in the terminal, desktop agents, and local models never pass through the browser. For agents, it is not a solution.

    Browser extension

    • Does: Stops data pasted into web AI chats
    • Does: Blocks unapproved AI sites
    • Does: Governs browser agents
    • Doesn’t: See agents on the endpoint
    • Doesn’t: See a coding agent’s tool calls
    • Doesn’t: See shell commands an agent runs
    • Doesn’t: Govern local models
  4. 04 Inside each agent

    Why not add the agent’s own hooks?

    Hooks give deep, agent-native control where they exist. Coverage stops at agents that ship hooks: of 56 agents Certiv reviewed, 8 expose an admin-owned hook tier, and local open-weight setups get nothing. Hooks also tie your security to your AI vendor, so it changes when you change agents or models.

    Hooks, one vendor

    • Does: Checks one vendor’s tool and MCP calls
    • Doesn’t: Cover agents without hooks or local open-weight
    • Doesn’t: Stay the same when you change agents or models
    • Doesn’t: Hold when hooks are switched off
    • Doesn’t: Give the same answer in every agent
  5. 05 On the OS

    Why not add EDR?

    EDR is already on the endpoint and records process and file activity, which is real visibility. It sees the binary, not its role as an agent or the request behind an action, and it often acts after the action runs.

    EDR, after the fact

    • Does: Records process and file activity
    • Does: Flags suspicious processes, after the fact
    • Doesn’t: Stop an action before it runs
    • Doesn’t: Check an action against the request
    • Doesn’t: Tell an agent from any other process
    • Doesn’t: Apply one company policy across agents
  6. 06 On the endpoint

    Why on the endpoint?

    Agents run commands and call models on the endpoint, including local models and off-network laptops. Scout runs there too, at the agent’s own vantage point, so it sees the action itself, not a rebuild from proxy logs.

    On the endpoint

    • Covers: Local model calls no gateway sees
    • Covers: Shell commands no proxy sees
    • Covers: CLI tools as the logged-in user

    Gives you Coverage of every supported agent and model.

  7. 07 Certiv decision

    Why run outside the agent?

    A control inside an agent depends on that agent: its vendor, its settings, whether it ships hooks. Scout runs on the endpoint, outside every agent, so one set of rules applies to all of them and the check is one the agent does not control, even when its own approvals are switched off.

    Outside the agent

    • Covers: Agents with their own approvals off

    Gives you Rules that do not depend on any vendor’s settings.

  8. 08 Certiv decision

    Why discover every agent?

    You can only govern the agents you can see. Scout runs on the endpoint, so it knows which agents are installed and active on every device, without inferring it from network traffic. One install finds agents, local model runtimes, and shadow automation across the fleet.

    Discovery

    • Covers: Agents nobody knows are installed
    • Covers: Local model runtimes nobody knows about
    • Covers: Shadow automation across the fleet

    Gives you A view of every agent and local model runtime on every device.

  9. 09 Certiv decision

    Why one company policy?

    Each model provider governs its own models and each agent vendor its own agent, so the same task can be blocked in Claude Code and allowed in Codex. Certiv rules are written once and stay the same across supported agents, models, and providers.

    One policy

    • Covers: Actions blocked in one agent, allowed in another

    Gives you One rule, written once: the same answer whichever model or provider.

  10. 10 Certiv decision

    Why before execution?

    EDR often acts after the action runs. Scout holds each action until Sage has judged it, so a destructive step is stopped before it runs. The answer can be Redact, Pause, Allow and record, Steer, or Block.

    Before it runs

    • Covers: Destructive actions, before they run

    Gives you A stopped action instead of an alert to chase, and permitted work keeps moving.

  11. 11 Certiv decision

    Why judge the whole action?

    Sage judges each action with its context: the request behind it, the agent, its target, and the steps before it. That is how a secret read in one step and sent in the next, an action a prompt injection steered, or an action that does not match what the user asked for gets caught.

    Whole action

    • Covers: Secrets leaving through chained tools
    • Covers: Prompt-injected actions
    • Covers: Actions that don’t match the request

    Gives you Risks that no single tool call shows on its own.

  12. 12 Certiv decision

    Why model-agnostic?

    Teams move between frontier, open-weight, and local models as the options change, and a local model carries no provider safeguards. Certiv rules apply across supported models, including ones your policy has never seen, and Scout flags models whose safety training was removed.

    Any model

    • Covers: Local models with no provider safeguards
    • Covers: Abliterated models
    • Covers: Models your policy has never seen

    Gives you Room for the next model your teams pick.

  13. 13 Certiv decision

    Why keep the record?

    Each event keeps which agent acted, the command, its target, and the trace of every policy in its path, so you can show what an agent actually ran, check it against what the agent said it did, and see which rule decided it.

    The record

    • Covers: Agent “done” claims with no proof
    • Covers: Incidents with no record of what ran
    • Covers: Actions with no record of which agent acted

    Gives you Proof for an audit or an incident.

See it live

Govern agents where the work happens⁠.

Certiv discovers and enforces policy on every agent running on your endpoints, hosted, local, or in between. See it on your own agents and models.

Book a Demo

Scroll, select the disc again, or press Esc to close

Where each approach sits, least to most invasive, and what it covers
LayerApproachCatches
In the modelProviderJailbreak prompts; Harmful model output

Leaves open: Different safety rules at each provider (Certiv: One rule set across providers); Protection that resets when you switch models (Certiv: Company rules stay the same across supported models)

On the networkGatewayJailbreak prompts; Harmful model output; Sensitive data sent to model APIs; Unapproved AI services

Leaves open: Laptops off the corporate network (Certiv: Scout runs on the laptop, wherever it is); Agents not routed through the gateway (Certiv: Scout sees the agent’s own traffic and actions)

In the browserExtensionUnapproved AI services; Data pasted into web AI chats

Leaves open: Coding agents in a terminal (Certiv: Scout sees the agent on the endpoint)

Inside each agentHooksOne agent’s tool and MCP calls

Leaves open: Agents with no hooks; Policy that resets when a team switches agents (Certiv: Company rules stay the same when the agent changes); Hooks the agent can switch off (Certiv: Rules run outside the agent, so its settings do not govern them); Hook coverage that differs by agent (Certiv: One rule set, the same answer in every supported agent); The same rule written again for every agent (Certiv: Written once, applied across supported agents); Audit records each agent keeps about itself (Certiv: One record outside the agent, across agents)

On the OSEDRSuspicious processes, after the fact
On the endpointCertivJailbreak prompts; Harmful model output; Different safety rules at each provider; Protection that resets when you switch models; Sensitive data sent to model APIs; Unapproved AI services; Laptops off the corporate network; Agents not routed through the gateway; Data pasted into web AI chats; Coding agents in a terminal; One agent’s tool and MCP calls; Agents with no hooks; Policy that resets when a team switches agents; Hooks the agent can switch off; Hook coverage that differs by agent; The same rule written again for every agent; Audit records each agent keeps about itself; Suspicious processes, after the fact; Local model calls no gateway sees; Shell commands no proxy sees; CLI tools as the logged-in user; Agents with their own approvals off; Agents nobody knows are installed; Local model runtimes nobody knows about; Shadow automation across the fleet; Actions blocked in one agent, allowed in another; Destructive actions, before they run; Secrets leaving through chained tools; Prompt-injected actions; Actions that don’t match the request; Local models with no provider safeguards; Abliterated models; Models your policy has never seen; Agent “done” claims with no proof; Incidents with no record of what ran; Actions with no record of which agent acted
Certiv decisionOutside the agentAgents with their own approvals off
Certiv decisionDiscover every agentAgents nobody knows are installed; Local model runtimes nobody knows about; Shadow automation across the fleet
Certiv decisionOne company policyActions blocked in one agent, allowed in another
Certiv decisionBefore executionDestructive actions, before they run
Certiv decisionJudge the whole actionSecrets leaving through chained tools; Prompt-injected actions; Actions that don’t match the request
Certiv decisionModel-agnosticLocal models with no provider safeguards; Abliterated models; Models your policy has never seen
Certiv decisionKeep the recordAgent “done” claims with no proof; Incidents with no record of what ran; Actions with no record of which agent acted