Support matrix

Which AI coding agents and DefenseClaw features work on Linux, macOS and Windows, in the open-source and enterprise editions, and what live tests verified.

This page shows whether DefenseClaw protects your agent on your operating system, which features each edition has, and how the enterprise edition attaches to each agent. Every Supported cell was verified by a live test. Everything else is labeled.

Supported
Verified by live tests in this release
Preview
In the code, not verified live in this release
Not supported
The code refuses it on that OS or edition
Not offered
Not part of that edition
  • Open source is the per-user install: one command, and each user runs their own DefenseClaw. Start with Install.
  • Enterprise is the managed standalone profile an administrator deploys with a package or an MDM. Users can't turn it off. Start with Deploy to a fleet. The Secure Client profile is covered in Secure Client managed deployment.

Agents

Supported means a live test on that OS verified the agent's hooks and a block before the tool call ran. A cell says so when the agent's telemetry to Grafana and Galileo wasn't verified there. Switch to Enterprise for the managed edition. Select an agent for its setup page.

AI coding agents by operating system, open-source edition
AgentLinuxx86_64, arm64macOSApple siliconWindowsx64Min versionlowest tested
Claude CodeNative hooks
Supported
Supported
Supported
2.1.154
CodexNative hooks
Supported
Supported
Supported
0.124.0
GitHub Copilot CLINative hooks
Supported
Supported
Supported
1.0.18
CursorNative hooks
Supported
Supported
Supported
2.4.0
DevinNative hooks
Supported
Supported
Supported
3000.4.25
AntigravityNative hooks
Supported
Supported
Supported
1.1.8
KiroNative hooks
Supported
Supported
Supported
kiro-cli 2.27.1; Kiro IDE 1.0.182
OpenCodePlugin
Supported
Supported
Supported
2.0.0
AmpPolicy plugin
Supported
Supported
Supported
0.0.1785334225
HermesNative hooks
Supported
Supported
Supported
0.19.0
Version and platform notes
Claude Code
Windows: Native executable hooks. WSL is outside the native contract.
Codex
Windows: System PowerShell bridge to the packaged hook executable.
GitHub Copilot CLI
Windows: Uses Copilot CLI's PowerShell hook field.
Cursor
Cursor Desktop 2.4.0 up to 4.0.0. The Cursor Agent CLI is covered only at the reviewed build 2026.07.23-e383d2b. Windows: Managed PowerShell adapter.
Devin
Reviewed Devin CLI 3000.4.25 on every OS and 3000.11.3 on Linux; newer builds run as untested newer versions. Windows: Devin's own hook runner starts the protected hook executable directly; no PowerShell bridge.
Antigravity
Windows: Packaged PowerShell hook launcher.
Kiro
Below 2.27.1, kiro-cli has non-interactive --v3 runs that load no hooks, and an IDE before 1.0.182 cannot read global hooks. Per-user and managed setup refuse an older kiro-cli or an older IDE, in every guardrail mode, when no supported Kiro form is installed beside it. A Kiro form whose version could not be read is unknown and not protected: action setup refuses it unless a supported form is installed, and doctor and managed status report it. Managed status reports a below-floor product as uncovered and verify fails. Earlier managed CLI enrollments keep their interactive hooks across upgrade until updated. A supported Kiro IDE can be enrolled beside an older CLI.
OpenCode
V2-only contract covers 2.0.0 up to 2.3.0. Version 2.2.5 was checked live on Linux, macOS and native Windows in per-user and managed installs; 2.2.3 and 2.2.4 were checked on selected platforms. Newer V2 minors are untested; V1 and unversioned git builds are refused.
Amp
Windows: Owner-only TypeScript plugin in the user plugin directory.
Hermes
Contract covers 0.19.0 up to 0.22.0. Before 0.21.1 the TUI (hermes --tui) and dashboard chat run tools without the hooks; setup and doctor warn. Windows: Hermes' own terminal tool needs its bundled Git Bash.

The connector contract behind each row (block events, native ask, fail closed, sandbox tier) is on the capability matrix. Exact version ranges are on Hook contracts.

Features

DefenseClaw features by edition and operating system
FeatureOpen sourceEnterprise
LinuxmacOSWindowsLinuxmacOSWindows
Protect
Guardrails: observe, action, blockSupportedSupportedSupportedSupportedSupportedSupported
Policy and rule packsSupportedSupportedSupportedSupportedSupportedSupported
CodeGuardEnterprise: part of the local policy engine in the standalone profile.SupportedSupportedSupportedPreviewPreviewPreview
Skill scannerSupportedSupportedPreviewSupportedSupportedPreview
MCP scannerSupportedPreviewSupportedSupportedSupportedPreview
LLM judgeSupportedSupportedPreviewPreviewPreviewPreview
Redaction profilesSupportedSupportedPreviewNot offeredNot offeredNot offered
OpenShell sandboxesLinux and macOS only. A standalone managed install runs sandboxes under the policy of the person’s directory group; Windows is refused. See Sandboxes on managed computers.PreviewPreviewNo: Not supportedSupportedSupportedNo: Not supported
ACP guard (Kiro, Zed)Per-user install, or enterprise managed mode through `enterprise acp enroll` (preview, not yet verified live).PreviewSupportedPreviewPreviewPreviewPreview
Discover
AI discoverySupportedSupportedSupportedSupportedSupportedPreview
Runtime discoverySupportedSupportedSupportedSupportedSupportedPreview
Tool inventorySupportedSupportedSupportedNot offeredNot offeredNot offered
Plugin inventory and scanPreviewSupportedSupportedNot offeredNot offeredNot offered
RegistriesPreviewSupportedSupportedNot offeredNot offeredNot offered
AIBOMSupportedPreviewPreviewNot offeredNot offeredNot offered
Observe
OpenTelemetry export (Grafana)SupportedSupportedSupportedSupportedSupportedSupported
GalileoSupportedSupportedSupportedSupportedSupportedSupported
SplunkNeeds a Splunk Observability Cloud organization, and Terraform for the dashboards.PreviewPreviewPreviewPreviewPreviewPreview
Local observability stackNeeds Docker.SupportedSupportedPreviewNot offeredNot offeredNot offered
AlertsSupportedSupportedSupportedNot offeredNot offeredNot offered
WebhooksSupportedSupportedSupportedPreviewPreviewPreview
Audit log and exportSupportedSupportedPreviewPreviewPreviewPreview
Operate
InstallOpen source: the one-line installer. Enterprise: the .rpm, .pkg or Setup.exe package.SupportedSupportedSupportedSupportedSupportedSupported
UpgradeSupportedSupportedSupportedSupportedSupportedSupported
UninstallSupportedSupportedSupportedSupportedSupportedSupported
Health check and repairOpen source: doctor. Enterprise: verify and repair.SupportedSupportedSupportedSupportedSupportedSupported
Keys and secretsEnterprise: the Cisco AI Defense key is a protected credential only the gateway service can read.SupportedSupportedSupportedPreviewPreviewPreview
Terminal UISupportedSupportedSupportedNot offeredNot offeredNot offered
macOS menu-bar appNot offeredPreviewNot offeredNot offeredNot offeredNot offered
Enterprise controls
Machine policy for agent hooksNot offeredNot offeredNot offeredSupportedSupportedSupported
Tamper resistanceStandard users can’t turn DefenseClaw or its hooks off.Not offeredNot offeredNot offeredSupportedSupportedSupported
Multi-user enroll and revokeNot offeredNot offeredNot offeredSupportedSupportedSupported
Foreign-hook guardNot offeredNot offeredNot offeredSupportedSupportedPreview
MDM deploymentIntune, Jamf, Iru (formerly Kandji), Workspace ONE, ConfigMgr and Linux configuration management. Verified by simulating the MDM run context; the recipes have not been run in a live MDM tenant.Not offeredNot offeredNot offeredSupportedSupportedSupported

