# AI Agent Stack Availability and Downtime Calculator

> Source: https://netray.co/tools/ai-agent-stack-availability-downtime-calculator
> Publisher: Netray (netray.co), AI and integration engineering for ERP and manufacturing systems.
> Section: Free Tools

## Short answer

Multiply component availabilities in an ERP AI stack into end-to-end uptime and hours of downtime per year, and see what a second GPU node buys.

## Category

on-prem-ai

## Audience

- CIO
- IT manager
- Infrastructure

## Tool

**Kind:** calculator

**Inputs:**

#### ERP API availability

**Key:** erp_av

**Type:** number

**Default:** 99.9

**Min:** 90

**Max:** 100

**Step:** 0.01

**Unit:** %

#### LLM inference node availability

**Key:** llm_av

**Type:** slider

**Default:** 99.5

**Min:** 95

**Max:** 99.99

**Step:** 0.05

**Unit:** %

**Help:** A single GPU server or a hosted API endpoint as you measure it.

#### Independent LLM nodes

**Key:** replicas

**Type:** select

**Default:** 1

**Options:**

##### 1 node

**Value:** 1

##### 2 nodes

**Value:** 2

##### 3 nodes

**Value:** 3

#### Vector database availability

**Key:** vec_av

**Type:** number

**Default:** 99.9

**Min:** 90

**Max:** 100

**Step:** 0.01

**Unit:** %

#### Gateway and authentication availability

**Key:** gw_av

**Type:** number

**Default:** 99.95

**Min:** 90

**Max:** 100

**Step:** 0.01

**Unit:** %

#### Network and hosting availability

**Key:** net_av

**Type:** number

**Default:** 99.9

**Min:** 90

**Max:** 100

**Step:** 0.01

**Unit:** %

**Outputs:**

#### Effective LLM tier availability

**Key:** llm_eff

**Expr:** (1 - pow(1 - llm_av / 100, replicas)) * 100

**Format:** decimal

**Description:** Redundant nodes in parallel: 1 - (1 - a) to the power of n.

#### End-to-end availability

**Key:** total

**Expr:** erp_av / 100 * llm_eff / 100 * vec_av / 100 * gw_av / 100 * net_av / 100 * 100

**Format:** decimal

**Primary:** true

**Description:** Serial components multiply.

#### Expected downtime per year

**Key:** downtime_hours

**Expr:** (1 - total / 100) * 8760

**Format:** hours

**Primary:** true

#### Expected downtime per month

**Key:** downtime_month

**Expr:** (1 - total / 100) * 730 * 60

**Format:** minutes

#### Downtime with a single LLM node

**Key:** single_hours

**Expr:** (1 - erp_av / 100 * llm_av / 100 * vec_av / 100 * gw_av / 100 * net_av / 100) * 8760

**Format:** hours

#### Hours per year saved by redundancy

**Key:** gain

**Expr:** single_hours - downtime_hours

**Format:** hours

**Chart:**

#### Annual downtime vs LLM node availability

**Type:** line

**X:** llm_av

**From:** 95

**To:** 99.9

**Steps:** 30

**Series:**

- downtime_hours

**Disclaimer:** Assumes independent failures and perfect failover. Real redundancy shares power, network and software, so treat results as an upper bound on availability.

## Content

**Intro:** An AI assistant depends on a chain: gateway, model server, vector store, ERP API and network. Each link has its own uptime, and they multiply. This calculator gives the end-to-end figure and shows what a second inference node adds.

**Sections:**

#### How to use it

**Body:** Enter measured availability for each component, from your monitoring over the last quarter rather than vendor claims. For hosted APIs use observed success rate, not the contractual SLA. Pick how many independent LLM nodes serve traffic. The result is the expected uptime if every component must work for a request to succeed. The chart sweeps the model tier's availability to show how much it moves the total.

#### The math

**Body:** For components in series, availability is the product of the individual values. For n identical independent nodes in parallel, tier availability = 1 - (1 - a) to the power n. Annual downtime = (1 - availability) x 8,760 hours. Five nines is about five minutes a year; three nines is almost nine hours.

**Bullets:**

- The weakest serial link dominates.
- Redundancy helps only the tier it duplicates.
- Maintenance windows count unless you can drain traffic.

#### Practical notes

**Body:** Decide what happens during an outage: graceful degradation to the ERP's native screens is better than a broken assistant. A single GPU server is often the weakest link, but a second node doubles hardware cost, so compare saved downtime hours against the business value of the assistant. Also test failover, including model reload times, since a node that takes minutes to load a large model is not instantly available.

**Cta:** Netray deploys on-prem inference with health checks and fallback behaviour. Talk to us if you want a high availability design reviewed.

**Faq:**

#### Why do components multiply?

**Answer:** If every part must work for a request to succeed, the chance all work together is the product of each chance, assuming failures are independent.

#### Is a second GPU node worth it?

**Answer:** It depends on how critical the assistant is. If it supports shift operations, yes. For occasional analytics, a documented manual fallback may be enough.

#### Do hosted LLM APIs have better uptime?

**Answer:** Not necessarily. Providers publish SLAs but incidents and rate limits still occur. Use your own measured success rate, and consider a second provider or local fallback model.

#### Are failures really independent?

**Answer:** Rarely. Shared power, switches, storage and software versions create correlated failures, so real availability is usually lower than the calculation.

## Search terms

ai stack availability calculator, composite availability serial components, llm uptime sla calculation, annual downtime hours calculator, ai agent sla planning, gpu redundancy availability, on prem llm high availability

---
Talk to an engineer: https://netray.co/contact?intent=erp_ai | Machine catalog: https://netray.co/agent/catalog.json