Policy Enforcement: Setting & Enforcing Boundaries

Overview

Policies define what agents can and cannot do. Enforcement ensures policies are actually followed.

---

Declarative Policies

class PolicyEngine:
    def __init__(self):
        self.policies = {
            "no_production_deletes": {
                "rule": "NOT (action=='delete' AND database=='production')",
                "severity": "CRITICAL",
                "action": "block"
            },
            "access_control": {
                "rule": "user.role == 'admin' OR NOT resource.is_sensitive",
                "severity": "HIGH",
                "action": "require_approval"
            },
            "data_handling": {
                "rule": "NOT contains_pii(output)",
                "severity": "HIGH",
                "action": "filter"
            }
        }

    def check(self, action: dict, context: dict) -> str:
        """Check if action violates policies"""

        for policy_name, policy in self.policies.items():
            if not self.evaluate_rule(policy['rule'], action, context):
                self.log_violation(policy_name, action, context)

                if policy['severity'] == 'CRITICAL':
                    return 'block'
                else:
                    return policy['action']

        return 'allow'

---

Access Control

class ACLEngine:
    def can_access(self, user, resource, action):
        """Check if user can perform action on resource"""

        # Get user's role
        role = user.role

        # Get resource's access requirements
        required_role = resource.access_level

        # Check permission
        if role_hierarchy[role] >= role_hierarchy[required_role]:
            return True

        # Check resource-specific ACL
        if resource.acl and user.id in resource.acl[action]:
            return True

        return False

---

Violation Handling

class ViolationHandler:
    def handle_violation(self, policy, action, context):
        """Handle policy violation"""

        if policy['action'] == 'block':
            self.log_blocked(policy, action)
            raise PermissionError(f"Policy violation: {policy['name']}")

        elif policy['action'] == 'filter':
            self.log_filtered(policy, action)
            return self.apply_filter(action, policy)

        elif policy['action'] == 'require_approval':
            self.log_needs_approval(policy, action)
            return self.request_approval(action, context)

---

3 Warnings ⚠️

Warning 1: Policy Bypass

# ❌ WRONG
if user.is_admin():
    # Skip all policy checks
    execute_action(action)

# Dangerous if admin account compromised!

# ✅ RIGHT
# Even admins subject to critical policies
critical_policies = [
    "no_mass_delete",
    "audit_all_access",
    "no_disable_logging"
]

if policy.severity == 'CRITICAL':
    enforce(policy)  # Always enforce
elif user.is_admin():
    skip_approval()  # But skip approval

Warning 2: Policy Explosion

# ❌ WRONG: Too many overlapping policies
policies = [
    "no_delete",
    "no_delete_important",
    "no_delete_important_production",
    "no_delete_important_production_users",
    # ...30 more policies
]
# Hard to reason about, maintenance nightmare

# ✅ RIGHT: Hierarchical policies
policies = {
    "data_protection": {
        "level1": "no_access_personal_data",
        "level2": "no_delete_production",
        "level3": "no_modify_audit_logs"
    }
}

Warning 3: Silent Failures

# ❌ WRONG
if not policy_check(action):
    return  # Silently fails

# User doesn't know why action didn't work

# ✅ RIGHT
if not policy_check(action):
    return {
        "error": "Action not allowed",
        "policy": "no_production_deletes",
        "reason": "Cannot delete production database",
        "contact": "security-team@company.com"
    }

---

Last Updated: August 9, 2026