AI Hallucinations Will Cause More Production Outages Than Human Errors by 2027: 2026 Data

import os
import re
import json
import subprocess
from typing import List, Dict, Optional
from dataclasses import dataclass

# Data class to represent a detected hallucination in infrastructure code
@dataclass
class HallucinationFinding:
    file_path: str
    line_number: int
    severity: str  # "HIGH", "MEDIUM", "LOW"
    description: str
    suggested_fix: str

class TerraformHallucinationDetector:
    """Detects AI-generated hallucinated resources, attributes, and dependencies in Terraform code."""

    def __init__(self, terraform_version: str = "1.7.0"):
        self.terraform_version = terraform_version
        # Load official Terraform resource schema for validation (cached from GitHub)
        self.official_schemas = self._load_official_schemas()
        self.hallucinations: List[HallucinationFinding] = []

    def _load_official_schemas(self) -> Dict:
        """Fetch official Terraform provider schemas from https://github.com/hashicorp/terraform-provider-aws"""
        schema_path = os.path.join(os.path.dirname(__file__), "aws_schemas.json")
        if not os.path.exists(schema_path):
            raise FileNotFoundError(
                f"Official AWS Terraform schemas not found at {schema_path}. "
                "Download from https://github.com/hashicorp/terraform-provider-aws/releases"
            )
        with open(schema_path, "r") as f:
            return json.load(f)

    def scan_file(self, file_path: str) -> List[HallucinationFinding]:
        """Scan a single Terraform file for hallucinated resources."""
        if not os.path.exists(file_path):
            raise FileNotFoundError(f"Terraform file {file_path} does not exist")
        if not file_path.endswith(".tf"):
            raise ValueError(f"File {file_path} is not a Terraform file (.tf extension required)")

        with open(file_path, "r") as f:
            content = f.readlines()

        for line_idx, line in enumerate(content, start=1):
            # Skip comments and blank lines
            if line.strip().startswith("#") or not line.strip():
                continue
            # Detect resource blocks
            resource_match = re.match(r'resource\s+"([^"]+)"\s+"([^"]+)"\s+{', line)
            if resource_match:
                resource_type = resource_match.group(1)
                resource_name = resource_match.group(2)
                # Check if resource type exists in official schema
                if resource_type not in self.official_schemas:
                    self.hallucinations.append(
                        HallucinationFinding(
                            file_path=file_path,
                            line_number=line_idx,
                            severity="HIGH",
                            description=f"Hallucinated Terraform resource type: {resource_type}",
                            suggested_fix=f"Replace with valid resource type from https://github.com/hashicorp/terraform-provider-aws"
                        )
                    )
                # Scan resource attributes for hallucinated fields
                self._scan_resource_attributes(content, line_idx, resource_type, file_path)
        return self.hallucinations

    def _scan_resource_attributes(self, content: List[str], start_line: int, resource_type: str, file_path: str):
        """Scan resource block attributes for invalid fields."""
        # Simple block parsing: find closing } for the resource
        brace_count = 1
        current_line = start_line
        while current_line < len(content) and brace_count > 0:
            current_line += 1
            line = content[current_line]
            if "{" in line:
                brace_count += 1
            if "}" in line:
                brace_count -= 1
            # Check for attribute assignments
            attr_match = re.match(r'\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*.+', line)
            if attr_match:
                attr_name = attr_match.group(1)
                # Check if attribute exists in official schema for the resource type
                valid_attrs = self.official_schemas.get(resource_type, {}).get("attributes", [])
                if attr_name not in valid_attrs and not attr_name.startswith("lifecycle"):
                    self.hallucinations.append(
                        HallucinationFinding(
                            file_path=file_path,
                            line_number=current_line + 1,  # 1-indexed
                            severity="MEDIUM",
                            description=f"Hallucinated attribute {attr_name} for resource {resource_type}",
                            suggested_fix=f"Remove invalid attribute or check https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/{resource_type.split(".")[1] if "." in resource_type else resource_type}"
                        )
                    )

    def generate_report(self, output_path: str = "hallucination_report.json"):
        """Generate a JSON report of all detected hallucinations."""
        report = {
            "scan_timestamp": subprocess.check_output(["date", "+%Y-%m-%dT%H:%M:%S"]).decode().strip(),
            "terraform_version": self.terraform_version,
            "total_findings": len(self.hallucinations),
            "findings": [vars(f) for f in self.hallucinations]
        }
        with open(output_path, "w") as f:
            json.dump(report, f, indent=2)
        print(f"Report generated at {output_path}")

