Skip to content
The State of Exposed AgentsRead the report
Guard0

You Wouldn't Hire Someone Without a Background Check. Why Deploy an Agent Without One?

Introducing g0, the open-source background check for AI agents: 1,128 security rules across 12 domains, mapped to the OWASP Agentic Top 10.

· Updated · 10 min read · Guard0 Team

You Wouldn't Hire Someone Without a Background Check. Why Deploy an Agent Without One?

You wouldn't hire someone without a background check. You wouldn't give an employee access to your production databases, your customer data, and your email systems without knowing who they are and what they can do.

So why are teams deploying AI agents, autonomous systems that reason, plan, and act, without any equivalent diligence?

Most teams building AI agents do not have a clear picture of what their agents can do. They know they should be doing something: hardening prompts, validating tool outputs, locking down memory access. But "something" stays vague. There is no checklist that feels complete, and no tool that tells you what you missed.

g0 is the open-source background check for AI agents. Point it at a repo and it scans your agent codebase against 1,128 security rules across 12 domains. You get a grade, and findings you can triage, assign, and fix.

* * *
1,128
Security Rules
12
Security Domains
10
OWASP Agentic Categories Mapped

What is g0

g0 reads your agent code (prompts, tool definitions, MCP configurations, memory implementations, orchestration logic) and tells you what your agent is capable of and where the risks are.

npx @guard0/g0 scan ./my-agent

That command produces a graded report. Every finding has a severity, a one-line fix, and a mapping to standards including the OWASP Top 10 for Agentic Applications (ASI01 through ASI10), the OWASP Top 10 for LLM Applications, NIST AI RMF, ISO 42001 and the EU AI Act.

g0 is open source under AGPL-3.0. It runs locally and does not upload your scans. It scans Python, TypeScript, JavaScript, Java and Go, and ships parsers for 10 agent frameworks.

g0 SCAN PIPELINE
scan1,128 rulesfindingsJSON / SARIFAgent CodebaseFramework DetectionRule EngineScoringReport
* * *

What g0 Scans

g0's rules are organized into 12 security domains. Most security tools were not built with agents in mind. g0 was built for nothing else.

g0 SECURITY DOMAINS
Goal IntegrityTool SafetyIdentity & Ac…Supply ChainCode ExecutionMemory & Cont…Data LeakageCascading Fai…Human Oversig…Inter-AgentReliability B…Rogue Agent

1. Goal Integrity

Can the agent's instructions be overridden? g0 checks system prompts for missing scope boundaries and for user-supplied or retrieved content that reaches the model in a way that lets it replace the agent's goal. This is where prompt injection findings land.

2. Tool Safety

Every tool an agent can call is a possible path to misuse. g0 scans tool definitions for dangerous capabilities, missing input validation, and unvalidated parameters, with dedicated rules for MCP servers.

3. Identity and Access

Agents that act on behalf of users need to handle identity correctly. g0 checks for hardcoded credentials and missing authorization on sensitive actions.

4. Supply Chain

Agents depend on frameworks, packages, MCP servers and skills. g0 checks those dependencies and configurations, including indicators from known malicious campaigns.

5. Code Execution

Agents that run code need limits. g0 flags unsafe dynamic execution, such as eval-style calls and unsandboxed shell access.

6. Memory and Context

Short-term and long-term memory introduce their own problems. g0 looks for memory shared between users, missing isolation, and patterns that allow memory poisoning.

7. Data Leakage

g0 uses taint tracking and cross-file analysis to find paths where sensitive data can leave: secrets in prompts, personal data passed to tools, and exfiltration through tool calls.

8. Cascading Failures

One agent's bad output becomes the next system's input. g0 checks for missing validation and error handling between steps.

9. Human Oversight

Some actions should wait for a person. g0 checks whether high-impact actions have an approval step.

10. Inter-Agent

Orchestrators call subagents, and subagents call each other. g0 checks whether agent-to-agent messages are authenticated and validated before being acted on.

11. Reliability Bounds

Agents need limits on loops, retries, spend and time. g0 flags agents that have none.

12. Rogue Agent

g0 checks for the controls that let you notice and stop an agent that is acting outside its purpose.

* * *

1,128 Rules, Organized for Triage

1,128 rules is a large number. The rule taxonomy is designed so that you are never looking at an undifferentiated list of findings.

Every rule has:

  • A severity level: critical, high, medium, low, or info
  • A domain: one of the 12 listed above
  • A confidence level: how strong the signal is
  • Standards mappings: the OWASP Top 10 for Agentic Applications (ASI01 to ASI10) and other frameworks where they apply
  • A remediation: a concrete fix, not only a description of the problem
  • A stable rule ID in the form AA-{DOMAIN}-{NUMBER}, such as AA-GI-001 for a goal integrity rule or AA-TS-002 for a tool safety rule, so you can exclude a specific rule in configuration

You can browse the catalog from the terminal:

g0 rules list --domain data-leakage
g0 rules describe AA-GI-001

g0 maps findings to the OWASP Top 10 for Agentic Applications (2026), the Agentic Security Initiative's ten categories of autonomous-agent risk:

IDCategory
ASI01Agent Goal Hijack
ASI02Tool Misuse & Exploitation
ASI03Identity & Privilege Abuse
ASI04Supply Chain Vulnerabilities
ASI05Unexpected Code Execution
ASI06Memory & Context Poisoning
ASI07Insecure Inter-Agent Communication
ASI08Cascading Failures
ASI09Human-Agent Trust Exploitation
ASI10Rogue Agents

