> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lasscyber.com/llms.txt
> Use this file to discover all available pages before exploring further.

# analyzer_unavailable

> HTTP 503 — a specific analyzer's upstream is degraded. Retry with backoff.

|                 |                                                                    |
| --------------- | ------------------------------------------------------------------ |
| **HTTP status** | `503 Service Unavailable`                                          |
| **Code**        | `analyzer_unavailable`                                             |
| **Retry?**      | Yes — honour `Retry-After`. SDKs retry automatically with backoff. |

## When this happens

A specific upstream that one of the analyzers depends on is degraded
or temporarily unavailable. The detail object names which analyzer
failed and the upstream HTTP status (when known). Examples:

* The internal model service is unreachable (prompt-injection
  classifier or ShieldGemma).
* Google Cloud DLP, NLP, Web Risk, or Vertex AI Embeddings is in a
  partial outage.

The error is fail-closed: the affected analyzer raises rather than
silently skipping, so your combined run never returns a *false*
"allow" because of an upstream blip.

## Example response

```http theme={null}
HTTP/1.1 503 Service Unavailable
Retry-After: 10
```

```json theme={null}
{
  "detail": {
    "message": "Adversarial detection upstream is temporarily unavailable",
    "code": "analyzer_unavailable",
    "analyzer": "adversarial_detection",
    "upstream_status": 502
  },
  "code": "analyzer_unavailable",
  "request_id": "5b3f6c7e-7d24-4d40-9b12-3a59c01c6e91",
  "doc_url": "https://docs.lasscyber.com/errors/analyzer_unavailable"
}
```

## How to recover

1. Read `Retry-After` (seconds).
2. Sleep + jitter, then retry up to 3 times.
3. If the third attempt still fails, escalate to the
   [status page](https://status.lasscyber.com).

The official SDKs do this automatically. Calls fail with a
`ServerError` (Python) / `ServerError` (TypeScript) only after the
configured retry budget is exhausted.

## Failing open vs closed

Agnes intentionally fails **closed** on `analyzer_unavailable` so
production traffic does not silently skip an analyzer the policy
relies on. If your application needs to fail-open during analyzer
outages (a deliberate choice — most do not), catch the SDK exception
and degrade gracefully:

```python theme={null}
from agnes import Agnes, ServerError

agnes = Agnes()
try:
    decision = agnes.analyze(prompt, policy="default-inbound")
except ServerError as e:
    if e.code == "analyzer_unavailable":
        # decide your own fallback policy here
        return your_own_default_decision()
    raise
```

## SDK behaviour

| SDK        | Exception                                                   |
| ---------- | ----------------------------------------------------------- |
| Python     | `agnes.ServerError` (with `code == "analyzer_unavailable"`) |
| TypeScript | `ServerError` (with `code === "analyzer_unavailable"`)      |

SDKs auto-retry up to the configured retry ceiling.

## Related

* [`service_unavailable`](/errors/service_unavailable) — generic 503
  not tied to a specific analyzer.
* [Combined analyzer](/concepts/combined-analyzer) — which analyzers
  call which upstreams.
* [status.lasscyber.com](https://status.lasscyber.com) — public
  health / incident history.