Protect

  • Guardrails: observe, action, block
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • Policy and rule packs
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • CodeGuardEnterprise: part of the local policy engine in the standalone profile.
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxPreviewmacOSPreviewWindowsPreview
  • Skill scanner
    Open source
    LinuxSupportedmacOSSupportedWindowsPreview
    Enterprise
    LinuxSupportedmacOSSupportedWindowsPreview
  • MCP scanner
    Open source
    LinuxSupportedmacOSPreviewWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsPreview
  • LLM judge
    Open source
    LinuxSupportedmacOSSupportedWindowsPreview
    Enterprise
    LinuxPreviewmacOSPreviewWindowsPreview
  • Redaction profiles
    Open source
    LinuxSupportedmacOSSupportedWindowsPreview
    Enterprise
    LinuxNot offeredmacOSNot offeredWindowsNot offered
  • OpenShell sandboxesLinux and macOS only. A standalone managed install runs sandboxes under the policy of the person’s directory group; Windows is refused. See Sandboxes on managed computers.
    Open source
    LinuxPreviewmacOSPreviewWindowsNo: Not supported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsNo: Not supported
  • ACP guard (Kiro, Zed)Per-user install, or enterprise managed mode through `enterprise acp enroll` (preview, not yet verified live).
    Open source
    LinuxPreviewmacOSSupportedWindowsPreview
    Enterprise
    LinuxPreviewmacOSPreviewWindowsPreview

Discover

  • AI discovery
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsPreview
  • Runtime discovery
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsPreview
  • Tool inventory
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxNot offeredmacOSNot offeredWindowsNot offered
  • Plugin inventory and scan
    Open source
    LinuxPreviewmacOSSupportedWindowsSupported
    Enterprise
    LinuxNot offeredmacOSNot offeredWindowsNot offered
  • Registries
    Open source
    LinuxPreviewmacOSSupportedWindowsSupported
    Enterprise
    LinuxNot offeredmacOSNot offeredWindowsNot offered
  • AIBOM
    Open source
    LinuxSupportedmacOSPreviewWindowsPreview
    Enterprise
    LinuxNot offeredmacOSNot offeredWindowsNot offered

Observe

  • OpenTelemetry export (Grafana)
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • Galileo
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • SplunkNeeds a Splunk Observability Cloud organization, and Terraform for the dashboards.
    Open source
    LinuxPreviewmacOSPreviewWindowsPreview
    Enterprise
    LinuxPreviewmacOSPreviewWindowsPreview
  • Local observability stackNeeds Docker.
    Open source
    LinuxSupportedmacOSSupportedWindowsPreview
    Enterprise
    LinuxNot offeredmacOSNot offeredWindowsNot offered
  • Alerts
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxNot offeredmacOSNot offeredWindowsNot offered
  • Webhooks
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxPreviewmacOSPreviewWindowsPreview
  • Audit log and export
    Open source
    LinuxSupportedmacOSSupportedWindowsPreview
    Enterprise
    LinuxPreviewmacOSPreviewWindowsPreview

Operate

  • InstallOpen source: the one-line installer. Enterprise: the .rpm, .pkg or Setup.exe package.
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • Upgrade
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • Uninstall
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • Health check and repairOpen source: doctor. Enterprise: verify and repair.
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • Keys and secretsEnterprise: the Cisco AI Defense key is a protected credential only the gateway service can read.
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxPreviewmacOSPreviewWindowsPreview
  • Terminal UI
    Open source
    LinuxSupportedmacOSSupportedWindowsSupported
    Enterprise
    LinuxNot offeredmacOSNot offeredWindowsNot offered
  • macOS menu-bar app
    Open source
    LinuxNot offeredmacOSPreviewWindowsNot offered
    Enterprise
    LinuxNot offeredmacOSNot offeredWindowsNot offered

Enterprise controls

  • Machine policy for agent hooks
    Open source
    LinuxNot offeredmacOSNot offeredWindowsNot offered
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • Tamper resistanceStandard users can’t turn DefenseClaw or its hooks off.
    Open source
    LinuxNot offeredmacOSNot offeredWindowsNot offered
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • Multi-user enroll and revoke
    Open source
    LinuxNot offeredmacOSNot offeredWindowsNot offered
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported
  • Foreign-hook guard
    Open source
    LinuxNot offeredmacOSNot offeredWindowsNot offered
    Enterprise
    LinuxSupportedmacOSSupportedWindowsPreview
  • MDM deploymentIntune, Jamf, Iru (formerly Kandji), Workspace ONE, ConfigMgr and Linux configuration management. Verified by simulating the MDM run context; the recipes have not been run in a live MDM tenant.
    Open source
    LinuxNot offeredmacOSNot offeredWindowsNot offered
    Enterprise
    LinuxSupportedmacOSSupportedWindowsSupported

Not offered in the enterprise columns means the feature is a per-user command. The enterprise packages don't install the per-user defenseclaw CLI, and a managed computer offers a standard user only the commands in Managed command availability. The administrator configures the managed gateway through its config instead.

Enterprise

In the enterprise edition DefenseClaw attaches to each agent in one of two ways:

  • Machine policy. DefenseClaw's hooks sit in the agent vendor's administrator-owned policy files, which apply to every user of the computer. See Machine policy.
  • Per-user. The guardian writes DefenseClaw's hook or plugin into each enrolled user's own agent config and repairs it if it changes. See Enrollment.

