agent OrderProcessor {
    can fetch order
    can validate items
    can process payment
}

agent SmartProcessor {
    can process order when validated
    can send notification if successful
}

agent ComplianceAgent {
    must validate input
    must log transaction
    must verify signature
}

agent SecurityAgent {
    must authenticate when accessing_secure_data
    must encrypt when storing_sensitive_info
    must audit_log when making_changes
}

agent BestPracticeAgent {
    should validate input
    should cache results
    should retry when failed
}

agent PermissionedAgent {
    may access premium_features when subscribed
    may export data if authorized
    may modify settings
}

agent PromiseAgent {
    will send confirmation
    will update status
    will notify subscribers
}

agent FormalAgent {
    shall comply with regulations
    shall maintain audit trail
    shall verify credentials
}

agent RestrictedAgent {
    cannot delete user_data
    cannot proceed if unauthorized
    cannot modify when locked
}

agent PaymentProcessor {
    # Required operations
    must validate card_details
    must encrypt payment_info
    must log transaction
    
    # Standard capabilities
    can process payment when validated
    can retry payment if declined
    
    # Best practices
    should notify customer when complete
    should cache validation results
    
    # Permissions
    may issue refund if authorized
    
    # Commitments
    will send receipt
    will update order status
    
    # Prohibitions
    cannot store raw_card_numbers
    cannot proceed if fraud_detected
}

agent ContentModerator {
    # Required checks
    must scan for prohibited_content
    must flag suspicious_activity
    must log moderation_actions
    
    # Capabilities
    can auto_approve when clearly_safe
    can auto_reject when clearly_violates
    
    # Best practices
    should escalate when uncertain
    should provide feedback to users
    
    # Commitments
    will review flagged_content
    will notify users of decisions
    
    # Formal requirements
    shall comply with content_policy
    shall maintain moderation_records
    
    # Prohibitions
    cannot publish without_review
    cannot delete without_logging
}

agent DataManager {
    # Critical operations
    must validate data_integrity
    must backup before_modifications
    must verify permissions
    
    # Standard operations
    can read data when authorized
    can write data if validated
    can transform data
    
    # Recommendations
    should cache frequently_accessed_data
    should compress large_datasets
    should clean old_data
    
    # Optional features
    may export to external_systems if configured
    may archive old_records
    
    # Guarantees
    will maintain consistency
    will log all operations
    
    # Restrictions
    cannot delete without_confirmation
    cannot expose sensitive_data
    cannot bypass audit_logging
}

agent ComplexAgent {
    # Phase 1: Validation (required)
    must validate input
    cannot proceed if invalid
    
    # Phase 2: Processing (capability)
    can process data when validated
    should optimize processing
    
    # Phase 3: Persistence (requirement)
    must save results
    must log completion
    
    # Phase 4: Notification (commitment)
    will notify success
    should send summary_email
    
    # Permissions
    may trigger downstream_process if configured
}

agent WellDesignedAgent {
    # 1. Required validations
    must validate input
    cannot proceed if invalid
    
    # 2. Core processing
    can process data
    should optimize processing
    
    # 3. Required outputs
    must save results
    will notify completion
    
    # 4. Optional enhancements
    may export results if requested
}

agent ConditionalAgent {
    can process when ready
    must validate when receiving_input
    should cache when frequently_accessed
    cannot modify when locked
}

agent LogicalAgent {
    can approve if criteria_met
    must reject if policy_violated
    should warn if threshold_exceeded
    may proceed if authorized
}

workflow OrderFlow {
    state pending -> processing
    state processing -> completed
}

agent OrderAgent {
    must validate when pending
    can process when validated
    will update_status to completed
    cannot cancel when completed
}

role AdminRole {
    permission system {
        manage
    }
}

agent SystemAdmin: AdminRole {
    can configure system
    must backup before_changes
    should test configuration
    cannot expose credentials
}