Part 3 - Tell vs Ask: Mastering Message Patterns in Akka.NET

Originally published on Dev-Tinker | Reading time: 12 minutes | Part 3 of 16 in the Complete Akka.NET Series

Part 1 - What is the Actor Model? A Complete Guide for C# Developers

Part 2 - Your First Akka.NET Actor: Building a Calculator Step-by-Step

The Difference Between Fire-and-Forget and Waiting for Answers

Imagine you're at a busy restaurant. When you place your order, do you tell the waiter and continue your conversation (fire-and-forget), or do you ask a question and wait for a response before proceeding? Both approaches have their place, and choosing the wrong one can dramatically impact your application's performance and user experience.

In Akka.NET, this choice between Tell and Ask is one of the most fundamental decisions you'll make. Get it right, and you'll build lightning-fast, responsive systems. Get it wrong, and you'll create bottlenecks that bring your application to its knees.

Today we're diving deep into these two messaging patterns. You'll learn when to use each approach, how to handle responses properly, and most importantly, how to build systems that scale from dozens to millions of concurrent operations. By the end, you'll be implementing a real-time chat system that demonstrates both patterns working together beautifully.

Learning Objectives

By the end of this tutorial, you will:

✅ Master the fundamental difference between Tell (fire-and-forget) and Ask (request-response) patterns
✅ Understand when to use each pattern for optimal performance and user experience
✅ Implement async/await integration with Ask for modern C# development practices
✅ Learn message ordering guarantees and their implications for system design
✅ Build a real-time chat system that combines both messaging patterns effectively

Prerequisites

Completed Week 1 (Actor Model fundamentals) and Week 2 (Calculator actor)
Basic understanding of C# async/await patterns
Familiarity with UntypedActor and message handling

Fire-and-Forget vs Request-Response Patterns

Every interaction in distributed systems falls into one of two categories:

Fire-and-Forget (Tell)

Tell sends a message and immediately continues without waiting for a response. It's like dropping a letter in a mailbox – you trust it will be delivered, but you don't wait around for confirmation.

// Fire-and-forget - non-blocking, high performance
actorRef.Tell(new ProcessOrderMessage(orderId));
// Execution continues immediately - no waiting!
Console.WriteLine("Order processing initiated");

Request-Response (Ask)

Ask sends a message and waits for a response before continuing. It's like making a phone call – you wait for the other person to answer before proceeding with the conversation.

// Request-response - blocks until response received
var result = await actorRef.Ask<OrderResult>(new ProcessOrderMessage(orderId));
Console.WriteLine($"Order processed: {result.Status}");
// This line only executes after receiving the response

Tell Method: Performance and Use Cases

Tell is the workhorse of actor systems. It's non-blocking, fast, and scales incredibly well. Here's why:

Performance Characteristics

Zero Blocking: The sender never waits, enabling maximum throughput
Memory Efficient: No need to maintain response tracking state
Naturally Asynchronous: Perfect for event-driven architectures
Highly Scalable: Can handle millions of messages per second

When to Use Tell

// 1. Logging and Auditing - You don't need confirmation
loggingActor.Tell(new LogMessage($"User {userId} logged in", LogLevel.Info));

// 2. Event Publishing - Broadcast to multiple subscribers
eventBus.Tell(new UserRegisteredEvent(user));

// 3. Background Processing - Fire and forget operations
emailActor.Tell(new SendWelcomeEmailMessage(user.Email, user.Name));

// 4. State Updates - Simple state changes without confirmation needed
counterActor.Tell(new IncrementMessage());

// 5. Notifications - One-way communication
notificationActor.Tell(new PushNotificationMessage(deviceId, message));

Tell Implementation Examples

public class OrderProcessorActor : UntypedActor
{
    protected override void OnReceive(object message)
    {
        switch (message)
        {
            case ProcessOrderMessage order:
                // Process the order
                var result = ProcessOrder(order.OrderId);
                
                // Tell other actors about the result - no waiting
                inventoryActor.Tell(new UpdateInventoryMessage(order.Items));
                billingActor.Tell(new ProcessPaymentMessage(order.PaymentInfo));
                shippingActor.Tell(new PrepareShipmentMessage(order.ShippingAddress));
                
                // Optional: Tell the original sender about completion
                Sender.Tell(new OrderProcessedMessage(result));
                break;
        }
    }
    
