AI agents that process personal data, make decisions, or interact with external systems need audit logs. Not “nice to have” logs. Compliance-grade audit trails that regulators can inspect.

Here’s how to implement audit logging that meets GDPR, SOC 2, HIPAA, and EU AI Act requirements.

Why audit logging matters

Regulators are catching up to AI. The EU AI Act (effective 2025-2026) requires logging of high-risk AI systems. GDPR requires records of data processing. SOC 2 requires access controls and audit trails.

If your AI agent processes personal data, makes decisions affecting users, or operates in a regulated industry, you need audit logs.

What to log

Required events

Event	Data Required	Retention
Agent start	Agent ID, task description, user ID, timestamp	1-3 years
Model invocation	Model name, input tokens, output tokens, cost, timestamp	1-3 years
Tool use	Tool name, input, output, success/failure, timestamp	1-3 years
Data access	Data source, data type, purpose, timestamp	1-3 years
Decision	Decision made, reasoning, confidence, timestamp	1-3 years
Error	Error type, context, resolution, timestamp	1-3 years
Agent end	Status, total cost, duration, output summary, timestamp	1-3 years

Optional but recommended

• Prompt and response (for debugging, may contain PII)
• Chain of thought (reasoning trace)
• User feedback (quality ratings)
• Performance metrics (latency, token usage)

Implementation

Log format

Use structured JSON logging:

import json
from datetime import datetime

class AgentAuditLogger:
    def __init__(self, agent_id, user_id):
        self.agent_id = agent_id
        self.user_id = user_id
    
    def log_event(self, event_type, data):
        entry = {
            'timestamp': datetime.utcnow().isoformat(),
            'event_type': event_type,
            'agent_id': self.agent_id,
            'user_id': self.user_id,
            'data': self.sanitize(data),  # Remove PII if needed
        }
        self.write_to_log(entry)
        self.send_to_monitoring(entry)
    
    def sanitize(self, data):
        """Remove or mask PII from log data."""
        sanitized = data.copy()
        # Mask email addresses
        if 'email' in sanitized:
            sanitized['email'] = self.mask_email(sanitized['email'])
        # Remove raw prompts (may contain PII)
        if 'prompt' in sanitized:
            sanitized['prompt_hash'] = self.hash(sanitized['prompt'])
            del sanitized['prompt']
        return sanitized

Storage

Audit logs must be:

• Append-only: No modification or deletion
• Tamper-evident: Hash chain or digital signatures
• Encrypted: At rest and in transit
• Retained: Per regulatory requirements (1-3 years)

class SecureAuditStorage:
    def __init__(self, storage_backend):
        self.backend = storage_backend
        self.previous_hash = None
    
    def write(self, entry):
        # Add hash chain
        entry['previous_hash'] = self.previous_hash
        entry['hash'] = self.compute_hash(entry)
        self.previous_hash = entry['hash']
        
        # Write to append-only storage
        self.backend.append(entry)

Querying

Audit logs need to be searchable for investigations and compliance reviews:

class AuditQuery:
    def __init__(self, storage):
        self.storage = storage
    
    def query_agent(self, agent_id, start_date, end_date):
        """Get all events for a specific agent."""
        return self.storage.query(
            filter={'agent_id': agent_id, 'timestamp': {'$gte': start_date, '$lte': end_date}}
        )
    
    def query_data_access(self, data_type, start_date, end_date):
        """Get all data access events for a specific data type."""
        return self.storage.query(
            filter={'event_type': 'data_access', 'data.data_type': data_type, 'timestamp': {'$gte': start_date, '$lte': end_date}}
        )
    
    def query_decisions(self, user_id, start_date, end_date):
        """Get all decisions affecting a specific user."""
        return self.storage.query(
            filter={'event_type': 'decision', 'user_id': user_id, 'timestamp': {'$gte': start_date, '$lte': end_date}}
        )

Compliance requirements

Claude Compliance API coverage

As of August 27, 2026, Anthropic describes its expanded Compliance API coverage as a beta for Claude Enterprise, not a generally available observability product. Anthropic says it can return session records from Cowork on desktop, web, and mobile and from Claude Code on CLI and desktop. Depending on the surface, records can include prompts, responses, tool calls, web activity, MCP interactions, skills, artifacts, and associated metadata.

