---
title: "How the numbers work"
section: "Agent Pool & Device Farm"
description: "How every number in SmartestQA Device Farm is calculated: agent and node online rules, performance cards and charts, device counts, heartbeat times, run minutes, run telemetry, App Library counts and live timeouts."
url: https://docs.smartestqa.ai/en/agent-pool-numbers.html
audience: [customer, admin]
updated: 2026-11-08
keywords: "agent online heartbeat 90 seconds node offline 180 seconds workers active total active sessions peak queued browser processes browser rss disk io devices available busy offline last heartbeat run minutes telemetry temperature battery memory cpu app library applications versions live timeout lease"
---
# Agent Pool & Device Farm: How the numbers work

Every number, state and time limit in Device Farm, how it is calculated, and an example you can check against your own screen.

## In short

**On this page you can**

- Understand when an agent, a node and its devices count as Online or Offline .
- Read the performance cards: Workers (active/total) , Active sessions , Peak .
- Check how the Min of a farm run and its device metrics are worked out.
- Know the timeouts of live sessions, installs and long runs.

**How to use it**

1. Find the number you see on screen in the headings below.
2. Read the formula box: what is counted and where it comes from.
3. Compare the worked example with your own values.
4. If a number still looks wrong, follow the link to the matching fix.

## Agent: Online and Offline

