Skip to the content

How it works

The layers AgentGarm governs an agent through, how it correlates one task, and where each fail mode is enforced.

Processes, split by privilege

  • agentgarmd holds the policy, the keys, the hash-chained audit log and approval verification. In a root install it runs as root; in no-root mode it runs as you, and the levels below drop accordingly.
  • agentgarm-session runs as you: the loopback LLM proxy, the agentgarm run launcher and the local dashboard. It reads model traffic, so it never runs as root.
  • agentgarm-agent runs in your desktop session: the menu bar or tray, notifications and the approval prompts.

Each agent calls agentgarm-hook on its hook events, and the hook asks agentgarmd directly, so decisions keep working when the session service is down.

Layers, and what each can give

Hooks are advisory: every vendor lets the tool run when a hook times out, even an administrator's. So fail closed rests on the launcher, which will not start an agent without agentgarmd, and on the sandbox, which the kernel keeps in force for the session.

The layers, what each sees and can do, and the level it can give
LayerSeesCan doFail mode and level
Agent hooks and managed settingsThe exact tool and its arguments, before it runsAllow, deny or askFails open on the vendor's timeout. At most B; C until the agent's live run is recorded
agentgarm run: launcher, sandbox, checkpointsThe process tree, files and resourcesContain, roll backFails closed at launch. B; A only once an OS sentinel makes launching through it mandatory
Loopback LLM proxy and accountingPrompts, usage and costInspect, budgetB where the sandbox makes it unavoidable (macOS), else C
MCP gatewaypreviewJSON-RPC, schema hashes, tool callsIsolate, pin, apply flow rulesNot yet claimed
Browser shim and extensionpreviewBrowser automation and web chat inputMediate, quarantine downloads, check pastes for secretsNot yet claimed
Computer-use airbag and capture monitor (macOS)previewSynthetic clicks and keystrokes, screen captureDrop input on protected apps, pause agents that can capture the screen while a sensitive app is in front, suspend the agent if the airbag stopsNot yet claimed
OS sentinelspreviewExecutions, files, socketsA backstop beneath the agentNot yet claimed

Assurance levels

Every session carries one level, recorded on every event: the weakest level among the controls its policy relies on, and lowered for the rest of the task when a control is bypassed or degrades.

  • A, enforced: a mechanism the agent can neither disable nor make fail open, and that you cannot sidestep by starting the agent another way.
  • B, controlled: enforced for the session by the kernel or a contract the agent cannot change from inside it, but the agent could have been started outside it, or it can fail open.
  • C, observed: detection and accounting only.

Agent coverage lists each agent at its level today, generated from the adapters' data.

What “preview” means

AgentGarm is built ahead of its release gates. A feature marked preview is built and tested, but no release claims it until its gate has been passed on real use: dogfood days, nightly runs, a release. Until then the site names it and does not count on it.

Commands are parsed, never matched as strings

Policy is evaluated over parsed argv and the process lineage, not the raw command line. Anything the parser cannot read for certain, such as an expansion or a parse error, is treated as opaque, so it never matches an allow rule by accident.

One task, from start to finish

Every event is tied to the agent task that caused it: the process tree, each model call with its tokens and cost, each file the agent changed. Before a task starts, AgentGarm can checkpoint the workspace with git, so the task's changes can be rolled back.

The AgentGarm dashboard's Activity view: recent decisions with the command and the rule that decided each, model calls with their cost, alerts and MCP events, newest first.
The local dashboard's Activity, on sample data: decisions, model calls, alerts and MCP events as they happen. Open it in the demo.

Across a fleet

Central Lite preview runs the same controls across many machines. It signs policy and rolls it out in stages, collects each machine's evidence, attributes cost by developer and credential, and forwards security events to Splunk or Microsoft Sentinel. Admins sign in with a passkey or through the organisation's identity provider, each with a role, and every change they make is confirmed with their passkey. A kill order, signed by several approvers, stops agents on every machine it names; each machine checks the signatures itself before it acts.

Every machine keeps enforcing on its own: a machine that cannot reach Central keeps its last signed policy, and once that policy expires, the policy itself says whether to keep enforcing, drop to audit or deny.