Enterprise managed mode supports ACP editors through enrollment: an administrator runs /opt/defenseclaw/bin/defenseclaw-gateway enterprise acp enroll (/opt/cisco/defenseclaw/bin/defenseclaw-gateway on macOS) for each user, editor and agent, and the user runs the setup command it reports (ACP guard). It is built and unit-tested but has not passed a live round in this release, so it is marked preview.

AI coding agents by operating system, enterprise edition, with the route DefenseClaw uses
AgentLinux.rpmmacOS.pkgWindowsSetup.exe
Claude CodeNative hooks
SupportedMachine policy
SupportedMachine policy
SupportedMachine policy
CodexNative hooks
SupportedMachine policy
SupportedMachine policy
SupportedMachine policy
GitHub Copilot CLINative hooks
SupportedMachine policy
SupportedMachine policy
SupportedMachine policy
CursorNative hooks
SupportedMachine policy
PreviewMachine policy
SupportedMachine policy
DevinNative hooks
SupportedPer-user
SupportedPer-user
SupportedPer-user
AntigravityNative hooks
SupportedPer-user
SupportedPer-user
SupportedPer-user
KiroNative hooks
PreviewPer-user
PreviewPer-user
SupportedPer-user
OpenCodePlugin
SupportedMachine policy
SupportedMachine policy
SupportedMachine policy
AmpPolicy plugin
SupportedPer-user
SupportedPer-user
SupportedPer-user
HermesNative hooks
SupportedPer-user
SupportedPer-user
SupportedPer-user
Route notes
Kiro
Editors that start Kiro over ACP are enrolled with `defenseclaw-gateway enterprise acp enroll` (preview).
OpenCode
Machine policy through the managed OpenCode plugin that the standalone package installs; per-user when that plugin is missing.

Claude Cowork

Claude Cowork is the agent mode of Claude Desktop. It is a surface of the Claude Code connector, not a connector of its own. The 1.0.8 tests ran Cowork on managed macOS and Windows with Claude Desktop 4.16336.0 (engine 2.1.317) using third-party inference through Amazon Bedrock. The per-user route (defenseclaw setup cowork) was also run on macOS and Windows, and in action mode a deny rule blocked a Cowork shell command on both. On Linux the managed drop-in and per-user setup were verified, but Cowork itself was not run.

RouteLinuxmacOSWindows
Per user (open source): defenseclaw setup cowork and an account pluginPreviewSupportedSupported
Managed computer (enterprise standalone): the Claude Code machine policy drop-inPreviewSupportedSupported

Supported means a live Cowork task reached the gateway with surface cowork and a deny rule blocked a call on that OS. Preview on Linux means the code allows the route and the setup was checked, but no Cowork task ran: Claude Desktop for Linux is a beta, and Cowork on Linux is not certified.

CapabilityOpen source (per user)Enterprise (standalone)Status
Prompt and tool-call hooksdefenseclaw setup cowork (per-user only) and an account pluginThe Claude Code machine policy drop-inMeasured on managed macOS and Windows: Cowork's hook calls reach the gateway with surface cowork, and an administrator deny rule blocks mcp__workspace__bash. Cowork was not run on Linux
Shell and fetch mappingYesYesReplay-tested against the Bash verdicts. The save_skill input was captured live. suggest_plugin_install was not called, and the browser tools are not offered in the tested third-party build
allowManagedHooksOnlyNot applicableOn by default, set with managed_hooks_onlyMeasured on managed macOS: under enforce an organization plugin's hooks did not run, under preserve they did, and DefenseClaw's hooks ran under both. Windows not measured yet
AI Discovery of Claude Desktop and CoworkYesYesThe macOS folders and the Windows MSIX folders were measured on Claude Desktop 4.16336.0. Some Windows and Linux folders are unmeasured, see AI Discovery

Cowork's web fetch runs on Anthropic's side, and the VM shell goes through Anthropic's proxy, so host egress controls do not see either. The Cowork surface is caller-reported. Limits has the detail.

Kernel sensor (Tetragon)

On managed Linux, the enterprise sensor helper can use the Tetragon that the computer already runs. Verified means the live round passed on that platform with the release build. Expected, not verified means the feature is built for it and has not yet passed a live round with the release build there. No platform is verified yet: lab rounds ran on RHEL 9 with Tetragon 1.7.1 in all three modes, and the verification of the release build is still open.

PlatformTetragon 1.7.xTetragon 1.6.x
RHEL 9, x86_64Consume, observe and enforce. Expected, not verified yet: the lab rounds ran with Tetragon 1.7.1, but the release build is not verifiedConsume only. Expected, not verified
Ubuntu 22.04 and 24.04Consume only. Expected, not verifiedConsume only. Expected, not verified
arm64Consume only. Expected, not verifiedConsume only. Expected, not verified
RHEL 8 (kernel 4.18)Not supported. Plane C uses cn_proc and fanotifyNot supported
macOS, WindowsNot available: Tetragon has no agent for either. The setting is accepted and ignoredNot available

The open-source per-user install and the Secure Client profile never connect to Tetragon. See Agent segmentation, visibility and enforcement for what the kernel controls add and do not add, and Tetragon on a Linux fleet for the setup.

Platforms

Platforms and where each edition was verified
OSArchitecturesOpen source verified onEnterprise verified on
Linuxx86_64, arm64RHELRHEL (.rpm). The .deb is built but not certified in this release
macOSApple siliconmacOS on Apple siliconmacOS on Apple silicon (.pkg)
Windowsx64Windows x64Windows x64 (Setup.exe)

Intel Macs aren't supported, and Windows is x64 only. The full requirements are on Install and, for the enterprise packages, under Requirements on the Windows, Linux and macOS pages.

Agents that connect through the guardrail proxy aren't part of this matrix. Their pages are listed under Connectors.

Known limits

These are the agent, operating system, local Splunk bridge, sandbox, upgrade and policy limits that DefenseClaw cannot remove.

1.0.7 deterministic reader limits

The deterministic hook reader covers common command forms. The optional LLM judge is the second layer for the remaining forms below. These limits apply to the rule layer in 1.0.7; a managed host's operating-system controls still apply independently.

