agent ConditionalAgent {
    can process if valid
    can approve if criteria_met
    must reject if policy_violated
    cannot proceed if unauthorized
}

agent SmartAgent {
    can execute if authorized and validated
    can approve if criteria_met or override_enabled
    cannot proceed if not ready
}

agent StateAgent {
    can process when ready
    must validate when receiving_input
    can notify when completed
    should cleanup when finished
}

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

agent OrderAgent {
    can accept when pending
    can process when validated
    must notify when completed
}

agent ExampleAgent {
    # Logical condition - checks a boolean value
    can approve if criteria_met
    
    # State condition - checks current state
    can process when in_ready_state
    
    # Combined
    can execute when ready and if authorized
}

agent LoopingAgent {
    can retry while attempts_remaining
    should process while items_pending
    must validate while data_available
}

agent IteratorAgent {
    can process for each item in collection
    must validate for all records in dataset
    should notify for every user in list
}

agent BatchProcessor {
    can transform for each document in batch
    must check for all entries in queue
    should aggregate for every value in results
}

agent CollectionAgent {
    can process each of items
    must validate all of records
    should update any of pending_tasks
}

agent LogicalAgent {
    can execute if authorized and validated
    can proceed when ready and if approved
    must check if valid and if complete
}

agent MultiConditionAgent {
    can approve if authenticated and authorized and validated
    must reject if expired or invalid or unauthorized
}

agent AlternativeAgent {
    can proceed if admin or owner
    can approve if manager or supervisor
    should notify if urgent or high_priority
}

agent NegationAgent {
    can proceed if not blocked
    cannot execute if not authorized
    should warn if not validated
}

agent ComplexAgent {
    can execute if authorized and not suspended
    can approve if valid or not strict_mode
    must reject if not authenticated and not public_access
}

agent ComplexConditionAgent {
    # AND + OR
    can approve if (admin or manager) and validated
    
    # NOT + AND
    can execute if authorized and not suspended
    
    # Complex combination
    can proceed if (authenticated and validated) or (admin and not restricted)
}

agent NestedAgent {
    can process if valid and (
        (premium_user and feature_enabled) or
        (admin and override_mode)
    )
}

agent AccessController {
    # Simple conditions
    can view if authenticated
    can edit if owner
    can delete if admin
    
    # Combined conditions
    can moderate if admin or moderator
    can publish if editor and approved
    
    # Negation
    cannot access if suspended
    cannot modify if locked or archived
    
    # Complex logic
    can approve if (
        (manager and department_match) or
        (admin and not restricted)
    ) and not suspended
}

agent OrderProcessor {
    # State conditions
    can accept when pending
    can validate when received
    can process when validated
    
    # Logical conditions
    can ship if payment_completed and stock_available
    can cancel if not shipped
    
    # Combined
    can refund when delivered and if within_refund_period
    cannot refund if damaged or used
    
    # Complex business logic
    can express_ship if (
        premium_customer or express_selected
    ) and stock_available and not restricted_item
}

agent ContentModerator {
    # Auto-approval logic
    can auto_approve if (
        trusted_user and
        not flagged and
        content_score_high
    )
    
    # Auto-rejection logic
    must auto_reject if (
        contains_prohibited_words or
        spam_detected or
        duplicate_content
    )
    
    # Escalation logic
    should escalate if (
        not clearly_safe and not clearly_unsafe
    ) or (
        flagged_by_users and flag_count_high
    )
    
    # Special handling
    can bypass_check if admin and emergency_mode
    cannot publish if not reviewed or flagged
}

agent WorkflowAutomation {
    # Iteration
    can process for each task in queue
    must validate for all items in batch
    
    # Looping
    can retry while attempts_remaining and not succeeded
    should backoff while rate_limited
    
    # State-based
    can advance when prerequisites_met
    must checkpoint when phase_complete
    
    # Conditional routing
    can route_to_fast_track if (
        simple_case and auto_approved
    ) or priority_customer
    
    can route_to_manual_review if (
        complex_case or flagged
    ) and not auto_processable
}

# This:
can execute if not blocked and ready or override

# Is equivalent to:
can execute if ((not blocked) and ready) or override

# For clarity, use explicit grouping:
can execute if (not blocked and ready) or override

agent GuardedAgent {
    # Prevent execution
    cannot proceed if not initialized
    cannot execute if suspended or locked
    
    # Allow only when ready
    can process when initialized and if configured
}

agent FallbackAgent {
    can use_primary_method if available
    can use_backup_method if primary_failed or not available
    can use_emergency_fallback if all_methods_failed
}

agent ProgressiveAgent {
    # Basic functionality
    can basic_process if authenticated
    
    # Enhanced functionality
    can advanced_process if premium_user
    
    # Full functionality
    can full_featured_process if enterprise_user and feature_enabled
}