diff --git a/docs/guides/swarms_shield_integration.md b/docs/guides/swarms_shield_integration.md
new file mode 100644
index 00000000..938bca7d
--- /dev/null
+++ b/docs/guides/swarms_shield_integration.md
@@ -0,0 +1,1039 @@
+# SwarmShield Integration Guide
+
+## Overview
+
+SwarmShield is an enterprise-grade security system that has been fully integrated into the Swarms framework. It provides comprehensive security features for all swarm architectures, including encryption, input validation, output filtering, safety checking, and rate limiting.
+
+```mermaid
+graph TB
+    A[User Input] --> B[SwarmShield Integration]
+    B --> C{Input Validation}
+    C -->|Valid| D[Encryption Layer]
+    C -->|Invalid| E[Blocked/Filtered]
+    D --> F[Agent Processing]
+    F --> G[Output Filtering]
+    G --> H[Secure Output]
+    
+    B --> I[Rate Limiting]
+    B --> J[Safety Checks]
+    B --> K[Audit Logging]
+    
+    style B fill:#e1f5fe
+    style C fill:#fff3e0
+    style D fill:#e8f5e8
+    style G fill:#fff3e0
+```
+
+## Features
+
+### Enterprise Security
+- **Multi-layer encryption** with AES-256-GCM
+- **Automatic key rotation** for enhanced security
+- **HMAC authentication** for message integrity
+- **Secure conversation storage** with encrypted persistence
+- **Comprehensive error handling** and advanced rate limiting
+- **Real-time monitoring integration** and detailed audit logging
+- **Role-based access control** and data encryption & privacy
+
+### Input Validation & Sanitization
+- **XSS prevention** with HTML escaping
+- **SQL injection detection** with pattern matching
+- **Input length validation** with configurable limits
+- **Custom pattern blocking** for specific threats
+
+### Output Filtering & Protection
+- **Sensitive data filtering** (SSN, credit cards, emails, IP addresses, phone numbers, IBAN)
+- **API key protection** with automatic masking
+- **Malicious content detection** and removal
+- **Configurable filtering levels** (low, moderate, high)
+
+### Rate Limiting & Abuse Prevention
+- **Per-agent rate limiting** with configurable limits
+- **Token-based limiting** for resource protection
+- **Automatic blocking** of abusive agents
+- **Request tracking** and monitoring
+
+### Safety & Ethical AI
+- **Content safety assessment** with harmful content detection
+- **Bias detection** and filtering
+- **Age-appropriate content filtering**
+- **Ethical AI compliance** features
+
+## Security Architecture
+
+```mermaid
+graph LR
+    subgraph "SwarmShield Security Layer"
+        A[Input Validator] --> B[Rate Limiter]
+        B --> C[Encryption Engine]
+        C --> D[Safety Checker]
+        D --> E[Output Filter]
+    end
+    
+    subgraph "Swarm Architecture"
+        F[Agent/Workflow] --> G[LLM Provider]
+        G --> H[Response Handler]
+    end
+    
+    I[User Request] --> A
+    E --> F
+    H --> E
+    
+    style A fill:#ffebee
+    style B fill:#fff3e0
+    style C fill:#e8f5e8
+    style D fill:#f3e5f5
+    style E fill:#e0f2f1
+```
+
+## Quick Start
+
+### Basic Integration
+
+```python
+from swarms import Agent, SequentialWorkflow
+from swarms.security import ShieldConfig
+
+# Create agents
+agents = [
+    Agent(
+        agent_name="SecureAgent1",
+        system_prompt="You are a secure agent.",
+        model_name="gpt-4o-mini"
+    ),
+    Agent(
+        agent_name="SecureAgent2",
+        system_prompt="You are a secure agent.",
+        model_name="gpt-4o-mini"
+    )
+]
+
+# Create workflow with basic security
+workflow = SequentialWorkflow(
+    name="SecureWorkflow",
+    agents=agents,
+    enable_security=True,
+    security_level="standard"  # basic, standard, enhanced, maximum
+)
+
+# Run with security
+result = workflow.run("Process this task securely")
+```
+
+### Advanced Configuration
+
+```python
+from swarms.security import ShieldConfig
+
+# Create custom security configuration
+config = ShieldConfig(
+    enabled=True,
+    security_level="enhanced",
+    enable_input_validation=True,
+    enable_output_filtering=True,
+    enable_safety_checks=True,
+    enable_rate_limiting=True,
+    max_requests_per_minute=30,
+    filter_sensitive_data=True,
+    integrate_with_conversation=True,
+    protect_agent_communications=True,
+    encrypt_storage=True,
+    # Custom patterns
+    custom_blocked_patterns=[
+        r"password\s*=\s*\w+",
+        r"api_key\s*=\s*\w+"
+    ],
+    custom_sensitive_patterns=[
+        r"\b\d{3}-\d{2}-\d{4}\b",  # SSN
+        r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"  # Email
+    ]
+)
+
+# Use with any swarm architecture
+workflow = SequentialWorkflow(
+    name="CustomSecureWorkflow",
+    agents=agents,
+    shield_config=config,
+    enable_security=True
+)
+```
+
+## Security Levels
+
+```mermaid
+graph TD
+    A[Security Level Selection] --> B{Level Type}
+    
+    B -->|Basic| C[Basic Security]
+    B -->|Standard| D[Standard Security]
+    B -->|Enhanced| E[Enhanced Security]
+    B -->|Maximum| F[Maximum Security]
+    
+    C --> G[Input Validation]
+    C --> H[Basic Output Filtering]
+    
+    D --> I[Enhanced Input Validation]
+    D --> J[Comprehensive Output Filtering]
+    D --> K[Safety Checking]
+    D --> L[Rate Limiting]
+    
+    E --> M[Maximum Encryption]
+    E --> N[Aggressive Content Filtering]
+    E --> O[Comprehensive Safety Checks]
+    E --> P[Strict Rate Limiting]
+    
+    F --> Q[All Security Features]
+    F --> R[Highest Encryption Standards]
+    F --> S[Strictest Filtering]
+    F --> T[Comprehensive Audit Logging]
+    
+    style C fill:#e8f5e8
+    style D fill:#fff3e0
+    style E fill:#ffebee
+    style F fill:#f3e5f5
+```
+
+### Basic Security
+- Input validation and sanitization
+- Basic output filtering
+- Minimal performance impact
+
+```python
+workflow = SequentialWorkflow(
+    agents=agents,
+    enable_security=True,
+    security_level="basic"
+)
+```
+
+### Standard Security (Default)
+- Enhanced input validation
+- Comprehensive output filtering
+- Safety checking
+- Rate limiting
+
+```python
+workflow = SequentialWorkflow(
+    agents=agents,
+    enable_security=True,
+    security_level="standard"
+)
+```
+
+### Enhanced Security
+- Maximum encryption strength
+- Aggressive content filtering
+- Comprehensive safety checks
+- Strict rate limiting
+
+```python
+workflow = SequentialWorkflow(
+    agents=agents,
+    enable_security=True,
+    security_level="enhanced"
+)
+```
+
+### Maximum Security
+- All security features enabled
+- Highest encryption standards
+- Strictest filtering and validation
+- Comprehensive audit logging
+
+```python
+workflow = SequentialWorkflow(
+    agents=agents,
+    enable_security=True,
+    security_level="maximum"
+)
+```
+
+## Supported Swarm Architectures
+
+SwarmShield is integrated into all swarm architectures:
+
+### SequentialWorkflow
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant S as SwarmShield
+    participant W as SequentialWorkflow
+    participant A1 as Agent 1
+    participant A2 as Agent 2
+    participant A3 as Agent 3
+    participant LLM as LLM Provider
+    
+    U->>S: Submit Task
+    S->>S: Validate Input
+    S->>S: Check Rate Limits
+    S->>S: Encrypt Data
+    S->>W: Forward Secure Task
+    
+    W->>A1: Process Step 1
+    A1->>LLM: Secure Request
+    LLM->>A1: Response
+    A1->>S: Encrypt Output
+    S->>S: Filter Sensitive Data
+    A1->>W: Secure Result
+    
+    W->>A2: Process Step 2
+    A2->>LLM: Secure Request
+    LLM->>A2: Response
+    A2->>S: Encrypt Output
+    S->>S: Filter Sensitive Data
+    A2->>W: Secure Result
+    
+    W->>A3: Process Step 3
+    A3->>LLM: Secure Request
+    LLM->>A3: Response
+    A3->>S: Encrypt Output
+    S->>S: Filter Sensitive Data
+    A3->>W: Secure Result
+    
+    W->>S: Final Result
+    S->>S: Final Security Check
+    S->>U: Secure Output
+```
+
+```python
+from swarms import SequentialWorkflow
+
+workflow = SequentialWorkflow(
+    agents=agents,
+    enable_security=True,
+    security_level="enhanced"
+)
+```
+
+### ConcurrentWorkflow
+
+```mermaid
+graph TB
+    A[User Input] --> B[SwarmShield Validation]
+    B --> C[Task Distribution]
+    
+    C --> D[Agent 1]
+    C --> E[Agent 2]
+    C --> F[Agent 3]
+    
+    D --> G[LLM Provider 1]
+    E --> H[LLM Provider 2]
+    F --> I[LLM Provider 3]
+    
+    G --> J[Output Filter 1]
+    H --> K[Output Filter 2]
+    I --> L[Output Filter 3]
+    
+    J --> M[Result Aggregation]
+    K --> M
+    L --> M
+    
+    M --> N[Final Security Check]
+    N --> O[Secure Output]
+    
+    style B fill:#e1f5fe
+    style J fill:#fff3e0
+    style K fill:#fff3e0
+    style L fill:#fff3e0
+    style N fill:#e8f5e8
+```
+
+```python
+from swarms import ConcurrentWorkflow
+
+workflow = ConcurrentWorkflow(
+    agents=agents,
+    enable_security=True,
+    security_level="enhanced"
+)
+```
+
+### SwarmRouter
+
+```mermaid
+graph TD
+    A[Input Task] --> B[SwarmShield Security Layer]
+    B --> C[Task Analysis]
+    C --> D{Route Decision}
+    
+    D -->|Route 1| E[Agent Group 1]
+    D -->|Route 2| F[Agent Group 2]
+    D -->|Route 3| G[Agent Group 3]
+    
+    E --> H[Security Validation]
+    F --> I[Security Validation]
+    G --> J[Security Validation]
+    
+    H --> K[LLM Processing]
+    I --> L[LLM Processing]
+    J --> M[LLM Processing]
+    
+    K --> N[Output Filtering]
+    L --> O[Output Filtering]
+    M --> P[Output Filtering]
+    
+    N --> Q[Result Router]
+    O --> Q
+    P --> Q
+    
+    Q --> R[Final Security Check]
+    R --> S[Secure Response]
+    
+    style B fill:#e1f5fe
+    style H fill:#fff3e0
+    style I fill:#fff3e0
+    style J fill:#fff3e0
+    style R fill:#e8f5e8
+```
+
+```python
+from swarms import SwarmRouter
+
+router = SwarmRouter(
+    agents=agents,
+    enable_security=True,
+    security_level="enhanced"
+)
+```
+
+### GroupChat
+
+```mermaid
+graph LR
+    A[User Message] --> B[SwarmShield Input Validation]
+    B --> C[Message Encryption]
+    C --> D[Group Chat System]
+    
+    D --> E[Agent 1]
+    D --> F[Agent 2]
+    D --> G[Agent 3]
+    
+    E --> H[Secure Communication]
+    F --> H
+    G --> H
+    
+    H --> I[Response Generation]
+    I --> J[Output Filtering]
+    J --> K[Secure Response]
+    
+    style B fill:#e1f5fe
+    style C fill:#e8f5e8
+    style J fill:#fff3e0
+```
+
+```python
+from swarms import GroupChat
+
+chat = GroupChat(
+    agents=agents,
+    enable_security=True,
+    security_level="enhanced"
+)
+```
+
+### InteractiveGroupChat
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant S as SwarmShield
+    participant IGC as InteractiveGroupChat
+    participant A1 as Agent 1
+    participant A2 as Agent 2
+    participant A3 as Agent 3
+    
+    U->>S: Interactive Message
+    S->>S: Real-time Validation
+    S->>IGC: Secure Message
+    
+    IGC->>A1: Broadcast Message
+    IGC->>A2: Broadcast Message
+    IGC->>A3: Broadcast Message
+    
+    A1->>S: Response 1
+    A2->>S: Response 2
+    A3->>S: Response 3
+    
+    S->>S: Filter Responses
+    S->>IGC: Secure Responses
+    IGC->>U: Interactive Output
+    
+    Note over S: Continuous Security Monitoring
+```
+
+```python
+from swarms import InteractiveGroupChat
+
+chat = InteractiveGroupChat(
+    agents=agents,
+    enable_security=True,
+    security_level="enhanced"
+)
+```
+
+### MajorityVoting
+
+```mermaid
+graph TB
+    A[Input Question] --> B[SwarmShield Security]
+    B --> C[Question Distribution]
+    
+    C --> D[Agent 1 Vote]
+    C --> E[Agent 2 Vote]
+    C --> F[Agent 3 Vote]
+    C --> G[Agent 4 Vote]
+    C --> H[Agent 5 Vote]
+    
+    D --> I[Vote Encryption]
+    E --> I
+    F --> I
+    G --> I
+    H --> I
+    
+    I --> J[Vote Aggregation]
+    J --> K[Majority Calculation]
+    K --> L[Result Filtering]
+    L --> M[Secure Final Answer]
+    
+    style B fill:#e1f5fe
+    style I fill:#e8f5e8
+    style L fill:#fff3e0
+```
+
+```python
+from swarms import MajorityVoting
+
+voting = MajorityVoting(
+    agents=agents,
+    enable_security=True,
+    security_level="enhanced"
+)
+```
+
+### Agent
+
+```mermaid
+graph LR
+    A[User Task] --> B[SwarmShield Integration]
+    B --> C[Input Validation]
+    C --> D[Rate Limiting]
+    D --> E[Task Encryption]
+    E --> F[Agent Processing]
+    F --> G[LLM Request]
+    G --> H[Response Encryption]
+    H --> I[Output Filtering]
+    I --> J[Secure Response]
+    
+    B --> K[Audit Logging]
+    B --> L[Safety Checks]
+    
+    style B fill:#e1f5fe
+    style C fill:#fff3e0
+    style E fill:#e8f5e8
+    style I fill:#fff3e0
+```
+
+```python
+from swarms import Agent
+
+agent = Agent(
+    agent_name="SecureAgent",
+    system_prompt="You are a secure agent.",
+    model_name="gpt-4o-mini",
+    enable_security=True,
+    security_level="enhanced"
+)
+```
+
+## Security Methods
+
+All swarm architectures inherit security methods from BaseSwarm:
+
+### Input Validation
+```python
+# Validate task input
+validated_task = workflow.validate_task_with_shield(
+    "Process sensitive data: user@example.com", 
+    "SecureAgent1"
+)
+
+# Validate agent configuration
+is_valid, validated_config, error = workflow.validate_agent_config_with_shield(
+    {"api_key": "sk-123..."}, 
+    "SecureAgent1"
+)
+```
+
+### Communication Processing
+```python
+# Process outbound communication
+is_valid, processed_message, error = workflow.process_agent_communication_with_shield(
+    "SecureAgent1", 
+    "Hello, this is a message", 
+    "outbound"
+)
+
+# Process inbound communication
+is_valid, processed_message, error = workflow.process_agent_communication_with_shield(
+    "SecureAgent1", 
+    "Received message", 
+    "inbound"
+)
+```
+
+### Rate Limiting
+```python
+# Check rate limits
+is_allowed = workflow.check_rate_limit_with_shield("SecureAgent1", 1)
+
+# Check token limits
+is_allowed = workflow.check_rate_limit_with_shield("SecureAgent1", 1000)
+```
+
+### Secure Communication
+```python
+# Add secure message to encrypted conversation
+success = workflow.add_secure_message("SecureAgent1", "Secret message")
+
+# Get secure messages (requires conversation_id)
+messages = workflow.get_secure_messages(conversation_id="conv_123")
+for agent, message, timestamp in messages:
+    print(f"{timestamp}: {agent}: {message}")
+```
+
+### Security Monitoring
+```python
+# Get comprehensive security statistics
+stats = workflow.get_security_stats()
+print(f"Security level: {stats['config']['security_level']}")
+print(f"Rate limiting: {stats['rate_limiting']['total_agents']} agents")
+print(f"Input validation: {stats['input_validation']['blocked_patterns_count']} patterns")
+```
+
+## Configuration Options
+
+### ShieldConfig Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `enabled` | bool | True | Enable/disable all security features |
+| `security_level` | str | "standard" | Security level (basic, standard, enhanced, maximum) |
+| `encryption_strength` | str | "maximum" | Encryption strength (standard, enhanced, maximum) |
+| `key_rotation_interval` | int | 3600 | Key rotation interval in seconds |
+| `enable_input_validation` | bool | True | Enable input validation |
+| `max_input_length` | int | 10000 | Maximum input length |
+| `enable_output_filtering` | bool | True | Enable output filtering |
+| `filter_sensitive_data` | bool | True | Filter sensitive data from outputs |
+| `enable_safety_checks` | bool | True | Enable safety checking |
+| `enable_rate_limiting` | bool | True | Enable rate limiting |
+| `max_requests_per_minute` | int | 60 | Maximum requests per minute |
+| `enable_audit_logging` | bool | True | Enable audit logging |
+| `integrate_with_conversation` | bool | True | Integrate with conversation management |
+| `protect_agent_communications` | bool | True | Protect inter-agent communications |
+
+### Custom Patterns
+
+```python
+config = ShieldConfig(
+    # Block specific patterns
+    custom_blocked_patterns=[
+        r"password\s*=\s*\w+",
+        r"api_key\s*=\s*\w+",
+        r"secret\s*=\s*\w+",
+        r"<script.*?>.*?</script>"
+    ],
+    
+    # Filter sensitive data patterns
+    custom_sensitive_patterns=[
+        r"\b\d{3}-\d{2}-\d{4}\b",  # SSN
+        r"\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b",  # Credit card
+        r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b",  # Email
+        r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b"  # IP address
+    ]
+)
+```
+
+## Complete Examples
+
+### Multi-Agent Security System
+
+```mermaid
+graph TB
+    A[Security Analysis Request] --> B[SwarmShield Security Layer]
+    B --> C[SequentialWorkflow]
+    
+    C --> D[Security-Analyzer Agent]
+    D --> E[Threat Assessment]
+    E --> F[Security Report]
+    
+    F --> G[Quality-Control Agent]
+    G --> H[Quality Verification]
+    H --> I[Final Secure Report]
+    
+    B --> J[Continuous Security Monitoring]
+    B --> K[Audit Logging]
+    B --> L[Rate Limiting]
+    
+    style B fill:#e1f5fe
+    style J fill:#fff3e0
+    style K fill:#e8f5e8
+    style L fill:#f3e5f5
+```
+
+```python
+from swarms import Agent, SequentialWorkflow
+from swarms.security import ShieldConfig
+
+def security_analysis(danger_level: str) -> str:
+    """Analyze security danger level and return appropriate response."""
+    responses = {
+        "low": "No immediate danger detected - Safe to proceed",
+        "medium": "Moderate security concern - Requires attention",
+        "high": "Critical security threat - Immediate action required",
+        None: "No danger level assessment available"
+    }
+    return responses.get(danger_level, "Unknown danger level")
+
+def quality_assessment(quality_score: int) -> str:
+    """Assess quality based on numerical score (1-10)."""
+    if quality_score >= 8:
+        return "Excellent quality - Meets all standards"
+    elif quality_score >= 6:
+        return "Good quality - Minor improvements needed"
+    elif quality_score >= 4:
+        return "Poor quality - Significant issues identified"
+    else:
+        return "Critical quality failure - Immediate attention required"
+
+# Create secure agents
+agents = [
+    Agent(
+        agent_name="Security-Analyzer",
+        agent_description="Analyzes security threats and vulnerabilities",
+        system_prompt="You are a security analyst. Assess security risks and provide threat analysis.",
+        model_name="gpt-4o-mini",
+        max_loops=1,
+        enable_security=True,
+        security_level="enhanced"
+    ),
+    Agent(
+        agent_name="Quality-Control",
+        agent_description="Ensures quality standards are met",
+        system_prompt="You are a quality control specialist. Verify content quality and compliance.",
+        model_name="gpt-4o-mini",
+        max_loops=1,
+        enable_security=True,
+        security_level="enhanced"
+    )
+]
+
+# Create secure workflow
+workflow = SequentialWorkflow(
+    name="Secure-Quality-System",
+    agents=agents,
+    enable_security=True,
+    security_level="enhanced"
+)
+
+# Run secure analysis
+result = workflow.run("Analyze the security posture of our new API endpoint")
+```
+
+### Agent with Dynamic Security
+
+```python
+from swarms import Agent
+
+# Agent with enhanced security features
+secure_agent = Agent(
+    agent_name="Secure-Agent",
+    agent_description="Agent with comprehensive security measures",
+    system_prompt="You are a helpful, harmless, and honest AI assistant.",
+    model_name="gpt-4o-mini",
+    enable_security=True,
+    security_level="maximum",
+    max_loops=1,
+    temperature=0.3  # Lower temperature for more consistent, safe responses
+)
+```
+
+### Output Type Configurations with Security
+
+```python
+# Different output type examples with security
+json_agent = Agent(
+    agent_name="JSON-Secure-Agent",
+    system_prompt="Always respond in valid JSON format",
+    output_type="json",
+    enable_security=True,
+    security_level="standard"
+)
+
+streaming_agent = Agent(
+    agent_name="Streaming-Secure-Agent", 
+    system_prompt="Provide detailed streaming responses",
+    output_type="str-all-except-first",
+    enable_security=True,
+    security_level="standard"
+)
+
+final_only_agent = Agent(
+    agent_name="Final-Only-Secure-Agent",
+    system_prompt="Provide only the final result",
+    output_type="final",
+    enable_security=True,
+    security_level="standard"
+)
+```
+
+## Security Flow Diagram
+
+```mermaid
+flowchart TD
+    A[User Input] --> B{SwarmShield Enabled?}
+    B -->|No| C[Direct Processing]
+    B -->|Yes| D[Security Layer]
+    
+    D --> E[Input Validation]
+    E --> F{Valid Input?}
+    F -->|No| G[Block Request]
+    F -->|Yes| H[Rate Limiting Check]
+    
+    H --> I{Within Limits?}
+    I -->|No| J[Rate Limit Exceeded]
+    I -->|Yes| K[Encrypt Data]
+    
+    K --> L[Agent Processing]
+    L --> M[LLM Request]
+    M --> N[Response Received]
+    
+    N --> O[Output Filtering]
+    O --> P[Safety Checks]
+    P --> Q[Final Encryption]
+    Q --> R[Secure Response]
+    
+    C --> S[Standard Processing]
+    S --> T[Direct Response]
+    
+    style D fill:#e1f5fe
+    style E fill:#fff3e0
+    style H fill:#fff3e0
+    style K fill:#e8f5e8
+    style O fill:#fff3e0
+    style P fill:#f3e5f5
+    style Q fill:#e8f5e8
+```
+
+## Best Practices
+
+### 1. Choose Appropriate Security Level
+- Use `basic` for development and testing
+- Use `standard` for most production applications
+- Use `enhanced` for sensitive data processing
+- Use `maximum` for highly regulated environments
+
+### 2. Configure Rate Limits
+```python
+config = ShieldConfig(
+    max_requests_per_minute=30,  # Adjust based on your needs
+    max_tokens_per_request=5000,  # Limit resource usage
+    rate_limit_window=60  # 1-minute window
+)
+```
+
+### 3. Customize Patterns
+```python
+config = ShieldConfig(
+    custom_blocked_patterns=[
+        # Add your organization-specific patterns
+        r"internal\s+server\s+error",
+        r"debug\s+mode",
+        r"test\s+environment"
+    ],
+    custom_sensitive_patterns=[
+        # Add your data-specific patterns
+        r"\b[A-Z]{2}\d{2}[A-Z0-9]{10,30}\b",  # IBAN
+        r"\b\d{3}[\s-]?\d{3}[\s-]?\d{4}\b"  # Phone number
+    ]
+)
+```
+
+### 4. Monitor Security
+```python
+# Regular security monitoring
+stats = workflow.get_security_stats()
+if stats['rate_limiting']['blocked_agents'] > 0:
+    print("Warning: Some agents are being rate limited")
+
+# Check for security events
+if stats['input_validation']['blocked_patterns_count'] > 0:
+    print("Warning: Blocked patterns detected")
+```
+
+### 5. Handle Security Errors
+```python
+# Validate input before processing
+validated_task = workflow.validate_task_with_shield(task, agent_name)
+if not validated_task:
+    print("Security validation failed")
+    return
+
+# Check rate limits
+is_allowed = workflow.check_rate_limit_with_shield(agent_name)
+if not is_allowed:
+    print("Rate limit exceeded")
+    return
+```
+
+### 6. Error Handling and Robustness
+```python
+import logging
+from swarms import Agent
+
+# Configure logging for security events
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create agent with error handling
+agent = Agent(
+    agent_name="Robust-Secure-Agent",
+    system_prompt="You are a secure and robust agent.",
+    model_name="gpt-4o-mini",
+    enable_security=True,
+    security_level="enhanced",
+    max_loops=1
+)
+
+try:
+    result = agent.run("Process this task securely")
+    logger.info("Task completed successfully")
+except Exception as e:
+    logger.error(f"Security error: {e}")
+    # Handle security-related errors appropriately
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Security Initialization Failed**
+   ```python
+   # Check if cryptography is installed
+   pip install cryptography
+   
+   # Use basic security as fallback
+   workflow = SequentialWorkflow(
+       agents=agents,
+       enable_security=True,
+       security_level="basic"
+   )
+   ```
+
+2. **Rate Limiting Too Strict**
+   ```python
+   # Increase rate limits
+   config = ShieldConfig(
+       max_requests_per_minute=100,  # Increase from default 60
+       rate_limit_window=120  # Increase window
+   )
+   ```
+
+3. **Pattern Blocking Legitimate Content**
+   ```python
+   # Review and adjust patterns
+   config = ShieldConfig(
+       custom_blocked_patterns=[
+           # Remove or modify problematic patterns
+           r"javascript:",  # Too broad, consider more specific
+       ]
+   )
+   ```
+
+### Performance Optimization
+
+1. **Disable Unnecessary Features**
+   ```python
+   config = ShieldConfig(
+       enable_audit_logging=False,  # Disable if not needed
+       log_input_output=False,  # Disable for performance
+       enable_caching=True  # Enable caching
+   )
+   ```
+
+2. **Use Appropriate Security Level**
+   ```python
+   # Use basic for high-throughput scenarios
+   workflow = SequentialWorkflow(
+       agents=agents,
+       enable_security=True,
+       security_level="basic"  # Minimal overhead
+   )
+   ```
+
+## Migration Guide
+
+### From Standalone SwarmShield
+
+If you were using the standalone SwarmShield package:
+
+```python
+# Old standalone usage
+from swarm_shield import SwarmShield
+shield = SwarmShield(encryption_strength="maximum")
+
+# New integrated usage
+from swarms import SequentialWorkflow
+from swarms.security import ShieldConfig
+
+config = ShieldConfig.create_maximum_config()
+workflow = SequentialWorkflow(
+    agents=agents,
+    shield_config=config,
+    enable_security=True
+)
+```
+
+### From No Security
+
+If you're adding security to existing swarms:
+
+```python
+# Old usage without security
+workflow = SequentialWorkflow(agents=agents)
+
+# New usage with security
+workflow = SequentialWorkflow(
+    agents=agents,
+    enable_security=True,
+    security_level="standard"
+)
+```
+
+## Examples
+
+See the complete examples in `example_swarm_with_shield.py` for:
+
+- Basic security configuration
+- Enhanced security features
+- Maximum security setup
+- Custom security patterns
+- Security monitoring
+- Async operations with security
+
+## Support
+
+For issues and questions:
+
+1. Check the troubleshooting section above
+2. Review the security statistics for insights
+3. Use basic security level for debugging
+4. Check the logs in the `security/` folder
+
+## Security Considerations
+
+- **Key Management**: Keys are automatically rotated, but ensure secure storage
+- **Pattern Updates**: Regularly update blocked and sensitive patterns
+- **Rate Limits**: Monitor and adjust based on your application needs
+- **Audit Logs**: Review logs regularly for security insights
+- **Updates**: Keep the Swarms framework updated for security patches