That way your security team, your compliance team, and your engineering team are looking at the same framework.

* * *

Tutorial: Running Your First Scan

Run the scan against an agent project:

npx @guard0/g0 scan ./my-banking-agent

The output ends in a report card like this one, from the g0 README:

  ./my-banking-agent  ·  langchain (+mcp)  ·  14 files  ·  1.2s
 
  CRITICAL  Shared memory between users            main.py:8   [AA-DL-046]
            Fix: isolate memory per user_id/session.  OWASP:ASI07
  HIGH      System prompt has no scope boundaries   main.py:21  [AA-GI-001]
            Fix: add role, task boundaries, output constraints.
  HIGH      Database tool without input validation  tools.py:34 [AA-TS-002]
  + 18 more across 12 domains
 
  CRIT 2   HIGH 5   MED 6   LOW 6   INFO 2         Total: 21
 
  Goal Integrity   ██████████████████░░░░░░░░░░  60
  Code Execution   ████████████████░░░░░░░░░░░░  52
  Data Leakage     █████████████████████████░░  82
 
  C   ████████████████████████████░░░░░░░░  68
  ⚠  Grade capped: 2 critical findings present

Three things to notice.

The grade is A to F, and it is capped when critical findings are present. A project with a serious issue cannot read as healthy because the rest of it is clean.

Every finding has a file, a line, a rule ID and a fix. The critical finding here, memory shared between users, is where to start. The two high findings come next: a system prompt with no scope boundaries is the usual way in for prompt injection, and a database tool without input validation is the path from injection to damage.

Mediums and lows are real but can be scheduled.

For other formats:

g0 scan . --json -o results.json
g0 scan . --sarif report.sarif
g0 scan . --junit results.xml
* * *

CI/CD Integration

A security scanner only works if it runs on every change. g0 is designed to be a CI gate as well as a developer tool.

GitHub Actions:

name: AI Agent Security
on: [push, pull_request]
 
permissions:
  contents: read
  pull-requests: write
  security-events: write
 
jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - name: g0 Security Scan
        uses: guard0-ai/g0@v2
        with:
          path: '.'
          min-score: '70'
          fail-on: 'high'
          sarif: 'true'
          upload-sarif: 'true'
          pr-comment: 'true'

fail-on: 'high' fails the job on any high or critical finding. The action uploads SARIF to GitHub Code Scanning, so findings appear as alerts on the pull request, and it posts one PR comment that it updates on each push.

Outside GitHub Actions, use the gate command:

g0 gate . --min-score 80
g0 gate . --no-critical
g0 gate . --baseline .g0-baseline.json

The baseline mode fails only on findings that are new since the baseline, which lets you adopt g0 on an existing codebase without first fixing everything.

You can add a .g0.yaml in your project root to customize behavior:

# .g0.yaml
preset: balanced  # strict | balanced | permissive
min_score: 70
exclude_rules:
  - AA-GI-001
exclude_paths:
  - tests/
  - node_modules/
severity_overrides:
  AA-DL-001: critical
* * *

OpenClaw Scanning

g0 includes rules for OpenClaw, the self-hosted personal AI agent. They run as part of a normal g0 scan and read OpenClaw's own files: SKILL.md, SOUL.md, MEMORY.md and openclaw.json. They flag things like unsafe runtime settings, unofficial skill registries, credentials stored in memory files, and indicators from the ClawHavoc malicious skill campaign.

g0 check does the same job for a whole machine: it lists the AI tools, MCP servers and installed skills it finds and compares them against a known-malicious database.

For what happened to OpenClaw and why it matters, see The OpenClaw Security Crisis.

* * *

From CLI to Company

g0 is the background check for one agent or one team. Run it locally. Run it in CI. Get a grade. Fix the findings.

Organizations with many agents across teams, products and cloud environments have a different problem. They need to know what every agent in the company is, including the ones no scan was ever pointed at, what each one can reach, and who answers for it.

That is what the Guard0 platform does:

  • Finds agents across the AI your people use, the AI inside your platforms, and the AI your teams build
  • Maps access: what each agent can reach, and what happens if it is compromised
  • Records an owner for each agent
  • Tests behavior with static analysis and red teaming
  • Maps to frameworks: EU AI Act, ISO 42001, and the OWASP lists

If you want the background on the discipline, the AI-SPM guide is a good place to start.

* * *
See Guard0 in action

Live walkthrough of agent discovery, risk scoring, and policy enforcement.

Book a Demo
*Key Takeaways
  • g0 is the open-source background check for AI agents: 1,128 security rules across 12 domains, mapped to the OWASP Top 10 for Agentic Applications
  • Every finding includes a severity, a domain, a rule ID, and a concrete fix
  • The grade is A to F and is capped when critical findings are present
  • It runs in CI through a GitHub Action or g0 gate, with SARIF output and configurable thresholds
  • g0 runs locally and does not upload your scans
* * *

Get Started

Run your first scan:

npx @guard0/g0 scan .

Source code, documentation, and the full rule set are at github.com/guard0-ai/g0. There is more on the g0 page.

Have agents across many teams? The Guard0 platform finds every agent in your company, maps what each can reach, and records who owns it.

Start free

g0 · Open Source · CLI · Agent Accountability · OWASP

Guard0 Team