    private OrderResult ProcessOrder(string orderId)
    {
        // Your business logic here
        return new OrderResult(orderId, "Processed");
    }
}

Ask Method: Async/Await Integration

Ask is perfect when you need the response to continue processing. It integrates seamlessly with modern async/await patterns.

Basic Ask Pattern

public class OrderController
{
    private readonly IActorRef _orderActor;
    private readonly TimeSpan _timeout = TimeSpan.FromSeconds(5);
    
    public OrderController(IActorRef orderActor)
    {
        _orderActor = orderActor;
    }
    
    public async Task<IActionResult> ProcessOrder(ProcessOrderRequest request)
    {
        try
        {
            // Ask and wait for response with timeout
            var result = await _orderActor.Ask<OrderResult>(
                new ProcessOrderMessage(request.OrderId), 
                _timeout);
                
            return Ok(new { Status = result.Status, OrderId = result.OrderId });
        }
        catch (AskTimeoutException)
        {
            return StatusCode(408, "Order processing timed out");
        }
        catch (Exception ex)
        {
            return StatusCode(500, $"Error processing order: {ex.Message}");
        }
    }
}

Advanced Ask Patterns

public class UserService
{
    private readonly IActorRef _userActor;
    
    // Ask with custom timeout
    public async Task<User> GetUserAsync(string userId)
    {
        return await _userActor.Ask<User>(
            new GetUserMessage(userId), 
            TimeSpan.FromSeconds(3));
    }
    
    // Ask with error handling and fallback
    public async Task<UserProfile> GetUserProfileAsync(string userId)
    {
        try
        {
            var profile = await _userActor.Ask<UserProfile>(
                new GetProfileMessage(userId), 
                TimeSpan.FromSeconds(2));
            return profile;
        }
        catch (AskTimeoutException)
        {
            // Return cached or default profile
            return GetCachedProfile(userId) ?? UserProfile.Default;
        }
    }
    
    // Parallel Ask operations
    public async Task<UserDashboard> GetDashboardAsync(string userId)
    {
        var profileTask = _userActor.Ask<UserProfile>(new GetProfileMessage(userId));
        var settingsTask = _userActor.Ask<UserSettings>(new GetSettingsMessage(userId));
        var notificationsTask = _userActor.Ask<List<Notification>>(new GetNotificationsMessage(userId));
        
        // Wait for all requests concurrently
        await Task.WhenAll(profileTask, settingsTask, notificationsTask);
        
        return new UserDashboard
        {
            Profile = profileTask.Result,
            Settings = settingsTask.Result,
            Notifications = notificationsTask.Result
        };
    }
}

Message Ordering Guarantees and Implications

Understanding message ordering is crucial for building correct distributed systems. Akka.NET provides specific guarantees that you must understand.

Ordering Guarantees

Same Sender to Same Receiver: Messages from Actor A to Actor B arrive in order
No Global Ordering: Messages from different senders may arrive in any order
Tell vs Ask Ordering: Both follow the same ordering rules

// These messages will arrive at targetActor IN ORDER
sourceActor.Tell(targetActor, new Message1());
sourceActor.Tell(targetActor, new Message2());
sourceActor.Tell(targetActor, new Message3());

// But these might arrive in ANY ORDER (different senders)
actor1.Tell(targetActor, new MessageA());
actor2.Tell(targetActor, new MessageB());
actor3.Tell(targetActor, new MessageC());

Implications for System Design

public class BankAccountActor : UntypedActor
{
    private decimal _balance = 0m;
    
    protected override void OnReceive(object message)
    {
        switch (message)
        {
            case DepositMessage deposit:
                _balance += deposit.Amount;
                Console.WriteLine($"Deposited {deposit.Amount}, Balance: {_balance}");
                
                // This ordering is GUARANTEED for same sender
                auditActor.Tell(new TransactionLogMessage("Deposit", deposit.Amount, _balance));
                notificationActor.Tell(new BalanceUpdateMessage(Context.Self.Path, _balance));
                break;
                
            case WithdrawMessage withdraw:
                if (_balance >= withdraw.Amount)
                {
                    _balance -= withdraw.Amount;
                    Console.WriteLine($"Withdrew {withdraw.Amount}, Balance: {_balance}");
                    
                    // These will arrive in order at their destinations
                    auditActor.Tell(new TransactionLogMessage("Withdrawal", withdraw.Amount, _balance));
                    Sender.Tell(new WithdrawalSuccessMessage(_balance));
                }
                else
                {
                    Sender.Tell(new InsufficientFundsMessage());
                }
                break;
        }
    }
}