RulingLimit
GAP-0347, GAP-0354On Windows, statements after a subexpression prefix and junction references inside a Bash wrapper are outside the reader's proof.
GAP-0350A long script can exceed the self-protection reader's bounded analysis.
GAP-0339, GAP-0391Some archive entries and later file moves cannot be tied together by the deterministic archive proof.
GAP-0355, GAP-0390A path held in a shell variable populated by read is not fully resolved through a later write or copy, including on managed macOS.
GAP-0367, GAP-0425A PowerShell scriptblock or leading unquoted call, and a shell function defined in an && list after a directory change, can hide later statements from the reader.
GAP-0429Case modification or pattern substitution used as a redirect target is outside the reader's proof.
GAP-0372Two ordinary copy commands with options and a dynamic destination can still be refused because the destination cannot be proved. Run them yourself or name a fixed destination.

Long PowerShell pipelines now receive the same bounded treatment as POSIX pipelines and can be refused when the reader cannot prove the full command. The GAP-0379 MCP refusal wording can still be less specific than the underlying reason; a refusal remains a refusal. See Fail modes for what the agent receives.

Other 1.0.7 limits

  • GAP-0327: On macOS per-user installs, idle gateway memory can grow gradually with the audit store. Retention bounds the store, but does not immediately return all memory; see Local history.
  • GAP-0482: On per-user Windows, a redirect to a network share that responds slowly can receive a conservative reader decision. Check the destination and retry from a terminal when appropriate.
  • GAP-0495: On per-user Windows, replacing the DefenseClaw home with a junction can leave the copied launcher unable to start doctor, setup or status. Restore a regular home folder before rerunning the command; the gateway refuses to start in this state. See Windows paths.
  • GAP-0519: Per-user Linux performance budgets were measured on x86 hosts with four vCPUs. A two-vCPU arm64 host can exceed hook latency and command-time budgets while remaining inside memory and restart bounds.
  • GAP-0524: During a sustained per-user Windows hook flood, some calls can lack a completed audit row even when the agent received a decision. See Audit completeness.

Claude Code shell

Claude Code does not run its hook for a command you type with ! in shell mode. DefenseClaw's hook cannot inspect or block that command, so there is no hook decision and no hook audit row for it. This applies on every OS, to per-user and managed installs, in observe and action mode. On managed Linux the Tetragon runtime layer can still record it (hook_seen=false), see Coverage by layer. It is a Claude Code limit: shell mode runs no PreToolUse hook. Use a normal Claude Code tool action when you need DefenseClaw to check a command. See Claude Code.

Codex

  • Cleanup refused by Codex: Codex's own command check can refuse a shell command that contains rm -f or rm -rf, even for build output inside your project. Codex shows rm -f style commands are not permitted. Use a safer approach and skips that step. This was seen on Linux with per-user and managed installs, in observe mode. It is a Codex limit, not a DefenseClaw block: DefenseClaw does not write this message, and its audit records the call as allowed with no DefenseClaw rule. Run the cleanup yourself in a terminal.
  • Stopped or timed-out pre-tool hook: Codex runs the tool when its PreToolUse hook is stopped, killed or times out. This is how Codex hooks work. If the hook stopped before it reached the gateway, DefenseClaw makes no decision and writes no pre-tool audit row. If it reached the gateway first, the gateway can still record the call, but Codex never gets the answer and runs the tool anyway. On a managed computer, status and verify report hook_process_fail_open and security_complete: false while Codex is enabled. Application control or EDR that stops users from signalling hook processes keeps them from stopping the hook. It does not prevent a timeout: Codex has no setting to deny a call on timeout, and its 30-second hook timeout only bounds the wait. See Vendor limits.
  • First session after Codex sets up its sandbox on Windows: the first Codex session after Codex sets up its sandbox (the Sandbox ready step) can refuse every shell command with approval required by policy, but AskForApproval::Granular.sandbox_approval is false. Codex does this with or without DefenseClaw: DefenseClaw allows the call, then Codex refuses it. It is a Codex limit. Quit Codex and start it again once; later sessions run commands normally.
  • Shared daemon keeps its model key: a running Codex app-server daemon keeps the model credential it started with. After you change or renew the key (for example a short-term Bedrock key), Codex calls fail with 401 until the daemon restarts. DefenseClaw's hooks still allow the calls. It is a Codex limit. Run codex app-server daemon restart from a shell that has the new key.
  • defenseclaw status inside an agent sandbox: inside an agent's sandbox (for example Codex's workspace sandbox on Linux), defenseclaw status shows Config check: not run because the sandbox hides who owns your folders. Your config is not invalid; run defenseclaw status in a normal terminal to check it.

See Codex.

Copilot CLI

  • Permission request not delivered: Copilot CLI can fail to deliver a tool's permission request, most often after a long model turn. The tool call fails with Session host did not acknowledge permission.requested delivery within 5 seconds and the turn stops. Esc and Ctrl+C may not end it. This was seen on Linux with Copilot CLI 1.0.98 in a session that had no DefenseClaw hook, so DefenseClaw gave no verdict. It is a Copilot CLI limit. Ask again; if the session stops responding, quit Copilot and start a new session.
  • Timed-out or failed pre-tool hook: Copilot CLI runs the tool when its preToolUse hook times out or cannot start, even when DefenseClaw's fail mode is closed. This is how Copilot CLI hooks work, and it applies to per-user and managed installs on every OS. If the hook never reached the gateway, DefenseClaw makes no decision and writes no pre-tool audit row. If it reached the gateway first, the gateway can still record the call, but Copilot CLI runs the tool anyway. A later permission hook may still deny the call on some releases; Copilot CLI 1.0.91 did in a managed Linux test. Check each new release. On a managed computer, status and verify report hook_process_fail_open and security_complete: false while Copilot is enabled. See Vendor limits.

See GitHub Copilot CLI.

Antigravity

Antigravity can run a tool when its PreToolUse hook times out or cannot start, even when DefenseClaw's fail mode is closed. Antigravity documents no setting to deny a call in that case. This applies to every install on every OS that the connector supports. If the hook never reached the gateway, DefenseClaw makes no decision and writes no pre-tool audit row. If it reached the gateway first, the gateway can still record the call, but Antigravity runs the tool anyway. A stopped-hook test blocked the call in one tested build, but that is not a vendor promise. On a managed computer, status and verify report hook_process_fail_open and security_complete: false while Antigravity is enabled. See Antigravity.

Local Splunk

The local Splunk bridge works only with an x86_64 Docker engine, because the Splunk container image it runs is published for x86_64 (amd64) only. This is a Splunk image limit. On ARM64, use --enterprise with an existing Splunk HTTP Event Collector (HEC) endpoint. See Send to Splunk.

Managed Linux and macOS scans

