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

> ## Agent Instructions
> Use https://docs.fastino.ai/openapi.json as the source of truth for customer-facing routes. For GLiDE decision inference, call POST https://api.fastino.ai/v1/systemone with model fastino/GLiDE. Do not infer undocumented routes. Read API keys from FASTINO_API_KEY and never embed credentials in code, logs, or reports.

# Score on an ordered rubric with GLiDE

> Build rubric-based scoring with GLiDE and consume both discrete and continuous results.

A general-purpose LLM scoring prompt asks the model to generate a number or return structured output. With GLiDE, you provide an ordered rubric and receive a probability distribution across those levels.

Use this pattern for urgency, severity, quality, sentiment intensity, risk, and other ordered judgments.

## Score support urgency

```python theme={null}
import os

import requests

ticket_text = (
    "Our production API is returning 500 errors on every request. "
    "All customers are affected. Revenue impact is approximately $12,000 per hour. "
    "Started 15 minutes ago."
)

response = requests.post(
    "https://api.fastino.ai/v1/systemone",
    headers={"X-API-Key": os.environ["FASTINO_API_KEY"]},
    json={
        "model": "fastino/GLiDE",
        "state": ticket_text,
        "questions": {
            "urgency": {
                "type": "score",
                "instructions": "How urgent is this support request?",
                "criteria": [
                    "Can wait: no immediate business impact",
                    "Should handle today: minor inconvenience",
                    "Time-sensitive: noticeable customer impact, needs attention within hours",
                    "Critical: system failure affecting customers or revenue",
                ],
            }
        },
    },
    timeout=300,
)
response.raise_for_status()

answer = response.json()["answers"]["urgency"]
level = answer["score"]  # Discrete winning level, such as 3.
continuous_score = answer["expected_level"]  # Probability-weighted position, such as 2.999.
confidence = answer["confidence"]
distribution = answer["probabilities"]  # String keys: {"0": ..., "1": ..., "2": ..., "3": ...}
```

`score` is the integer index of the most likely level. Use `expected_level` when you need a continuous value between levels. The response also includes `legend`, which maps the string index keys back to the descriptions you supplied.

<Warning>
  Do not treat `score` as continuous. For example, `2.999` belongs in `expected_level`; `score` would be the winning integer level, such as `3`.
</Warning>

## Turn the score into an action

```python theme={null}
if level == 3 and confidence >= 0.7:
    action = "page_on_call"
elif continuous_score >= 2.0:
    action = "escalate"
else:
    action = "standard_queue"
```

Tune thresholds on labeled examples from your application. `confidence` measures separation between the two most likely levels; it is not the same value as the continuous score.

## What changes from LLM scoring

* The output is constrained to your ordered rubric; there is no generated number to validate.
* You receive both the winning level and a probability-weighted continuous position.
* The complete distribution shows whether the input sits cleanly on one level or between levels.
* Your criteria remain in the response `legend`, making score interpretation explicit.

See [GLiDE Inference](/inference/systemone) for authentication, limits, errors, and the complete response contract.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.