if __name__ == "__main__":
    try:
        detector = TerraformHallucinationDetector(terraform_version="1.7.0")
        # Scan all .tf files in the current directory
        for root, dirs, files in os.walk("."):
            for file in files:
                if file.endswith(".tf"):
                    file_path = os.path.join(root, file)
                    print(f"Scanning {file_path}...")
                    detector.scan_file(file_path)
        detector.generate_report()
        print(f"Detected {len(detector.hallucinations)} potential hallucinations")
    except Exception as e:
        print(f"Scan failed: {str(e)}")
        exit(1)

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
    "sync"

    "github.com/getkin/kin-openapi/openapi3"
    "github.com/sashabaranov/go-openai"
)

// HallucinationValidator validates AI-generated API responses against OpenAPI schemas
type HallucinationValidator struct {
    openaiClient *openai.Client
    schemaLoader *openapi3.Loader
    schemas      map[string]*openapi3.SchemaRef
    mu           sync.RWMutex
}

// NewHallucinationValidator initializes a new validator with OpenAI client and schema loader
func NewHallucinationValidator(openaiKey string, schemaDir string) (*HallucinationValidator, error) {
    if openaiKey == "" {
        return nil, fmt.Errorf("openai API key is required")
    }
    client := openai.NewClient(openaiKey)
    loader := openapi3.NewLoader()
    schemas := make(map[string]*openapi3.SchemaRef)

    // Load all OpenAPI schemas from the provided directory
    files, err := os.ReadDir(schemaDir)
    if err != nil {
        return nil, fmt.Errorf("failed to read schema directory: %w", err)
    }
    for _, file := range files {
        if !strings.HasSuffix(file.Name(), ".json") {
            continue
        }
        schemaPath := fmt.Sprintf("%s/%s", schemaDir, file.Name())
        doc, err := loader.LoadFromFile(schemaPath)
        if err != nil {
            return nil, fmt.Errorf("failed to load schema %s: %w", schemaPath, err)
        }
        // Extract schema name from file name (e.g., user-api.json -> user-api)
        schemaName := strings.TrimSuffix(file.Name(), ".json")
        schemas[schemaName] = doc.Components.Schemas[schemaName]
    }

    return &HallucinationValidator{
        openaiClient: client,
        schemaLoader: loader,
        schemas:      schemas,
    }, nil
}

// ValidateAIResponse sends a prompt to OpenAI, then validates the response against a schema
func (v *HallucinationValidator) ValidateAIResponse(ctx context.Context, prompt string, schemaName string) (map[string]interface{}, []string, error) {
    v.mu.RLock()
    schema, exists := v.schemas[schemaName]
    v.mu.RUnlock()
    if !exists {
        return nil, nil, fmt.Errorf("schema %s not found", schemaName)
    }

    // Generate AI response
    resp, err := v.openaiClient.CreateChatCompletion(
        ctx,
        openai.ChatCompletionRequest{
            Model: openai.GPT4o,
            Messages: []openai.ChatCompletionMessage{
                {
                    Role:    openai.ChatMessageRoleUser,
                    Content: prompt,
                },
            },
            ResponseFormat: &openai.ChatCompletionResponseFormat{
                Type: openai.ChatCompletionResponseFormatTypeJSONObject,
            },
        },
    )
    if err != nil {
        return nil, nil, fmt.Errorf("openai request failed: %w", err)
    }

    // Parse response content
    content := resp.Choices[0].Message.Content
    var responseData map[string]interface{}
    if err := json.Unmarshal([]byte(content), &responseData); err != nil {
        return nil, nil, fmt.Errorf("failed to parse AI response JSON: %w", err)
    }

    // Validate response against schema
    validationErrors := v.validateAgainstSchema(responseData, schema.Value, "")
    return responseData, validationErrors, nil
}