The coverage is deliberately narrower than “all Claude activity.” Anthropic’s current documentation excludes Claude Code on the web, Claude Platform API inference, and Claude used through Amazon Bedrock, Google Vertex AI, or Microsoft Foundry. Microsoft 365 add-in activity is also documented as outside Enterprise audit logs, Compliance API responses, and data exports. Confirm these boundaries against Anthropic’s current Compliance API documentation before designing a retention or investigation workflow.

The Compliance API is an audit and export surface. It is not a replacement for runtime observability:

• Compliance API: retrieves supported Claude Enterprise activity for governance and investigation.
• OpenTelemetry: emits operational metrics and traces from supported applications.
• Inference hooks: observe or govern model requests at integration boundaries.
• Runtime monitoring: detects process, network, credential, and infrastructure events while an agent acts.

Production teams commonly need more than one of these layers. A later compliance export cannot provide the same containment signal as independent, real-time security telemetry.

GDPR (Article 30)

Requirements:

• Records of processing activities
• Purpose of processing
• Categories of data subjects
• Retention periods

Implementation:

# Log data processing activities
audit_logger.log_event('data_processing', {
    'purpose': 'customer_support',
    'data_categories': ['email', 'name', 'support_ticket'],
    'data_subjects': 'customers',
    'retention_days': 365,
})

SOC 2 (Type II)

Requirements:

• Access controls
• Audit logging
• Change management
• Incident response

Implementation:

# Log access control events
audit_logger.log_event('access_control', {
    'resource': 'customer_database',
    'action': 'read',
    'user_id': 'agent_123',
    'result': 'allowed',
})

HIPAA

Requirements:

• PHI access logging
• Audit controls
• Integrity controls
• Transmission security

Implementation:

# Log PHI access
audit_logger.log_event('phi_access', {
    'patient_id': 'masked_id',
    'data_type': 'medical_record',
    'purpose': 'treatment',
    'user_id': 'agent_123',
})

EU AI Act (High-Risk Systems)

Requirements:

• Logging of AI system behavior
• Record-keeping for at least 6 months
• Traceability of decisions
• Human oversight documentation

Implementation:

# Log AI decisions
audit_logger.log_event('ai_decision', {
    'decision': 'approve_loan',
    'reasoning': 'credit_score_above_threshold',
    'confidence': 0.92,
    'human_review': False,
})

Retention policy

Regulation	Minimum Retention	Recommended
GDPR	Duration of processing + 1 year	3 years
SOC 2	1 year	3 years
HIPAA	6 years	7 years
EU AI Act	6 months	2 years

My take

Audit logging is not optional for production AI agents. The regulatory landscape is tightening, and the cost of non-compliance (fines, lawsuits, reputation damage) far exceeds the cost of implementation.

Start with the basics:

1. Log every agent action (start, tool use, decision, end)
2. Use structured JSON format
3. Store in append-only, encrypted storage
4. Retain for 3 years (covers most regulations)

Add compliance-specific logging (GDPR, HIPAA) as needed for your industry.

The biggest mistake is logging too little. You can always delete logs later. You can’t retroactively create logs for events you didn’t capture.

FAQ

Do I need audit logging for a single agent?

If the agent processes personal data, makes decisions affecting users, or operates in a regulated industry: yes. For internal-only agents with no sensitive data: it’s still recommended.

How long should I retain audit logs?

3 years covers most regulations. HIPAA requires 6 years. EU AI Act requires 6 months minimum. Check your specific regulatory requirements.

Can I store audit logs in the same system as the agent?

No. Audit logs should be stored separately, in append-only, tamper-evident storage. If the agent’s system is compromised, the audit logs must remain intact.

How do I handle PII in audit logs?

Mask or remove PII before logging. Hash prompts and responses. Use tokenization for identifiers. Never log raw personal data in audit logs.

What’s the minimum audit logging for SOC 2?

Access controls (who accessed what), change management (what changed), and incident response (what went wrong). Log every access, every change, and every incident.

Related Articles

• AI Agent Security
• AI Agent Governance Framework
• Production Agent Deployment Checklist
• AI Compliance Automation
• Agent Sandboxing at Scale