The managed Linux and macOS packages (rpm, deb and pkg) install the skill, MCP and plugin scanners. An administrator runs them through the managed gateway, for example sudo /opt/defenseclaw/bin/defenseclaw-gateway scan skill PATH on Linux or sudo /opt/cisco/defenseclaw/bin/defenseclaw-gateway scan skill PATH on macOS. Two limits apply:

  • The gateway service cannot read home folders (on Linux /home and /root; on macOS /Users and /var/root) and, on Linux, temporary folders (/tmp, /var/tmp and /run/user). On macOS a folder in /tmp is scanned. Copy the folder somewhere every account can read, such as /opt/defenseclaw-scan, and scan the copy. The command names the folder it refuses.
  • A deployment installed from the payload archive (enterprise linux install --payload or enterprise macos install --payload) has no scanners. There, scan skill, scan mcp and scan plugin exit 3 and scan nothing. Install the package instead.

Standard users add MCP servers through the agent's own MCP configuration. See Scan a skill.

Managed macOS private agent scan

On managed macOS the scan of an account's private agent installs does not open the folders macOS privacy protection holds for a background service: Desktop, Documents, Downloads, Movies, Music, the Photos library, and the Mail, Messages, Safari and other personal-data folders under ~/Library. On macOS 15.8 the managed scan also skips these folders in each account, because macOS holds them for a background service without a GUI session: ~/Library/Accounts, AppleMediaServices, Assistant/SiriVocabulary, Autosave Information, ContainerManager, CoreFollowUp, DoNotDisturb, DuetExpertCenter, IntelligencePlatform, PersonalizationPortrait, Photos, Shortcuts, StatusKit, Trial, Weather, com.apple.aiml.instrumentation; ~/Library/Application Support/DifferentialPrivacy, FaceTime, FileProvider, com.apple.sharedfilelist; ~/Library/Caches/CloudKit, com.apple.HomeKit, com.apple.Safari, com.apple.ap.adprivacyd, com.apple.containermanagerd, com.apple.homed. An agent copy kept in one of them is not found and not reported. This is a macOS limit.

Scanners on macOS

On macOS, the skill, MCP and plugin scanners DefenseClaw starts run as you, with a timeout, and DefenseClaw ends the processes they start when the scan ends. A scanner process that detaches itself completely from the scan between DefenseClaw's process checks can escape that tracking and keep running after the scan and after defenseclaw-gateway stop. macOS gives an unprivileged program no race-free way to follow every process its children start. This is a macOS limit. Use scanners you trust, and end a leftover scanner process yourself (Activity Monitor or ps -U $USER shows it).

Hook floods on Windows

On Windows, every hook decision adds about 40 KiB to the account's audit database (audit.db), and a sustained flood of tool calls (an agent loop or script that makes several calls a second for minutes) grows it for as long as the flood runs. In 1.0.5 tests on Windows Server 2025, 1,800 calls at 4 a second added 74 MB and 2,400 calls at 10 a second added 98 MB; every call was answered and allowed. Windows writes the database to disk more slowly than Linux and macOS, so on a disk with slow scattered writes the write-ahead log (audit.db-wal) can also pass its 256 MiB alarm and hook answers can take seconds (Local history). A call the gateway took but did not answer in time is blocked in every policy tier, never let through: a per-user hook says this account's gateway did not answer in time (it may be restarting or busy), a managed hook reports enterprise_managed_gateway_no_answer. This is a Windows disk-write limit. Slow the loop down or batch its work, and keep enough free disk for the flood. Retention deletes events older than observability.local.retention_days (default 7) and frees their space; the defenseclaw.sqlite.wal.bytes metric shows the log size.

On a per-user install on Windows, the gateway answers about 30 tool calls a second without blocking benign calls on a host with 16 vCPUs, and it stops keeping up near 40. In 1.0.5 tests on Windows Server 2025 with four other processes forcing writes to the same disk, 10 calls a second for 15 minutes (9,000 calls) and 20 a second for 3 minutes were all answered and allowed. At 30 a second, 13 of 5,400 calls were blocked, all in the first two seconds of the burst. At about 40 a second the host ran out of CPU and calls were blocked with this account's gateway did not answer in time (it may be restarting or busy) until the load dropped. Each call costs about a third of a CPU second on the host, mostly for starting the hook processes, so a host with fewer cores keeps up with fewer calls. Interactive sessions are far below these rates. Keep automated loops under 30 calls a second, and lower on a smaller host.

After a long flood the gateway on Windows keeps much of the memory the flood used. In a 1.0.6 test on Windows Server 2025 (18,000 calls at 10 a second for 30 minutes), the working set of the gateway grew from about 100 MB to about 650 MB, fell to about 480 MB once the calls stopped, and stayed there for the next 10 minutes. On Linux it returns to within about 50 MB of its level before the flood within a minute and stays there. This is a Windows limit of 1.0.6. To give the memory back after a flood, run defenseclaw-gateway restart.

Many agents on one Linux host

On a per-user install on Linux, the gateway answered every tool-call hook within 2 seconds with up to 3 interactive agents per vCPU working at once. In 1.0.5 tests on RHEL 9.8 with 4 vCPUs, 6 and then 12 interactive agents (Claude Code, Codex, GitHub Copilot CLI, Hermes and OpenCode) ran at the same time, with extra CPU load added until the 1-minute load average reached 8 to 14. All 613 tool calls sent through the registered Claude Code and Codex hooks were answered and allowed: median about 1.5 seconds, maximum 1.9 seconds (an idle host answers in 0.1 to 1.1 seconds). Answers get slower as the load grows, so a host with more agents per vCPU waits longer. On a managed host a call that waits out its answer window is blocked (Hook capacity on managed hosts).

Hook capacity on managed hosts

A managed host fails closed. In 1.0.7, a native tool-call hook gives the gateway up to 3.5 seconds from contact, within a 4-second cap from hook launch, before it blocks with enterprise_managed_gateway_no_answer. The 1.0.5 measurements below used a 3.5-second wait from hook launch: when the gateway did not answer, the hook blocked only after that full wait. Under a heavy burst of calls, or with a very large audit store, the gateway could be slow enough that some calls waited out the 3.5 seconds and were denied. Measured in 1.0.5:

  • Parallel burst. On a managed macOS host with a 710 MB audit store, the gateway answered about 14 calls a second when 32 tool calls ran in parallel. A call that was not answered in time was denied after the full wait.
  • First start after an upgrade. With a 2 GB audit store, the first cold start of the gateway after an upgrade denied 27 to 37 calls at the full wait before it answered normally.