// validateAgainstSchema recursively checks response data against the expected schema
func (v *HallucinationValidator) validateAgainstSchema(data interface{}, schema *openapi3.Schema, path string) []string {
    var errors []string

    // Check for extra fields not in schema
    if obj, ok := data.(map[string]interface{}); ok {
        for field := range obj {
            if _, exists := schema.Properties[field]; !exists {
                errors = append(errors, fmt.Sprintf("hallucinated field %s%s not defined in schema", path, field))
            }
        }
        // Recursively validate existing fields
        for field, propSchema := range schema.Properties {
            if fieldData, exists := obj[field]; exists {
                fieldErrors := v.validateAgainstSchema(fieldData, propSchema.Value, fmt.Sprintf("%s%s.", path, field))
                errors = append(errors, fieldErrors...)
            } else if schema.Required.Contains(field) {
                errors = append(errors, fmt.Sprintf("missing required field %s%s", path, field))
            }
        }
    }

    // Check array items
    if arr, ok := data.([]interface{}); ok && schema.Items != nil {
        for idx, item := range arr {
            itemErrors := v.validateAgainstSchema(item, schema.Items.Value, fmt.Sprintf("%s[%d].", path, idx))
            errors = append(errors, itemErrors...)
        }
    }

    return errors
}

func main() {
    openaiKey := os.Getenv("OPENAI_API_KEY")
    if openaiKey == "" {
        fmt.Println("OPENAI_API_KEY environment variable is required")
        os.Exit(1)
    }

    validator, err := NewHallucinationValidator(openaiKey, "./openapi-schemas")
    if err != nil {
        fmt.Printf("Failed to initialize validator: %v\n", err)
        os.Exit(1)
    }

    // Example: Validate AI-generated user profile response
    prompt := "Generate a JSON user profile for user ID 12345 with fields: id, name, email, role"
    response, errors, err := validator.ValidateAIResponse(context.Background(), prompt, "user-api")
    if err != nil {
        fmt.Printf("Validation failed: %v\n", err)
        os.Exit(1)
    }

    if len(errors) > 0 {
        fmt.Printf("Detected %d hallucinated fields:\n", len(errors))
        for _, err := range errors {
            fmt.Printf("- %s\n", err)
        }
    } else {
        fmt.Println("AI response is valid against schema")
        json.NewEncoder(os.Stdout).Encode(response)
    }
}

import React, { useState, useEffect, useCallback } from "react";
import { ChatCompletionMessage } from "openai/resources/chat/completions";
import OpenAI from "openai";

// Types for documentation validation results
type DocValidationResult = {
  url: string;
  isValid: boolean;
  status?: number;
  error?: string;
};

type HallucinatedDoc = {
  messageId: string;
  originalUrl: string;
  suggestion: string;
  validationResult: DocValidationResult;
};

// Official documentation sources to validate against
const OFFICIAL_DOC_SOURCES = [
  "https://developer.mozilla.org",
  "https://nodejs.org/docs",
  "https://react.dev",
  "https://github.com/facebook/react",
  "https://github.com/microsoft/TypeScript",
];

const AI_CHAT_HALLUCINATION_DETECTOR_GITHUB = "https://github.com/yourusername/ai-chat-hallucination-detector";

const openai = new OpenAI({
  apiKey: process.env.REACT_APP_OPENAI_API_KEY,
  dangerouslyAllowBrowser: true, // Only for demo, use backend proxy in production
});

