AI coding agents write Terraform in seconds, and most teams merge it after a skim. audytx reviews it with a
deterministic, hand-written engine — the same one behind the GitHub App — running as a stateless
MCP server at https://audytx.com/mcp. The agent that wrote the code is
probabilistic; the reviewer isn't.
Point your agent at audytx's MCP server. Before it opens a pull request, the agent calls scan_terraform on its own output — or autofix_terraform to scan, repair, and re-scan in one loop.
The agent runs scan_terraform on the Terraform it just wrote, in the same session — no CI wait, no second tool.
Findings come from a hand-written Rust engine, not another LLM, so the reviewer never hallucinates the fix.
autofix_terraform applies only sound, attribute-precise fixes and re-scans — up to three passes.
LLMs write valid-looking Terraform fast. The research on LLM code security is blunt: valid isn't secure.
LLMs score below 35% on the IaC-Eval benchmark for infrastructure-as-code correctness, with security misconfigurations among the most common failure modes.
An AI-generated Terraform configuration granted IAMFullAccess to a publicly-accessible, unauthenticated Lambda function — leading to admin access within 8 minutes of deployment.
45% of AI-generated code introduces a known security vulnerability when no security guidance is given.
Across 470 pull requests, AI-co-authored code showed 1.57× the overall security findings of human-written code — rising to 2.74× for specific vulnerability classes such as XSS.
The dangerous configuration is rarely in one file — it's in how three resources relate. A skim can't see that; a context graph can.
An agent writes a .tf file, the developer skims the diff, it looks fine, the PR merges. The IAM PassRole chain that creates a privilege-escalation path isn't visible in any single file. Seeing it takes reasoning across the three resources the agent touched.
The agent that wrote the Terraform calls scan_terraform before the PR exists. It gets file and line anchors, severity, and a rationale for every finding (including the false positives audytx suppressed, and why), then fixes the real issues in the same session.
Install the GitHub App, point your agent at the MCP server, and watch the first review land. Free for every team while the beta is open.
Free with a Client ID. Grab one at /signup, add the header, and point your agent at the endpoint.
# Claude Code
claude mcp add --transport http audytx https://audytx.com/mcp \
--header "X-Client-ID: YOUR_CLIENT_ID"
# Or in .cursor/mcp.json / claude_desktop_config.json:
{
"audytx": {
"url": "https://audytx.com/mcp",
"headers": { "X-Client-ID": "YOUR_CLIENT_ID" }
}
}The server is stateless: no session, no persistent connection. Each call is one HTTP POST with JSON-RPC, authenticated by your X-Client-ID header (get a free Client ID).
# The agent calls scan_terraform with your .tf content
{
"tool": "scan_terraform",
"files": [
{ "path": "main.tf", "content": "resource \"aws_iam_role\" ..." },
{ "path": "lambda.tf", "content": "resource \"aws_lambda_function\" ..." }
]
}Pass as many .tf files as the change touches. Cross-resource reasoning spans every file in the call, the same way the GitHub App spans the repo tree it fetches at PR time (up to 400 files).
Each finding includes: resource name, file path, line number, severity, rule ID, human-readable description, and a sound fix suggestion. Suppressed findings carry the suppression axis and rationale, so the agent sees what was reasoned away and why.
Runs the full audytx engine on the provided Terraform files and returns structured findings.
plan argument for resolved-value precision (variables, count, module internals)Applies sound, precisely-anchored fixes to the Terraform files, then re-scans. Loops until clean or no further sound fixes remain (max 3 passes).
Variables, count, and module outputs are opaque to static analysis — var.environment in a tag condition can't be resolved without a plan. Already running terraform plan? Feed it in.
# 1. Generate the plan JSON
terraform init && terraform plan -out plan.tfplan
terraform show -json plan.tfplan > plan.json
# 2. Pass it to scan_terraform
{
"tool": "scan_terraform",
"files": [{ "path": "main.tf", "content": "..." }],
"plan": "{ ... contents of plan.json ... }"
}
Without a plan, audytx marks findings that depend on unresolved values as
Incomplete — it flags what it can prove, not what it guesses. With the plan, those findings become precise.
Both paths run the exact same engine. What differs is the context each one sees.
No repo identity, no diff. The agent passes files directly. No baseline suppressions (no repo to load them from). Best for: catching issues before the PR, in-agent autofix loops, CI-independent checks.
Repo tree fetched at PR time (up to 400 files). Only changed files surface. Baseline suppressions from .audytx-baseline.yaml. SARIF to Code Scanning. One PR comment per scan.
Run both. The agent checks its own work over MCP while it writes; the GitHub App reviews every PR and catches what slipped through, before insecure infrastructure merges.
Independent research finds it is. CodeRabbit measured 1.57× the security findings of human-written code, rising to 2.74× for classes such as XSS. The code compiles and looks correct, so the misconfigurations hide in cross-resource relationships a quick diff review misses.
Add audytx as an MCP server in Claude Code, Cursor, or any MCP-compatible agent, then have the agent call scan_terraform on its Terraform before opening the pull request. autofix_terraform can scan, apply sound fixes, and re-scan in one loop. You can also install the GitHub App to review every pull request.
The MCP server is live and the free tier is free forever. Your agent is one command away from deterministic Terraform security scanning.
claude mcp add --transport http audytx https://audytx.com/mcp