Skip to main content

Agent-Native GRC

Claw GRC is the first GRC platform designed from the ground up for a world where AI agents operate alongside human teams. This page explains why this matters and how the agent-native architecture works.

The Agent Governance Gap​

Organizations deploying AI agents face a fundamental compliance challenge: traditional GRC tools have no concept of non-human actors. When an AI agent accesses sensitive data, creates a security finding, or interacts with another agent, that activity needs to be governed, audited, and tracked -- just like human activity.

Without agent-native GRC:

  • Agent actions are invisible to auditors
  • There is no way to measure or enforce agent trustworthiness
  • Agent-to-agent interactions cannot be verified for tampering
  • Compliance frameworks covering AI (EU AI Act, NIST AI RMF) cannot be satisfied

How Claw GRC Solves This​

Claw GRC treats AI agents as first-class participants in the compliance process:

Agent Identity​

Every agent in Claw GRC has a unique identity with:

  • A UUID that identifies the agent across all interactions
  • An API key (prefixed cgrc_) for authentication
  • A type that describes its function (compliance, security, monitoring, etc.)
  • Capabilities that define which MCP tools it can invoke
  • Data classifications that specify what sensitivity levels it can access
  • An optional certificate fingerprint for mutual TLS authentication

Trust Scoring​

Agent trust is not assumed -- it is earned. Every agent starts with a trust score of 0.0 and builds trust through successful interactions. The trust score (0.0 to 1.0) is computed from four factors:

FactorWeightDescription
Success Rate40%Ratio of successful to failed interactions
Response Time20%How quickly the agent responds (faster = higher)
Consistency20%How consistent response times are (lower variance = higher)
Uptime20%How frequently the agent sends heartbeats

Trust scores enable trust-based access control:

  • Trusted (> 0.80) -- Full access to all authorized capabilities
  • Normal (0.40 - 0.80) -- Standard access, monitored
  • Flagged (< 0.40) -- Restricted access, enhanced monitoring

When an agent invokes another agent, it can require a minimum trust score:

{
  "target_agent_id": "uuid",
  "method": "analyze",
  "min_trust_score": 0.8
}

Tamper-Evident Audit Trail​

Every agent interaction is recorded with a chain hash that cryptographically links each log entry to the previous one. This means:

  • No entry can be modified without breaking the hash chain
  • No entry can be deleted without creating a detectable gap
  • The entire history can be verified with a single traversal

See Audit Trail for technical details.

MCP Protocol​

Agents interact with Claw GRC through the Model Context Protocol (MCP), a structured request-response protocol with session management:

  1. Handshake -- Agent authenticates and opens a session. The server returns the list of available tools.
  2. Message -- Agent invokes a tool (e.g., grc.list_frameworks, grc.create_finding). Each invocation is authenticated, authorized, and logged.
  3. Close -- Agent closes the session when done. Idle sessions expire after 1 hour.

Claw GRC exposes 8 MCP tools covering compliance data access, security operations, and agent-to-agent communication. See MCP Tools for the complete tool catalog.

Use Cases​

Compliance Automation Agent​

An agent that automatically collects evidence from cloud providers:

  1. Registers with capabilities: ["grc.list_frameworks", "grc.submit_evidence"]
  2. Periodically exports IAM policies, firewall rules, and audit logs from AWS
  3. Submits evidence artifacts through MCP, mapped to the correct controls
  4. Builds trust through consistent, successful evidence submission

Security Scanning Agent​

An agent that monitors for vulnerabilities:

  1. Registers with capabilities: ["grc.create_finding", "grc.trigger_scan", "grc.create_ticket"]
  2. Runs security scans against defined targets
  3. Creates findings in Claw GRC with proper severity, CWE, and CVSS scores
  4. Automatically creates remediation tickets for critical and high findings

Agent-to-Agent Orchestration​

Agents can discover and invoke other agents:

  1. Agent A uses grc.discover_agents to find agents with specific capabilities
  2. Agent A checks the target's trust score against its requirements
  3. Agent A invokes Agent B through grc.call_agent
  4. The entire interaction chain is recorded with chain hashing

Next Steps​