Could someone explain the precise interaction between Agent Scripting timeouts and the standard Handle Time metric in the performance dashboard? We are observing a discrepancy where agents who trigger a scripting timeout are being flagged with inflated handle times, which negatively impacts their individual KPIs.
The environment is running the latest Genesys Cloud release in the EU region. The specific flow utilizes the ‘Run Script’ action with a configured timeout of 120 seconds. When this threshold is breached, the system logs a ‘SCRIPT_TIMEOUT’ event, yet the call continues to accumulate time in the ‘Active’ state rather than transitioning to ‘Wrap-up’ or ‘After-Call Work’ immediately.
Business stakeholders are concerned that this technical limitation is skewing agent productivity reports. The current data suggests that agents using complex scripts are penalized for infrastructure delays, which is not reflective of their actual performance or efficiency during the conversation.
We require clarification on whether this is expected behavior for the scripting module or if a specific configuration in the flow can force a metric reset upon timeout. Understanding the exact mechanism of how scripting events map to queue performance views is critical for accurate reporting.
The simplest way to resolve this is to decouple the script execution timeout from the actual handle time calculation by leveraging custom data actions and state mapping within the Architect flow. The discrepancy arises because the standard handle time metric often captures the entire duration of the ‘Run Script’ action, including the idle wait period before the timeout triggers, which inflates the metric without reflecting productive agent effort. To correct this, configure the script action to output a specific status code upon timeout, such as ‘SCRIPT_TIMEOUT_IDLE’, and then route this outcome to a data action that explicitly sets a custom attribute, say ‘EffectiveHandleTime’, to zero or the actual talk time recorded prior to the timeout. This ensures that the performance dashboard can reference this clean, adjusted value instead of the raw, inflated interaction duration. Additionally, verify that the SIP registration stability on your BYOC trunks is not contributing to delayed timeout signals, as carrier-specific quirks in the EU region can sometimes cause silent failures that extend the perceived wait time before the local timeout logic engages. By implementing this explicit state management, you ensure that KPIs reflect true agent productivity rather than system latency or configuration artifacts, providing a more accurate view of performance while maintaining compliance with regional trunk management standards.
Check your interaction metadata export settings to ensure the script timeout duration is explicitly excluded from the handle_time calculation. The standard performance dashboard often aggregates the entire ‘Run Script’ action duration, including the idle wait period, into the agent’s handle time. For legal discovery and accurate chain of custody, this aggregation creates a false positive for productivity metrics. You need to verify if the interaction_type is being correctly tagged as digital or voice in the bulk export job, as digital channels often bundle wrap-up and script execution differently. The Recording API allows you to filter by start_time and end_time of specific interaction legs, which helps isolate the actual talking time from the automated script execution.
Configure a custom data action in Architect to capture the script_execution_start and script_execution_end timestamps separately. Map these to custom attributes that feed into a dedicated analytics dashboard, rather than relying on the native handle_time metric. This approach ensures that the 120-second timeout is treated as system latency, not agent effort. When exporting recordings via S3 for compliance, include these custom attributes in the metadata manifest to maintain audit trail integrity. This separation prevents the inflated KPIs you are seeing while preserving the full interaction record for any potential legal hold requests. The key is to stop trusting the default dashboard metric for scripted interactions and instead build a custom metric that excludes the timeout period.
The timeout duration is often counted as active handle time because the interaction state remains TALKING or WORKING while the script node is pending. To isolate this during load testing, you need to force a state change before the timeout triggers.
In the Architect flow, configure the Run Script node with a timeout of 120 seconds. Add an error path for the timeout event. On this path, insert a Set Interaction State node immediately. Set the state to AFTER_CALL_WORK or PAUSED. This action breaks the continuous handle time metric. The dashboard will then calculate handle time only up to the moment the state changed, excluding the idle wait period.
For accurate capacity planning, monitor the WebSocket connection pool. If agents are stuck in RUNNING_SCRIPT states for 120 seconds, this consumes significant server resources. Use JMeter to simulate this load. Create a thread group with 100 concurrent users. Each user should trigger a script timeout via the /api/v2/architect/flows execution endpoint. Measure the response time for the state transition. If the transition takes longer than 2 seconds, the API throughput is bottlenecked.
{
"action": "Set Interaction State",
"state": "AFTER_CALL_WORK",
"reason": "Script Timeout"
}
Check the interaction_type metadata in the export. Ensure the script_timeout flag is set to true. This allows filtering in the performance dashboard. The standard handle time metric will still show inflation if the state is not changed. The custom data action approach mentioned above is valid, but changing the interaction state is more immediate for real-time metrics.
During peak load, the 429 rate limit errors may occur if too many agents trigger timeouts simultaneously. Configure the JMeter script to add a random delay between 0 and 500 milliseconds between requests. This smooths the request spike and prevents API throttling. The WebSocket connection limit for Architect flows is typically 1000 per organization. Monitor this limit closely. If the limit is reached, new script executions will fail silently, causing further metric discrepancies.