Error Handling in Tell vs Ask

Error handling strategies differ significantly between Tell and Ask patterns.

Tell Error Handling

public class RobustProcessingActor : UntypedActor
{
    private readonly IActorRef _errorHandler;
    
    protected override void OnReceive(object message)
    {
        switch (message)
        {
            case ProcessDataMessage data:
                try
                {
                    var result = ProcessData(data.Payload);
                    
                    // Tell success - fire and forget
                    Sender.Tell(new ProcessingSuccessMessage(result));
                }
                catch (ValidationException ex)
                {
                    // Tell about validation error - no blocking
                    Sender.Tell(new ValidationErrorMessage(ex.Message));
                    _errorHandler.Tell(new LogErrorMessage(ex, data));
                }
                catch (Exception ex)
                {
                    // Tell about general error
                    Sender.Tell(new ProcessingFailedMessage(ex.Message));
                    _errorHandler.Tell(new CriticalErrorMessage(ex, data));
                    
                    // Don't rethrow - handle gracefully
                }
                break;
        }
    }
}

Ask Error Handling

public class ApiController : ControllerBase
{
    private readonly IActorRef _processingActor;
    
    [HttpPost("process")]
    public async Task<IActionResult> ProcessData([FromBody] DataRequest request)
    {
        try
        {
            // Ask with timeout - will throw on timeout or actor failure
            var result = await _processingActor.Ask<ProcessingResult>(
                new ProcessDataMessage(request.Data), 
                TimeSpan.FromSeconds(10));
                
            return result switch
            {
                ProcessingSuccessMessage success => Ok(success.Result),
                ValidationErrorMessage error => BadRequest(error.Message),
                ProcessingFailedMessage failure => StatusCode(500, failure.Error),
                _ => StatusCode(500, "Unknown response type")
            };
        }
        catch (AskTimeoutException)
        {
            return StatusCode(408, "Request timeout - try again later");
        }
        catch (Exception ex)
        {
            return StatusCode(500, $"Processing error: {ex.Message}");
        }
    }
}

Performance Considerations and Benchmarks

Let's examine the performance characteristics with concrete numbers:

Tell Performance

// Tell Performance Characteristics
// - Throughput: 10M+ messages/second on modern hardware
// - Latency: Sub-microsecond message queuing
// - Memory: Minimal - just message allocation
// - CPU: Low - no response tracking overhead

public class PerformanceTester
{
    public async Task BenchmarkTellPerformance()
    {
        using var system = ActorSystem.Create("TellBenchmark");
        var actor = system.ActorOf<HighThroughputActor>("processor");
        
        var messageCount = 1_000_000;
        var stopwatch = Stopwatch.StartNew();
        
        // Fire a million messages as fast as possible
        for (int i = 0; i < messageCount; i++)
        {
            actor.Tell(new ProcessMessage(i));
        }
        
        stopwatch.Stop();
        
        Console.WriteLine($"Tell Throughput: {messageCount / stopwatch.Elapsed.TotalSeconds:F0} msg/sec");
        // Typical result: 5,000,000+ messages/second
        
        await system.Terminate();
    }
}

Ask Performance

// Ask Performance Characteristics  
// - Throughput: 100K-500K requests/second (depends on timeout and response time)
// - Latency: Higher due to round-trip + timeout handling
// - Memory: Higher - maintains Task<T> for each request
// - CPU: Higher - response correlation overhead

public async Task BenchmarkAskPerformance()
{
    using var system = ActorSystem.Create("AskBenchmark");
    var actor = system.ActorOf<QuickResponseActor>("processor");
    
    var requestCount = 10_000;
    var stopwatch = Stopwatch.StartNew();
    
    // Process requests with Ask (limited concurrency to avoid overwhelming)
    var semaphore = new SemaphoreSlim(100); // Limit concurrent asks
    var tasks = new List<Task>();
    
    for (int i = 0; i < requestCount; i++)
    {
        tasks.Add(ProcessWithAsk(actor, i, semaphore));
    }
    
    await Task.WhenAll(tasks);
    stopwatch.Stop();
    
    Console.WriteLine($"Ask Throughput: {requestCount / stopwatch.Elapsed.TotalSeconds:F0} req/sec");
    // Typical result: 50,000-200,000 requests/second
}