An agent that runs a few tool calls at a time is not affected. To reduce the effect, lower the number of tool calls the agent runs in parallel, and keep the audit store small: an administrator can lower observability.local.retention_days (default 7) in the managed config and apply it with enterprise <os> ensure (Local history). Upgrade while agents are idle.

No-op ensure time on managed Windows

On managed Windows, an ensure that finds nothing to change (noop: true, noop_reason: compliant) still takes about a minute or more. It checks the Setup signature, runs the installer status and verify checks, and checks the SHA-256 of every file of the scanner runtime (about 14,000 files, 390 MB), so that a changed file is put back. DefenseClaw keeps that full check: skipping it would let a changed scanner file run. Measured in 1.0.5 on quiet Windows Server 2025 hosts:

  • Fresh install. A second ensure took 46 s.
  • Upgraded install. Later no-op ensure runs took 62 to 100 s, of which the scanner runtime check took 36 to 45 s. The first no-op ensure after an upgrade took 154 to 308 s, because the scanner runtime check took 98 s to 4 min 25 s.
  • Busy host. With four hook clients and an agent session running, a no-op ensure took 383 s.

Of a 100 s no-op ensure, about 16 s is the Setup signature check and staging, 25 s the installer status and verify checks, 45 s the scanner runtime check and 14 s the rest. Give the MDM compliance script a time limit of several minutes, not one, and do not run ensure in a tight loop.

Linux sign-out

On Linux, the OpenShell gateway runs in your systemd user manager. Without linger, signing out of your last session stops the gateway and its MicroVMs, even when a disk sync failed, so unsynced work in the guest is lost. This is how systemd works: without linger it ends a user's services when their last session ends. Save your work and stop the sandbox before you sign out, or ask an administrator to enable linger for your account with sudo loginctl enable-linger USER. See A Linux sign-out ends a running MicroVM.

Identity

On Linux, the gateway confirms an SSH session through systemd-logind, or through /run/utmp when logind is not running. utmp keeps only the first 32 characters of a user name, so for a longer directory user name the session cannot be confirmed without logind: audit events then omit defenseclaw.session.kind and client.address. Tool calls still run and are audited with the user's identity. This is a Linux limit. Keep systemd-logind running on hosts where directory user names are longer than 32 characters. See Identity sources.

Per-user self-protection

On a per-user install the agent runs as the account that owns DefenseClaw's own files, SSH keys and agent instruction files, and the hook decides from the command text the agent sends. It blocks the common ways an agent could change DefenseClaw's own files, SSH keys or protected instruction files. DefenseClaw's own state is protected in every mode (rule tamper.detector_state_write, with every rule pack). SSH keys, authorized_keys and agent instruction files are protected in action mode.

Shell can express the same write in many ways, and some unusual forms are not recognised. These cannot be decided by reading the command:

  • Command text built when it runs. A command that joins strings, fills in variables or decodes a value while it runs, and then runs the result, has no fixed text for the hook to check beforehand.
  • A link made by git, then a write. A git command such as a pull or a checkout can create a symbolic link from the repository's content. A write later in the same command that goes through that new link can reach the file the link points to, because the link does not exist yet when the hook reads the command.
  • Link text with line breaks. A link whose text has line breaks is a limit of the command reader.
  • A socket opened from an interpreter command line. The deterministic socket rule recognises the minimal one-liner form only. Other spellings are left to the LLM judge.
  • PowerShell text sent to the Claude Code Bash tool on Windows. The Bash tool runs Git Bash, so DefenseClaw reads the call as Git Bash and PowerShell cmdlet text with a comment that names a protected path is blocked. Run PowerShell commands through PowerShell.

A few harmless commands are blocked because their text matches a protected write and the hook cannot see what they do when they run:

  • a link to the SSH folder or to DefenseClaw's state made in a project, and a move in the same command as such a link;
  • a move inside a linked folder whose entries are links to the SSH folder or to DefenseClaw's state;
  • find -exec mv into a link that the same command makes;
  • a project script run by a relative path after cd, in a command that also makes a link;
  • cp -s with a source built by command substitution;
  • rsync of the whole SSH folder (cp -a and tar of it block too);
  • a ~ path after the command sets HOME.

Run such a step yourself, or give the agent a command of its own that names the real path.

The LLM judge (the LLM guardrail) is the second layer for protected-file access. If you need more than the command reader gives, turn it on; see Optional LLM judge.

On a managed install DefenseClaw's own state is owned by root or SYSTEM, so these commands cannot change it. A user's own files, such as authorized_keys, are as exposed as on a per-user install. The managed gateway cannot read the user's home, so it judges links there from what the hook reports: a few link forms of a write to authorized_keys (an existing link moved and then written through, a relative link made from the home) and some PowerShell writes to it that a per-user gateway blocks can run on a managed install. The LLM judge is the second layer for them. Check for links in repositories you pull. For what DefenseClaw repairs afterwards and what to protect yourself, see Protected files in action mode under Security.

