Real-Time Updates

Built-in WebSocket Support for Agent Activations, Model Changes, and Live UI Updates

No polling, no refreshing - instant updates for agent executions, data changes, and user interactions across all connected clients

Real-Time Architecture

Event-driven updates across your entire application stack

Event Triggers

Agent activation
Model changes
User interactions
System events

WebSocket Hub

Event filtering
Channel routing
Client management
Authentication

Live UI Updates

Instant data refresh
Real-time notifications
Live progress tracking
Instant messaging

Comprehensive Event System

Built-in events for every aspect of your application

Agent Events

agent.started Agent execution begins
agent.progress Real-time progress updates
agent.completed Agent execution finished
agent.error Execution errors

Model Events

model.created New record created
model.updated Record modified
model.deleted Record removed
model.bulk_update Multiple records changed

User Events

user.connected WebSocket connection established
user.activity User interaction events
user.typing Real-time typing indicators
user.disconnected Connection closed

System Events

system.deployment App deployment status
system.health Health check updates
system.maintenance Maintenance notifications
system.alert Critical system alerts

Simple WebSocket Integration

Connect to real-time events with minimal code

1

Connect to WebSocket

Establish connection to your app's WebSocket endpoint

2

Subscribe to Events

Listen for specific event types or channels

3

Handle Updates

Update your UI instantly when events arrive

WebSocket API Reference
JavaScript
Python
websocket-client.js
// Connect to your app's WebSocket
const ws = new WebSocket('wss://app.fiberwise.ai/ws/my-app');

// Listen for agent events
ws.addEventListener('message', (event) => {
  const data = JSON.parse(event.data);
  
  switch(data.event) {
    case 'agent.started':
      showProgress(data.agent_id);
      break;
      
    case 'agent.completed':
      updateResults(data.result);
      break;
      
    case 'model.created':
      addToList(data.record);
      break;
  }
});

// Subscribe to specific channels
ws.send(JSON.stringify({
  action: 'subscribe',
  channels: ['agents', 'users', 'chats']
}));
websocket_client.py
import websockets
import json

async def websocket_client():
    uri = "wss://app.fiberwise.ai/ws/my-app"
    
    async with websockets.connect(uri) as websocket:
        # Subscribe to events
        await websocket.send(json.dumps({
            "action": "subscribe",
            "channels": ["agents", "models"]
        }))
        
        # Listen for events
        async for message in websocket:
            data = json.loads(message)
            
            if data["event"] == "agent.completed":
                print(f"Agent {data['agent_id']} finished!")
                process_result(data["result"])
                
            elif data["event"] == "model.created":
                print(f"New {data['model']} created: {data['id']}")
                update_ui(data["record"])

Real-Time Use Cases

Perfect for applications that need instant updates

Live Chat Applications

Instant message delivery, typing indicators, and presence status for real-time communication

Instant messaging Typing indicators User presence

Live Dashboards

Real-time metrics, charts that update instantly, and live data visualization without page refreshes

Live metrics Auto-updating charts Real-time alerts

Collaborative Tools

Multiple users working together with instant updates, conflict resolution, and activity tracking

Multi-user editing Conflict resolution Activity feeds

AI Progress Tracking

Live updates during AI agent execution, progress bars, and instant result delivery

Agent progress Live results Error handling

High-Performance WebSocket Infrastructure

Built for scale with enterprise-grade reliability

10,000+
Concurrent connections per server
<5ms
Average event delivery time
99.9%
Message delivery reliability
Auto
Connection recovery & reconnection

Horizontal Scaling

Automatic load balancing across multiple WebSocket servers

Connection Management

Automatic reconnection, heartbeat monitoring, and graceful degradation

Efficient Filtering

Server-side event filtering reduces bandwidth and improves performance

Live Performance Monitor
Active Connections
8,247
Messages/Second
1,543
Avg Latency
3.2ms
Error Rate
0.01%

Ready to Add Real-Time Updates?

Learn how to integrate WebSocket events into your applications