private async Task ProcessWithAsk(IActorRef actor, int id, SemaphoreSlim semaphore)
{
    await semaphore.WaitAsync();
    try
    {
        var result = await actor.Ask<ProcessResult>(new ProcessMessage(id), TimeSpan.FromSeconds(1));
        // Process result
    }
    finally
    {
        semaphore.Release();
    }
}

Building a Chat Room with Both Patterns

Now let's build a real-time chat system that demonstrates both Tell and Ask patterns working together effectively.

Chat System Architecture

ChatRoomActor: Manages room state and broadcasts messages (Tell)
UserActor: Represents individual users and handles queries (Ask)
ChatService: API layer that coordinates between HTTP and actors

Message Definitions

// Chat Commands (use Tell for broadcasting)
public abstract record ChatCommand;
public record JoinRoomCommand(string UserId, string Username, string RoomId) : ChatCommand;
public record LeaveRoomCommand(string UserId, string RoomId) : ChatCommand;
public record SendMessageCommand(string UserId, string RoomId, string Message) : ChatCommand;

// Chat Events (broadcast with Tell)
public abstract record ChatEvent;
public record UserJoinedEvent(string Username, string RoomId, DateTime Timestamp) : ChatEvent;
public record UserLeftEvent(string Username, string RoomId, DateTime Timestamp) : ChatEvent;
public record MessageBroadcastEvent(string Username, string Message, string RoomId, DateTime Timestamp) : ChatEvent;

// Chat Queries (use Ask for responses)
public abstract record ChatQuery;
public record GetRoomUsersQuery(string RoomId) : ChatQuery;
public record GetMessageHistoryQuery(string RoomId, int Count = 50) : ChatQuery;
public record GetUserStatusQuery(string UserId) : ChatQuery;

// Query Responses
public record RoomUsersResponse(List<string> Users);
public record MessageHistoryResponse(List<ChatMessage> Messages);
public record UserStatusResponse(string Status, List<string> Rooms);

public record ChatMessage(string Username, string Message, DateTime Timestamp);

ChatRoomActor Implementation

public class ChatRoomActor : UntypedActor
{
    private readonly string _roomId;
    private readonly Dictionary<string, string> _users = new(); // UserId -> Username
    private readonly List<ChatMessage> _messageHistory = new();
    private readonly List<IActorRef> _subscribers = new();
    
    public ChatRoomActor(string roomId)
    {
        _roomId = roomId;
    }
    
    protected override void OnReceive(object message)
    {
        switch (message)
        {
            case JoinRoomCommand join:
                HandleUserJoin(join);
                break;
                
            case LeaveRoomCommand leave:
                HandleUserLeave(leave);
                break;
                
            case SendMessageCommand sendMsg:
                HandleSendMessage(sendMsg);
                break;
                
            // Queries - respond with Ask
            case GetRoomUsersQuery:
                HandleGetUsers();
                break;
                
            case GetMessageHistoryQuery history:
                HandleGetHistory(history);
                break;
                
            // Subscription management
            case SubscribeToRoomCommand subscribe:
                _subscribers.Add(Sender);
                break;
                
            case UnsubscribeFromRoomCommand:
                _subscribers.Remove(Sender);
                break;
        }
    }
    
    private void HandleUserJoin(JoinRoomCommand join)
    {
        if (!_users.ContainsKey(join.UserId))
        {
            _users[join.UserId] = join.Username;
            
            var joinEvent = new UserJoinedEvent(join.Username, _roomId, DateTime.UtcNow);
            
            // Tell all subscribers about the join - no waiting
            BroadcastToSubscribers(joinEvent);
            
            Console.WriteLine($"{join.Username} joined room {_roomId}");
        }
    }
    
    private void HandleUserLeave(LeaveRoomCommand leave)
    {
        if (_users.TryGetValue(leave.UserId, out var username))
        {
            _users.Remove(leave.UserId);
            
            var leaveEvent = new UserLeftEvent(username, _roomId, DateTime.UtcNow);
            
            // Tell all subscribers about the departure
            BroadcastToSubscribers(leaveEvent);
            
            Console.WriteLine($"{username} left room {_roomId}");
        }
    }
    
