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. 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.
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-agentThat 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.
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.
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, orinfo - 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 asAA-GI-001for a goal integrity rule orAA-TS-002for 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-001g0 maps findings to the OWASP Top 10 for Agentic Applications (2026), the Agentic Security Initiative's ten categories of autonomous-agent risk:
| ID | Category |
|---|---|
| ASI01 | Agent Goal Hijack |
| ASI02 | Tool Misuse & Exploitation |
| ASI03 | Identity & Privilege Abuse |
| ASI04 | Supply Chain Vulnerabilities |
| ASI05 | Unexpected Code Execution |
| ASI06 | Memory & Context Poisoning |
| ASI07 | Insecure Inter-Agent Communication |
| ASI08 | Cascading Failures |
| ASI09 | Human-Agent Trust Exploitation |
| ASI10 | Rogue 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-agentThe 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 presentThree 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.xmlCI/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.jsonThe 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: criticalOpenClaw 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.
Live walkthrough of agent discovery, risk scoring, and policy enforcement.
Book a Demo- 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.
g0 · Open Source · CLI · Agent Accountability · OWASP