Menu

Strix Guard · Execution control for AI agents

Govern the action. Verify the evidence.

Your agent can issue a refund, send a message, merge a change, or delete a record. The problem is not only that it might be wrong. A consequential action needs an enforceable authorization decision before it runs, and afterwards someone will be asked to show what was authorized, refused, and observed, with evidence that does not depend on trusting us.

Strix is an execution control kernel that sits between an AI agent's intent and a protected side effect. Guard is the entry point: one command, the MCP servers your agent already uses, reads pass, writes wait for a person, and every governed call leaves a signed record anyone can verify without a Strix account.

# check a real production record, no account
npx @strixgov/verifier@latest 5686

# wrap the MCP servers your agent already uses, locally, free
npx @strixgov/guard init

What Strix controls

Four layers, each with its boundary stated.

Decision

Evaluates each governed call before the side effect: allow, deny, or hold for a person.

Does not read the message body or SQL to infer intent; it decides by tool and capability classification.

Authorization

A held call proceeds only on a human decision. Hosted HIGH and CRITICAL actions need a single-use, short-lived, payload-bound execution token consumed before the handler runs.

Does not re-derive policy against world state inside the token's lifetime unless the action is designed to re-read standing.

Evidence

Signs an Ed25519 record of every governed decision and outcome; hash-chained; verifiable offline with open tooling.

A signature authenticates the record. It does not prove the policy was right or that the business outcome happened.

Coverage

Governs the paths you route through it, and names the paths you do not.

Does not cover tools, routes, credentials, agents, or systems outside the governed path.

How the boundary works

Evaluate, then hold or refuse, then execute, then record.

agent intent ──▶ Guard / Strix evaluate ──▶ ALLOW ──▶ protected side effect ──▶ signed receipt
                        │
                        ├──▶ HOLD ──▶ a person approves or denies ──▶ runs once, or refused and receipted
                        │
                        └──▶ DENY ──▶ nothing runs ──▶ signed receipt of the refusal

Authorized execution

  • A read classified low-risk passes without a hold.
  • A held write runs only after a named person approves, and runs once.
  • Hosted HIGH and CRITICAL actions redeem a single-use execution token bound to the exact payload before the handler runs.
  • The receipt records the decision, the approval, and the outcome the tool reported.

Refused execution

  • A person denies: nothing runs, and the refusal is a signed record, not an absence.
  • No decision within the timeout: deny. A lost notification never approves and never silently denies.
  • A call outside the allowed set: refused before the side effect.
  • Hosted: a replayed or payload-substituted token is refused and the token is spent.

Evidence and independent verification

Verify the record, not the dashboard.

# hosted records: against the public key set, no account
npx @strixgov/verifier@latest <evidenceId>

# Guard receipts on your machine: offline, against the exported key
npx @strixgov/verifier@latest chain \
  ~/.strix-guard/receipts/<serverId>/receipts.jsonl \
  --jwks ~/.strix-guard/receipts/<serverId>/keys/public-jwk.json

What VERIFIED establishes: the named key signed this exact canonical record, and its hash and chain link are intact. Hosted records resolve against /.well-known/strix-jwks.json. The verifier is a separate package that shares no code with the proxy or the kernel.

What it does not establish: that the policy was correct, that the tool did what it reported, or that anything happened on a path that did not pass through the boundary. A Guard receipt signed by a key on your machine is a local-machine assertion, not Strix-operated key custody.

Production records you can check now: 5686 (the signing path, a cron record), 36269 (a real administrator refused), 36548 (a second administrator's action intercepted for approval). See also CFX-009, point-of-use standing on one consequential workflow.

Supported integration scope

Governed paths, and the ones that are not.

Covered today

  • ✓Stdio MCP servers in a Claude Code .mcp.json, Claude Desktop config, or Cursor mcp.json, wrapped by Guard
  • ✓A TypeScript function or HTTP mutation wrapped by @strixgov/governed-action
  • ✓A Python call site wrapped by governed_action() via /strix-wire
  • ✓Known servers (Notion, GitHub, Slack, Linear, Postgres, filesystem, email): low-risk reads pass, everything else waits
  • ✓Unknown servers: every call waits until classified; nothing defaults to silent-allow

Not covered, stated plainly

  • —HTTPS-hosted MCP servers (the proxy intercepts stdio transport only)
  • —Actions an agent takes outside the proxy or the wrapped call site
  • —Inspection of payload content for intent, data-loss prevention, or model correctness
  • —Any route you did not route: the pilot handoff lists these by name

Who it is for

Teams whose agents already act.

  • Engineering teams putting AI agents into existing business workflows
  • Agents that already act: Claude Code, Claude Desktop, or Cursor against Stripe, GitHub, Slack, Notion, Linear, Postgres, or a filesystem
  • The person who answers “why was the agent allowed to do that?”

The Governed Integration Pilot

One action. One boundary. A result your team checks.

One consequential action

A refund, a send, a merge, a record mutation, a tool write, named by capability, system, and material parameters.

One agreed integration boundary

A Guard-wrapped MCP server, a wrapped call site, or a wrapped HTTP mutation. Exactly one.

Defined policy and authorization behavior

Who may approve, what holds, what denies, what happens on timeout: deny.

Authorized and refused scenarios

Approved once; refused by a person; refused by timeout; policy deny; replay and payload substitution on a hosted token; a tamper check.

Evidence capture and independent verification

Hosted records verified with npx @strixgov/verifier <id> against the public key set; Guard receipts verified offline against the exported key. You run the commands.

A customer handoff

A written statement of what was covered, what was not, what the records establish, and the outcome: control established, additional evidence required, or not suitable.

A pilot is not a production certification and not an enterprise-wide assurance guarantee. A valid negative result is still a completed pilot. Technical acceptance follows the independent reviewer's verification results.

Pricing reference

Local Guard use (proxy, policy, receipts, verifier) is free and never metered. Catalog figures, subject to the canonical pricing document: Pro $49 per user per month; Team $199 per user per month with a 3-seat minimum; Business $2,500–$7,500 per month, scoped. Pro and Team are set up by a person after you reach out; they are not self-serve today. Pilot: Contact Sales for Pricing. See the catalog.

Request a pilot

Bring us the one action your agent cannot be allowed to get wrong.

We freeze the action, the boundary, and the authorization behavior in writing, run the authorized and refused scenarios in your environment, and hand you records you verify yourself along with a plain list of what was and was not covered.