    private void HandleSendMessage(SendMessageCommand sendMsg)
    {
        if (_users.TryGetValue(sendMsg.UserId, out var username))
        {
            var chatMessage = new ChatMessage(username, sendMsg.Message, DateTime.UtcNow);
            _messageHistory.Add(chatMessage);
            
            // Keep history manageable
            if (_messageHistory.Count > 1000)
            {
                _messageHistory.RemoveAt(0);
            }
            
            var broadcastEvent = new MessageBroadcastEvent(
                username, sendMsg.Message, _roomId, DateTime.UtcNow);
            
            // Tell all subscribers about the new message
            BroadcastToSubscribers(broadcastEvent);
            
            Console.WriteLine($"[{_roomId}] {username}: {sendMsg.Message}");
        }
    }
    
    private void HandleGetUsers()
    {
        // Ask response - send back user list
        var users = _users.Values.ToList();
        Sender.Tell(new RoomUsersResponse(users));
    }
    
    private void HandleGetHistory(GetMessageHistoryQuery history)
    {
        // Ask response - send back message history
        var messages = _messageHistory.TakeLast(history.Count).ToList();
        Sender.Tell(new MessageHistoryResponse(messages));
    }
    
    private void BroadcastToSubscribers(ChatEvent chatEvent)
    {
        // Tell pattern - fire and forget to all subscribers
        foreach (var subscriber in _subscribers.ToList())
        {
            subscriber.Tell(chatEvent);
        }
    }
    
    protected override void PreStart()
    {
        Console.WriteLine($"ChatRoom {_roomId} started");
    }
    
    protected override void PostStop()
    {
        Console.WriteLine($"ChatRoom {_roomId} stopped");
    }
}

Chat Service Integration

public class ChatService
{
    private readonly ActorSystem _actorSystem;
    private readonly Dictionary<string, IActorRef> _chatRooms = new();
    
    public ChatService()
    {
        _actorSystem = ActorSystem.Create("ChatSystem");
    }
    
    // Tell patterns - fire and forget
    public void JoinRoom(string userId, string username, string roomId)
    {
        var roomActor = GetOrCreateRoom(roomId);
        roomActor.Tell(new JoinRoomCommand(userId, username, roomId));
    }
    
    public void LeaveRoom(string userId, string roomId)
    {
        if (_chatRooms.TryGetValue(roomId, out var roomActor))
        {
            roomActor.Tell(new LeaveRoomCommand(userId, roomId));
        }
    }
    
    public void SendMessage(string userId, string roomId, string message)
    {
        if (_chatRooms.TryGetValue(roomId, out var roomActor))
        {
            roomActor.Tell(new SendMessageCommand(userId, roomId, message));
        }
    }
    
    // Ask patterns - wait for responses
    public async Task<List<string>> GetRoomUsersAsync(string roomId)
    {
        if (_chatRooms.TryGetValue(roomId, out var roomActor))
        {
            var response = await roomActor.Ask<RoomUsersResponse>(
                new GetRoomUsersQuery(roomId), 
                TimeSpan.FromSeconds(2));
            return response.Users;
        }
        return new List<string>();
    }
    
    public async Task<List<ChatMessage>> GetMessageHistoryAsync(string roomId, int count = 50)
    {
        if (_chatRooms.TryGetValue(roomId, out var roomActor))
        {
            var response = await roomActor.Ask<MessageHistoryResponse>(
                new GetMessageHistoryQuery(roomId, count), 
                TimeSpan.FromSeconds(2));
            return response.Messages;
        }
        return new List<ChatMessage>();
    }
    
    private IActorRef GetOrCreateRoom(string roomId)
    {
        if (!_chatRooms.TryGetValue(roomId, out var roomActor))
        {
            roomActor = _actorSystem.ActorOf(
                Props.Create(() => new ChatRoomActor(roomId)), 
                $"chatroom-{roomId}");
            _chatRooms[roomId] = roomActor;
        }
        return roomActor;
    }
}

Console Chat Application