Upgrade and policy limits

  • Legacy MicroVM guests: a MicroVM sandbox that an earlier DefenseClaw started on OpenShell 0.1.3 or older keeps running after the upgrade. DefenseClaw closes its egress proxy, withdraws every OpenShell network rule and provider of it, adds none back (approvals included) and reports it as not protected, but withdrawing those rules does not contain the guest's old OpenShell network broker, which passes a connection it cannot inspect straight to the host (NVIDIA/OpenShell#4494), so treat the guest's network as open until it restarts. DefenseClaw does not stop it for you, so as not to lose work it has not synced. Restart it once DefenseClaw has withdrawn its rules: save the work you need, then run defenseclaw sandbox stop NAME and defenseclaw sandbox start NAME (or delete for one whose workload ended); its next session runs on the current supervisor with its network restored. This is an OpenShell 0.1.3 limit; see A guest from OpenShell 0.1.3 or older keeps its network after its rules are withdrawn. Run defenseclaw sandbox status NAME to check the guest's state and why it stopped.
    • If the guest is ready, save accessible work outside it, then run defenseclaw sandbox stop NAME and defenseclaw sandbox start NAME. This keeps the guest. The stop syncs the guest's disk first. If that sync fails (a frozen guest, for one), the stop is held and the guest keeps running: sandbox NAME was not stopped: its MicroVM's disk could not be synced first. defenseclaw sandbox stop NAME --discard-unsynced stops it anyway and loses what it wrote since its last sync; the activity feed then shows stop_unflushed. See A MicroVM stop is held because its disk could not sync.
    • If the guest completed, or its main process failed and its VM is still running: OpenShell 0.1.5 neither stops nor restarts a MicroVM whose workload completed, or whose main process failed, while its VM still runs: its start (defenseclaw sandbox start NAME --end-vm, or openshell sandbox start NAME for a raw sandbox) fails with Conflict and leaves it starting, where stop is refused too. Save or sync any work you can reach first and keep the VM while you need what it holds (it keeps the OpenShell gateway, so upgrades and gateway restarts wait). Only then delete it with defenseclaw sandbox delete NAME (or openshell sandbox delete NAME), which deletes it and its work.
    • On OpenShell 0.1.3, recreate a legacy guest only if it is completed or in an error state and its VM has not exited. Save accessible work outside it before running defenseclaw sandbox delete NAME; deletion removes the guest and its work.
    • If the VM process has exited, run defenseclaw sandbox stop NAME and defenseclaw sandbox start NAME instead. For other states or errors, follow the recovery advice from status.
  • Managed policy before launch: on managed Linux, macOS and Windows a managed agent loads its DefenseClaw hook from the machine policy when it starts. A standard user can start the agent in a private view of the files (a user and mount namespace or a process tracer such as PRoot on Linux, a sandbox profile on macOS, a process device map on Windows). On Linux and macOS that view can hide the machine policy: the agent then runs without its hook, so DefenseClaw does not see or audit its tool calls, and status and verify cannot see inside that one process. macOS has no setting that stops a user's sandbox profile, and its status and verify stay healthy while such an agent runs. On Windows the tested device map did not change what the agent read. This is an operating system limit: the system lets users change what their own processes see. On Linux, status and verify warn unprivileged_user_namespaces while the kernel allows these namespaces and unprivileged_ptrace while standard users can trace their own processes, and report security_complete: false; an administrator can set user.max_user_namespaces=0 and kernel.yama.ptrace_scope=2 after testing the host's workloads (Linux user namespaces, macOS machine policy, Windows machine policy). Keep Unix policy files owned by root and Windows machine policy protected by the installer. Use the agent's doctor check where available. Before use, ask an administrator to run the policy verification for that OS and repair any missing hook.
  • Restored hook records on managed macOS: after you restore saved per-user hook records (Hermes hook_contract_lock.json, hook token files, .hookcfg files), the guardian rewrites, within seconds, the records that no longer match the live registration (an older token, another fail mode or contract state). Records that still match stay byte for byte as restored. Protection is unchanged; compare the hook commands, not the file bytes.
  • Restored generated state on managed macOS: after you restore saved copies of the generated files of a managed Mac (for example runtime/hook_guardian_state.json, runtime/hook_guardian_owned_files.json and etc/bundles/inbox), the files and folders the running services own change again within a few minutes. The guardian rewrites its two last-pass records on every pass (updated_at is the heartbeat that status and verify require to be less than five minutes old), and every ensure creates the empty etc/bundles/inbox folder that the apply job watches. Protection is unchanged. Compare the policy-bearing files (the admin config, machine profiles and effective policy digest) and the status and verify results, not the bytes of these records.
  • Restored hook contract lock: on every install the gateway writes hook_contract_lock.json again when it starts and on every upgrade or rollback, so a restored copy keeps its bytes only until then. Only updated_at and defenseclaw_version change; see Fields the gateway rewrites.
  • Hermes config changed and put back quickly: on a managed computer Hermes reads its config from a file the user owns. If that file is emptied and put back within about 3 seconds, before the guardian's next check, one Hermes session can start without the DefenseClaw hook. The guardian repairs the file at its next check and records the change in the audit log. This is a limit of an agent config the user owns.
  • Windows upgrade and rollback return before the installer finishes: On Windows, defenseclaw upgrade and defenseclaw rollback hand over to the installer in a new window and return at once: exit code 0 means the installer started, not that it finished, because the installer must replace the Python environment the CLI runs from. The result is shown in that window and saved in %USERPROFILE%\.defenseclaw\logs\install-<time>.log. A script that needs the result runs the installer itself in its own terminal, for example powershell -NoProfile -ExecutionPolicy Bypass -File <install.ps1> -Rollback -Yes, which waits and sets the exit code.
  • Uninstall of a 1.0.2 or 1.0.3 deployment on Windows: a newer Setup's /uninstall of a 1.0.2 or 1.0.3 deployment runs that release's own cleanup helper. If the result lists user_registrations_failed for an account's Claude Code registration (legacy compare-and-swap state directory ... is not owned by current user), run the newer Setup's /ensure first, then /uninstall. Deployments of 1.0.4 and later remove that registration directly.
  • Managed upgrades from 1.0.2 and 1.0.3: if the administrator explicitly chose to allow gateway outages, an old hook already in flight or a plugin still loaded by an agent may let a call run while the gateway is stopped. Stop agent sessions before upgrading and keep them stopped until the gateway is healthy. Start new OpenCode and Amp sessions afterward. During an upgrade from 1.0.2 or 1.0.3, the old gateway can keep answering hook calls until the package replaces it. Those versions do not wait for the hook to confirm that it used the answer, so if a call timed out in the hook and was blocked, the old gateway's audit row can still say allow. From 1.0.4 on, the gateway records such a call as unconfirmed. See Managed hook limits.

Agent messages that are not from DefenseClaw