export const AIChatDocumentationValidator: React.FC = () => {
  const [messages, setMessages] = useState([]);
  const [input, setInput] = useState("");
  const [hallucinatedDocs, setHallucinatedDocs] = useState([]);
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState(null);

  // Extract URLs from AI response text
  const extractUrls = useCallback((text: string): string[] => {
    const urlRegex = /https?:\/\/[^\s<>"']+/g;
    const matches = text.match(urlRegex) || [];
    // Filter to only documentation URLs from official sources
    return matches.filter((url) =>
      OFFICIAL_DOC_SOURCES.some((source) => url.startsWith(source))
    );
  }, []);

  // Validate a single URL against the official source
  const validateUrl = useCallback(
    async (url: string): Promise => {
      try {
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 5000);

        const response = await fetch(url, {
          method: "HEAD",
          signal: controller.signal,
        });
        clearTimeout(timeoutId);

        return {
          url,
          isValid: response.ok,
          status: response.status,
        };
      } catch (err) {
        return {
          url,
          isValid: false,
          error: err instanceof Error ? err.message : "Unknown error",
        };
      }
    },
    []
  );

  // Handle sending a message to the AI and validating responses
  const handleSendMessage = useCallback(async () => {
    if (!input.trim()) return;

    setIsLoading(true);
    setError(null);

    try {
      const userMessage: ChatCompletionMessage = {
        role: "user",
        content: input,
      };
      const updatedMessages = [...messages, userMessage];
      setMessages(updatedMessages);
      setInput("");

      const response = await openai.chat.completions.create({
        model: "gpt-4o",
        messages: updatedMessages.map((msg) => ({
          role: msg.role,
          content: msg.content || "",
        })),
      });

      const aiMessage = response.choices[0].message;
      setMessages([...updatedMessages, aiMessage]);

      // Extract and validate URLs from the AI response
      const aiText = aiMessage.content || "";
      const urls = extractUrls(aiText);
      const validationResults = await Promise.all(urls.map(validateUrl));

      // Flag invalid URLs as hallucinations
      const newHallucinations = validationResults
        .filter((result) => !result.isValid)
        .map((result) => ({
          messageId: aiMessage.id || crypto.randomUUID(),
          originalUrl: result.url,
          suggestion: `Replace with valid URL from ${OFFICIAL_DOC_SOURCES.join(", ")}`,
          validationResult: result,
        }));

      setHallucinatedDocs((prev) => [...prev, ...newHallucinations]);
    } catch (err) {
      setError(
        err instanceof Error ? err.message : "Failed to send message to AI"
      );
    } finally {
      setIsLoading(false);
    }
  }, [input, messages, extractUrls, validateUrl]);

  // Clear all hallucinations
  const clearHallucinations = useCallback(() => {
    setHallucinatedDocs([]);
  }, []);

  return (

      AI Chat Documentation Hallucination Detector

        Validates AI-generated documentation links against official sources. See
        the source code at {AI_CHAT_HALLUCINATION_DETECTOR_GITHUB}



        {messages.map((msg, idx) => (

            {msg.role}: {msg.content}

        ))}


      {error && {error}}


         setInput(e.target.value)}
          onKeyPress={(e) => e.key === "Enter" && handleSendMessage()}
          placeholder="Ask the AI a technical question..."
          disabled={isLoading}
        />

          {isLoading ? "Sending..." : "Send"}



      {hallucinatedDocs.length > 0 && (


            Detected {hallucinatedDocs.length} Hallucinated Documentation Links

          Clear Report

            {hallucinatedDocs.map((doc, idx) => (

                Invalid URL: {doc.originalUrl}

                Reason: {doc.validationResult.error || `HTTP ${doc.validationResult.status}`}

                Suggestion: {doc.suggestion}

            ))}


      )}

  );
};

export default AIChatDocumentationValidator;

// Always pin to exact model version, never use aliases like "gpt-4o"
const completion = await openai.chat.completions.create({
  model: "gpt-4o-2024-08-06", // Exact version, not "gpt-4o"
  messages: [{ role: "user", content: "Generate Terraform AWS S3 bucket resource" }],
  temperature: 0.1, // Lower temperature reduces hallucination likelihood
});

import Ajv from "ajv";
import addFormats from "ajv-formats";

const ajv = new Ajv({ allErrors: true });
addFormats(ajv);

// Load canonical user schema from official API docs
const userSchema = {
  type: "object",
  properties: {
    id: { type: "string" },
    name: { type: "string" },
    email: { type: "string", format: "email" },
  },
  required: ["id", "name", "email"],
  additionalProperties: false, // Reject hallucinated fields
};

const validate = ajv.compile(userSchema);
const aiResponse = { id: "123", name: "Alice", email: "alice@example.com", role: "admin" }; // Hallucinated "role"
if (!validate(aiResponse)) {
  console.error("AI response has hallucinations:", validate.errors);
}

name: Detect Terraform Hallucinations
on: [pull_request]

jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - name: Install dependencies
        run: pip install -r requirements.txt
      - name: Run hallucination detector
        run: python terraform_hallucination_detector.py
      - name: Check for findings
        run: |
          if [ -f hallucination_report.json ]; then
            COUNT=$(jq '.total_findings' hallucination_report.json)
            if [ $COUNT -gt 0 ]; then
              echo "Detected $COUNT hallucinations, failing CI"
              exit 1
            fi
          fi