class Program
{
    static async Task Main(string[] args)
    {
        var chatService = new ChatService();
        
        Console.WriteLine("=== Akka.NET Chat Demo ===");
        Console.WriteLine("Commands: join <room> <username>, send <room> <message>, users <room>, history <room>, quit");
        Console.WriteLine();
        
        string? input;
        while ((input = Console.ReadLine()) != "quit")
        {
            if (string.IsNullOrWhiteSpace(input)) continue;
            
            var parts = input.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            if (parts.Length == 0) continue;
            
            var command = parts[0].ToLower();
            
            try
            {
                switch (command)
                {
                    case "join" when parts.Length >= 3:
                        var roomId = parts[1];
                        var username = string.Join(" ", parts.Skip(2));
                        var userId = Guid.NewGuid().ToString();
                        
                        // Tell - fire and forget
                        chatService.JoinRoom(userId, username, roomId);
                        Console.WriteLine($"Joined room '{roomId}' as '{username}'");
                        break;
                        
                    case "send" when parts.Length >= 3:
                        var sendRoomId = parts[1];
                        var message = string.Join(" ", parts.Skip(2));
                        var sendUserId = "demo-user"; // In real app, track current user
                        
                        // Tell - fire and forget
                        chatService.SendMessage(sendUserId, sendRoomId, message);
                        break;
                        
                    case "users" when parts.Length >= 2:
                        var usersRoomId = parts[1];
                        
                        // Ask - wait for response
                        var users = await chatService.GetRoomUsersAsync(usersRoomId);
                        Console.WriteLine($"Users in '{usersRoomId}': {string.Join(", ", users)}");
                        break;
                        
                    case "history" when parts.Length >= 2:
                        var historyRoomId = parts[1];
                        
                        // Ask - wait for response
                        var messages = await chatService.GetMessageHistoryAsync(historyRoomId, 10);
                        Console.WriteLine($"Recent messages in '{historyRoomId}':");
                        foreach (var msg in messages)
                        {
                            Console.WriteLine($"  [{msg.Timestamp:HH:mm:ss}] {msg.Username}: {msg.Message}");
                        }
                        break;
                        
                    default:
                        Console.WriteLine("Usage: join <room> <username> | send <room> <message> | users <room> | history <room>");
                        break;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
            
            await Task.Delay(100); // Small delay to see actor processing
        }
        
        Console.WriteLine("Chat application shutting down...");
    }
}

Testing Your Chat System

Try this sequence to test both Tell and Ask patterns:

=== Akka.NET Chat Demo ===
Commands: join <room> <username>, send <room> <message>, users <room>, history <room>, quit

> join general Alice
Joined room 'general' as 'Alice'
Alice joined room general

> join general Bob  
Joined room 'general' as 'Bob'
Bob joined room general

> send general Hello everyone!
[general] demo-user: Hello everyone!

> users general
Users in 'general': Alice, Bob

> history general
Recent messages in 'general':
  [14:30:15] demo-user: Hello everyone!

> quit
Chat application shutting down...

Key Takeaways

🎯 Tell is for performance - Use when you don't need a response and want maximum throughput (logging, events, notifications).

🎯 Ask is for coordination - Use when you need the response to continue processing (API endpoints, data queries, user interactions).

🎯 Message ordering is guaranteed between the same sender and receiver, but not globally across different senders.

🎯 Error handling differs - Tell errors are handled in the receiver, Ask errors propagate back to the caller.

🎯 Performance scales differently - Tell can handle millions of messages/second, Ask is limited by round-trip time and timeout handling.

What's Next?

In Week 4, we'll dive into actor supervision and fault tolerance - the "Let It Crash" philosophy that makes Akka.NET systems incredibly resilient. You'll learn:

Building hierarchical supervision strategies (OneForOne vs AllForOne)
The four supervision directives (Restart, Resume, Stop, Escalate)
Implementing custom supervision strategies for business logic
Building self-healing systems that recover from failures automatically
Creating a fault-tolerant file processing system with multiple supervision levels

Hands-On Challenge

Extend your chat system with these advanced features:

Private Messages: Add user-to-user messaging with Ask pattern for delivery confirmation
Room Management: Implement room creation/deletion with proper cleanup
User Presence: Track online/offline status with periodic heartbeats (Tell pattern)
Message Persistence: Store chat history to file or database
Rate Limiting: Prevent spam by limiting messages per user per minute