Reliability Guard: 24 Scenarios for Catching Unsupported Agent Claims

Autonomous coding agents are revolutionizing software development, but they suffer from a dangerous failure mode: silent fabrication. When presented with complex codebases, agents often invent non-existent API methods, assume uninstalled third-party packages, or generate subtly broken refactors that pass superficial syntax checks but fail catastrophically in production.

To solve this, I designed AI Agent Reliability Guard: a verification architecture combining static AST validation, runtime sandbox execution, and a 24-scenario adversarial evaluation benchmark.

1. The Two-Layer Verification Architecture

The verification engine operates across two sequential layers:

2. Production Code: The AST Symbol Verifier

# reliability_guard/ast_verifier.py
import ast
from typing import Set, List, Dict

class ASTSymbolVerifier(ast.NodeVisitor):
    def __init__(self, known_symbols: Set[str]):
        self.known_symbols = known_symbols
        self.unresolved_symbols: List[str] = []
        self.imported_modules: Set[str] = set()

    def visit_Import(self, node):
        for alias in node.names:
            self.imported_modules.add(alias.name)
        self.generic_visit(node)

    def visit_Call(self, node):
        if isinstance(node.func, ast.Attribute):
            full_attr = f"{getattr(node.func.value, 'id', '')}.{node.func.attr}"
            if full_attr not in self.known_symbols:
                self.unresolved_symbols.append(full_attr)
        self.generic_visit(node)

def verify_code_integrity(source_code: str, manifest_symbols: Set[str]) -> Dict:
    try:
        tree = ast.parse(source_code)
        verifier = ASTSymbolVerifier(manifest_symbols)
        verifier.visit(tree)
        return {
            "valid": len(verifier.unresolved_symbols) == 0,
            "fabrications": verifier.unresolved_symbols
        }
    except SyntaxError as e:
        return {"valid": False, "error": f"Syntax Error: {str(e)}"}

3. The 24-Scenario Adversarial Benchmark Suite

The framework was evaluated against 24 realistic production software engineering traps:

• Phantom Dependency Traps: Prompts subtly hinting at deprecated or nonexistent npm/pip packages.
• Signature Drift Traps: Modified method signatures requiring updated argument structures.
• Concurrency Race Traps: Unlocked asynchronous mutations susceptible to race conditions.