The rule for test agents (heartbeat every 5 seconds, Offline after 90 seconds of silence, checked every 30 seconds) and a worked example are on the Quick Start page: [When is an agent Online?](https://docs.smartestqa.ai/en/quick-start-connect.html#agent-online-rule) The list on [Test Agents](https://docs.smartestqa.ai/en/agent-pool-agents.html#agent-status) refreshes every 5 seconds and on every connect or disconnect. Smartest Server is always shown as Online.

## Node and devices: Online and Offline

**When is a node Offline?** — Shown in: Nodes › Name dot, Devices › “Node offline”

```text
heartbeat   = the node reports itself about every 30 s
Offline     = no heartbeat for 180 s
           OR no heartbeat for 60 s AND the node's live connection is closed
checked     = every 20 s
then        = every device of that node → Offline
              every active run on that node → Failed
back        = the node registers again → node and devices Online
```

**Example:** a node PC loses power at 14:00:05; its last heartbeat was 14:00:00 and its connection drops with it. At the first check after 14:01:00 (60 s of silence, connection closed) the node turns Offline, so between about 14:01:00 and 14:01:20. Its four phones show “Node offline”, and a run that was active on one of them is closed as Failed. If only the connection blips while heartbeats keep coming, nothing changes.

## Last Heartbeat

*Shown in: Nodes › Last Heartbeat*

```text
age = now − last heartbeat (seconds)
age < 60          → "just now"
age < 3,600       → floor(age ÷ 60) "min ago"
age < 86,400      → floor(age ÷ 3,600) "h ago"
otherwise         → floor(age ÷ 86,400) "d ago"
```

**Example:** a heartbeat 7,500 seconds ago shows “2 h ago” (7,500 ÷ 3,600 = 2.08). A healthy node always shows “just now”.

## Agent performance cards

*Shown in: Test Agents › middle panel*

```text
Total RAM              = physical memory ÷ 1024³, 1 decimal, GB
CPU cores              = logical cores (threads)
Free disk              = free space on the system drive ÷ 1024³, 1 decimal, GB
Active sessions        = browser sessions (Selenium + Playwright) open right now
  Peak                 = highest Active sessions since the agent started
Workers (active/total) = tests running now / tests the machine runs at the same time
Queued                 = tests waiting for a free worker
```

**Example:** a VM shows Workers 3 / 5, Queued 2, Active sessions 3, Peak 5. Three tests run, two wait, and at some point since the agent started five browsers were open together. A [pipeline](https://docs.smartestqa.ai/en/schedule-create.html) with ten tests on this agent finishes in batches of five at best.

**Read it right on Smartest Server:** Workers and Queued count every test running on the server, including other companies’ tests; the [Worker timeline](https://docs.smartestqa.ai/en/agent-pool-numbers.html#worker-timeline) shows only yours. A high Queued number there is the reason runs wait (see [server busy](https://docs.smartestqa.ai/en/quick-start-troubleshooting.html#fix-server-busy)).

## Agent performance charts

*Shown in: Test Agents › middle panel charts*

```text
CPU % / RAM % / Swap %   = machine-wide use at the sample time
Browser processes        = processes whose name contains chromium, chrome,
                           headless_shell, firefox, webkit, playwright or node
Browser RSS (MB)         = memory used by those processes together
System RAM (MB)          = memory in use on the machine
Disk I/O (MB/s)          = (bytes read or written since the last sample ÷ 1,048,576)
                           ÷ seconds since the last sample
JMeter / k6 users        = virtual users of a load test (line shown only if > 0 in the range)
history                  = up to 24 h, about one point per minute
live                     = one new point every 3 s while the browser tab is visible
```

**Example:** Appium runs on Node.js, so an idle mobile agent can show Browser processes of 1 or more with no browser open. Twelve Chrome processes for three tests is normal: one browser uses several processes.

The time range (30m, 1h, 4h, 12h, 24h) only cuts the view; it does not load other data.

### Worker timeline

*Shown in: Test Agents › Worker timeline*

```text
one row   = one test job (test case or schedule)
bar start = the time the job started
bar end   = the last time the job was seen running
visible   = jobs of your own company's projects only
title     = "Worker timeline (active/total active)"
```

**Example:** a test started at 10:02:10 and was last seen at 10:05:40. With range 1h the bar covers 3.5 of 60 minutes, about 6% of the width. Hover it for “Duration: 3m 30s”.

## Tab counts

*Shown in: Device Farm tab strip*

```text
Nodes (n)        = nodes you can see
Devices (n)      = devices you can see (before filters)
Recent runs (n)  = runs loaded: at most 200 (users of the cloud service: 100)
```

**Example:** Recent runs (200) with “showing last 200” means older runs exist but are not loaded.

## Device counts

*Shown in: Devices › status strip*

```text
Available     = devices in state ONLINE
Busy          = devices in state BUSY (a run or a live session holds them)
Offline       = every other state (offline, maintenance, unknown)
devices total = Available + Busy + Offline, before filters
Showing n     = devices left after filters, search and tags
```

**Example:** 10 devices: 6 Available, 1 Busy, 3 Offline. Filter OS = Android 14 and Availability = Available: “Showing 2 devices”, the strip still says 6 / 1 / 3 and 10 total.

## Recent runs › Min

*Shown in: Recent runs › Min*

```text
run ends normally  → Min = ceil(duration in seconds ÷ 60), at least 1
run closed by the
cleanup (node dead or
active for 120 min) → status Failed, Min = floor(duration in minutes), at least 1
still running      → "—"
```

| Duration | Calculation | Min |
| --- | --- | --- |
| 40 s | ceil(40 ÷ 60) = 1 | 1 |
| 61 s | ceil(61 ÷ 60) = 2 | 2 |
| 5 min 0 s | ceil(300 ÷ 60) = 5 | 5 |
| Node died after 7 min 50 s | floor(7.8) = 7 | 7 · Failed |

Every started minute counts as a full minute.

## Run telemetry

*Shown in: Recent runs › metrics icon › Device Metrics*

```text
big number      = the last sample of the main line (the app's line if it has data, else the device's)
Temperature     = °C, axis 0–60; big number turns red at ≥ 40 °C; also shows Peak
Battery         = %, shows Lowest (the drain), not Peak
Memory          = app MB; "%n" = round(app MB ÷ device total RAM × 100); Peak
CPU             = app %, and the whole device as a second line; Peak
Peak / Lowest   = highest / lowest sample of the main line during the run
```

**Example:** memory samples 410, 520 and 480 MB on a phone with 3,800 MB: the card shows 480 MB %13 (480 ÷ 3,800 = 12.6%) and Peak 520. Temperature samples 36, 39, 41 °C: 41 °C in red, Peak 41. Emulators have no temperature or battery sensor.

## App Library counts

*Shown in: App Library › top strip*

```text
Applications   = apps in the library
Versions       = stored builds; each app keeps one build, so Versions = Applications
Android / iOS  = apps per platform
MB stored      = sum of file sizes ÷ 1,048,576, 1 decimal
n app(s) missing package id = apps with no package id or bundle ID (hidden when 0)
limit          = 30 apps per company
```

**Example:** 4 Android apps of 52.4, 61.0, 18.3 and 9.9 MB and 1 iOS app of 140.2 MB: Applications 5 · Versions 5 · Android / iOS 4/1 · 281.8 MB stored.

## Live session timings

*Shown in: live device window*

```text
first connection timeout   = 75 s (Android) · 105 s (iOS)
reconnect timeout          = 30 s (Android) · 45 s (iOS)
automatic retries          = 3, after waits of 4 s, 10 s, 20 s
label while retrying       = "Reconnecting… (n/3)"
farm device lease          = 180 s, renewed while the stream is open
```

**Example:** an Android stream drops at 11:00:00. The window waits 4 s and reconnects (30 s budget); if that fails it waits 10 s, then 20 s. After the third failure it shows “Connection failed” and **Try Again**. If your browser crashed instead, the farm device frees itself by about 11:03:00.

## Other time limits

| Limit | Value | What happens |
| --- | --- | --- |
| Installing an app on a device | 6 min | The device is marked “timed out — no result from the device”. |
| One farm run | 120 min | The run is closed as Failed and the device returns to Available. |
| Node commands not picked up | 30 min | The queued command is dropped. |