These messages come from the agent, its installer or its own command checks. DefenseClaw did not make that decision, and its audit log has no block for it. Check defenseclaw-gateway audit export --output - (or the TUI Audit panel) when you are not sure.

  • Codex, Model metadata for <model> not found. Defaulting to fallback metadata: Codex has no built-in metadata for a Bedrock model such as us.openai.gpt-5.6-luna and uses its defaults. Model turns work. Nothing to do.
  • Codex, startup offers to restart a shared daemon (for example to turn off api_key_model_discovery): the running Codex app-server daemon has other settings than this session asks for. Choose to run without the daemon this time to leave other Codex sessions alone, or restart the daemon when no other session uses it.
  • Codex, sandbox_approval refusals, a read-only .git/hooks or no network in a Workspace (granular) session: Codex's own workspace sandbox refuses these steps; DefenseClaw allowed the call. /status in Codex shows the sandbox. Change the Codex sandbox or approval setting, or run the step in a terminal.
  • Claude Code, Auto-update failed: no write permission to npm prefix: Claude Code is installed in an npm prefix your account cannot write, so it cannot update itself. Ask the administrator who installed it to update it.
  • Claude Code, Unknown command: /NAME for a new project skill: Claude Code loads a new skill only when it starts. Restart Claude Code.
  • Claude Code, Contains brace with quote character (expansion obfuscation): Claude Code's own permission prompt labels some literal JSON or heredoc text this way. Read the command and allow it once if it is what you want.
  • GitHub Copilot CLI, automatic update fails with EACCES: Copilot cannot write its machine-owned install folder. Ask the administrator who installed it to update it.
  • Copilot CLI, the path-access dialog lists command words such as exit, test or run as paths: that is how Copilot's dialog reads a shell command. Check the real project path in the dialog.
  • Copilot CLI, Model "<model>" is not in the built-in catalog. Using defaults for: prompt tokens ..., output tokens: Copilot has no catalog entry for the Bedrock model and uses default token limits. Set COPILOT_PROVIDER_MAX_PROMPT_TOKENS and COPILOT_PROVIDER_MAX_OUTPUT_TOKENS if you need other limits.
  • Hermes, Security scan — [HIGH] Pipe to interpreter, Nested executable body could not be resolved, The command is blocked followed by auto-approved by smart approval, or a Dangerous Command prompt that names Tirith: these come from Hermes's own command scanner (Tirith) and SmartApproval. If you deny such a prompt, Hermes can then say DefenseClaw blocked the step; the DefenseClaw audit shows its real decision.
  • Hermes, This foreground command appears to start a long-lived server/watch process: Hermes's terminal policy refuses a foreground command such as npm start. Run it in the background as Hermes suggests, or run the program directly.
  • Hermes, node not available (Hermes-managed Node not installed) from its file lint: Hermes's linter looks for its own Node, not yours. Your Node builds and tests still work.
  • Hermes, pygount: command not found in its inspection skill: the bundled skill uses the optional pygount tool. Install it, or let Hermes use its fallback.
  • Hermes, pm-runtime: invalid package install stamp or Permission denied on .install.lock when you add an MCP server: Hermes cannot read or create its own runtime files for your account, often in a shared Hermes install. Check the path, owner and permissions the message names. See Hermes limits.
  • OpenCode, npm warn install-scripts: postinstall ... is not covered by allowScripts during npm install -g opencode-ai: npm reports the package's install script. The CLI works (opencode --version).
  • OpenClaw, its coding-agent skill runs codex exec --full-auto or puts pty:true in a shell command and fails: the bundled OpenClaw skill does not match the installed Codex CLI. The model can still run Codex directly.

Sandboxes

  • Raw OpenShell during a gateway restart: a sandbox you start with a raw openshell command while DefenseClaw sets up, upgrades, restarts or rolls back the OpenShell gateway is not held back. DefenseClaw's lock covers only DefenseClaw commands, and OpenShell has no admission barrier that raw clients honor. DefenseClaw checks before the change and stops when it sees such a sandbox. On an upgrade, DefenseClaw's last check runs before NVIDIA's installer runs, not right before the restart: the installer restarts the gateway itself, after its download and install, so a raw sandbox started while the installer runs is not seen. A restart or rollback DefenseClaw makes itself checks again right before the restart. In both cases, one started after the last check is ended by the restart and loses work it has not written to disk. This is an OpenShell limit. Do not start raw openshell sandboxes until the DefenseClaw command finishes. See A raw openshell sandbox stops a restart or rollback.
  • Rejected model key in a sandbox: a rejected model key (for example an expired short-term Bedrock key) is named in the sandbox's feed and status when the agent's turn ends on it. Claude Code retries a rejected request for up to about three minutes before that, and neither its hooks nor OpenShell's records report the rejection earlier, so DefenseClaw cannot warn before the retries end.
  • No network cutoff for a contained MicroVM: if DefenseClaw cannot confirm that OpenShell withdrew a contained VM's network rules (the OpenShell gateway does not answer, or a global OpenShell policy stops the change), the VM stays reported as unprotected and new DefenseClaw runs are refused, but its network may still work. The user-level DefenseClaw daemon has no host packet filter, and OpenShell has no VM pause or network-off operation. This is an OpenShell and platform limit. Treat the network as available until the withdrawal is confirmed, save the work you need, then decide whether to end the VM. See A contained VM has no confirmed network withdrawal.

Known issues

Every other bug that 1.0.4 listed here is fixed in 1.0.5; the release notes list the fixes. The entries below are still true on 1.0.5. Each says who is affected and what to do now.

Fail mode and outages

  • OpenCode and Amp keep their start-up state: a session started while the gateway was down keeps blocking after the gateway is back, and a running OpenCode session keeps the outage mode it loaded with. Restart OpenCode or Amp after the gateway is healthy and after you change the fail mode or policy.
  • Outage warnings: Hermes shows no DefenseClaw warning in the chat when a call runs during an outage. Copilot CLI shows it once per session under the first tool call's output (expand the tool output to read it), and OpenCode V2 adds it to the tool call's result. Claude Code shows it once per session, with the session's first prompt or tool call, in the terminal; Claude Desktop's Cowork shows no DefenseClaw hook warning or notice anywhere in its window (measured on macOS and Windows with Claude Desktop 4.16336.0), so check Cowork with defenseclaw status, defenseclaw doctor or the TUI. Codex shows it once per session. Check defenseclaw status; each unchecked call is in ~/.defenseclaw/logs/hook-failures.jsonl.

Agents and hooks

  • Busy hosts: when many agent sessions start at once or the CPU is saturated, a few ordinary calls can be denied with "gateway is running but did not answer", "hook client disconnected before the gateway decision was delivered", or on managed Windows after an upgrade runtime_state_invalid once a minute. Retry the call, and don't start many sessions at once on a small host.
  • Not certified on every per-user Windows agent: the 1.0.5 certification ran Antigravity, Cursor (command line) and Devin on per-user Windows. It did not run Amp or Kiro there.

Action mode

  • Ordinary work blocked: action mode can block a few benign commands as an SSH key write: a bare alias definition such as alias ll=ls, some PowerShell if blocks, and on Windows some Codex apply_patch edits that name the file through a PowerShell variable. Observe, the default, only reports them. On a per-user install, switch that agent to observe while you work: defenseclaw guardrail mode observe --connector NAME.

Security

  • Protected files in action mode: on a per-user install the agent runs as the account that owns SSH keys, authorized_keys, agent instruction files and DefenseClaw's own state, so action mode blocks the commands it recognises and some indirect forms can still get through. DefenseClaw's hook guard and defenseclaw doctor detect and repair a change to its own state afterwards. Managed installs protect that state with operating-system ownership and permissions. Per-user self-protection lists the commands the hook cannot decide by reading them. Don't rely on DefenseClaw alone for these files: keep SSH keys passphrase-protected and file permissions tight, and review changes to CLAUDE.md, AGENTS.md and SOUL.md (for example with git diff). defenseclaw rollback refuses a saved installer whose digest changed.