> ## 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.

# GLiDE primitives and request parameters

> The Noul, Choice, and Score primitives behind GLiDE decisions, plus the /v1/systemone request contract and confidence.

## Primitives

Every question you ask [GLiDE](/concepts/glide) uses one of three types, sent to `POST /v1/systemone` against a shared `state`:

* **[Noul](/concepts/glide-noul)** - a yes/no question that returns a probability between 0 and 1. Think of it as a boolean on a sliding scale. "Does this request qualify for a refund?" might return `0.999` - a 99.9% probability the answer is yes.
* **[Choice](/concepts/glide-choice)** - a pick-one-from-many question that returns a probability distribution over up to 255 named options. "Which team should handle this?" might return `{"billing": 0.0006, "returns": 0.999, "shipping": 0.0005}`.
* **[Score](/concepts/glide-score)** - a rate-on-a-scale question over an ordered rubric you define. "How urgent is this request?" with three levels might return `score: 0` (low) and `expected_level: 0.276` - a probability-weighted result between low and medium, closer to low.

Pick the type that matches the shape of the answer your code needs.

<Tip>
  Noul vs. Score: a Noul at `0.5` means maximum uncertainty between yes and no - it doesn't express degree. If you need to measure degree (urgency, severity, frustration), use a Score with defined levels. If you need a binary gate, use a Noul.
</Tip>

There is no multi-label primitive - each question is single-label. Ask several independent questions in one call if you need several simultaneous judgments; see [Combining multiple questions](#combining-multiple-questions).

## Limits

* Each rendered question prompt (`state` plus that question) must fit within **40,000
  tokens**.
* Choice and Score accept up to **255 options or levels**.
* One request evaluates one shared `state`. Put multiple named questions under `questions`;
  `/v1/systemone` does not accept a batch of independent states.
* `usage.input_tokens` sums internal passes across questions, so it can exceed 40,000 even
  though every individual rendered prompt fits.

## Endpoint

| Method | Path | Description |
| - | - | - |
| `POST` | `/v1/systemone` | Run one or more typed decision questions against a state |

See [GLiDE inference](/inference/systemone) for authentication, a complete cURL request,
response handling, retries, and errors.

## Request parameters

<ParamField body="state" type="string | object | array" required>
  The context to evaluate - a plain string, a JSON object, or a JSON array. See [State shapes](#state-shapes) below for guidance on which to use.
</ParamField>

<ParamField body="questions" type="object" required>
  One or more named, typed questions to evaluate against `state`. Each key is your chosen question name; each value is a question object with `type`, `instructions`, and (for `choice`/`score`) `criteria`. See [Noul](/concepts/glide-noul), [Choice](/concepts/glide-choice), and [Score](/concepts/glide-score) for the full per-type request and response shape.
</ParamField>

<ParamField body="model" type="string" required>
  Which decision model to use, e.g. `fastino/GLiDE`. Omitting it returns `422 'model' must be provided`. The response echoes it back with the provider prefix stripped (`fastino/GLiDE` → `glide`).
</ParamField>

### State shapes

`state` is the material every question is evaluated against - think of it as what you'd hand a panel of experts before asking them to make a judgment.

| Shape | Useful for | Example |
| - | - | - |
| String | A single message, article, or passage | `"My card was charged twice."` |
| Object | Named fields, related records, or app state | `{"message": "My card was charged twice.", "order_id": "A-104"}` |
| Array | A sequence of messages or records | `["Hi", "My order number is A-104.", "My card was charged twice."]` |

Use an object when the decision depends on comparing several named parts (a ticket plus the policy it's evaluated against, for example) - it keeps each part labeled and its relationships clear. A plain string is enough when the case is a single self-contained passage. All questions in a request see the same `state` and are evaluated independently against it.

## Confidence

Every answer carries a `confidence` value. The answer tells you *what* GLiDE concluded; confidence tells you *whether to act on it* - treat them as two separate axes, not one.

| Question type | Formula | Range |
| - | - | - |
| Noul | `\|2 × noul − 1\|` | `0` (maximum uncertainty, `noul = 0.5`) to `1` (fully certain, `noul = 0` or `1`) |
| Choice / Score | `top1 − top2` (probability margin between the best and second-best option or level) | `0` (two options tied) to `1` (one option has \~all the probability mass) |

A low-confidence answer isn't wrong - it means the probability mass is spread across two or more outcomes instead of concentrated on one, which is itself useful signal. A common pattern is **confidence-gated routing**: act automatically on high-confidence answers, and route low-confidence ones to a fallback (human review, a broader category, a secondary check):

```python theme={null}
answer = response["answers"]["department"]

if answer["confidence"] >= 0.6:
    route_to(answer["choice"])
else:
    route_to("triage-queue")  # ambiguous - let a human or a broader handler decide
```

Tune the threshold on real data for your use case rather than assuming `0.5` is correct - confidence is calibrated per model, not guaranteed to map onto any particular business tolerance for ambiguity.

Each primitive page has a worked example and more on using its result: [Noul](/concepts/glide-noul), [Choice](/concepts/glide-choice), [Score](/concepts/glide-score).

## Combining multiple questions

Ask multiple questions of different types against the same `state` in a single call. All questions are evaluated together in one round trip.

<CodeGroup>
  ```bash cURL theme={null}
  curl -s https://api.fastino.ai/v1/systemone \
    -H "X-API-Key: $FASTINO_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "fastino/GLiDE",
      "state": "Refund request: the receipt is attached, the purchase was 10 days ago, and refunds are allowed within 30 days.",
      "questions": {
        "department": {
          "type": "choice",
          "instructions": "Which team should handle this request?",
          "criteria": {
            "billing": "Payment or charge disputes",
            "returns": "Refund or return requests",
            "shipping": "Delivery or shipping issues"
          }
        },
        "urgency": {
          "type": "score",
          "instructions": "How urgent is this request?",
          "criteria": [
            "low urgency, can wait",
            "medium urgency, handle soon",
            "high urgency, handle immediately"
          ]
        }
      }
    }'
  ```
</CodeGroup>

Response:

```json theme={null}
{
  "model": "glide",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "returns",
      "confidence": 0.9992611288391886,
      "probabilities": {
        "billing": 0.00031500429476013744,
        "returns": 0.9995761331339488,
        "shipping": 0.00010886257129113499
      }
    },
    "urgency": {
      "type": "score",
      "score": 0,
      "expected_level": 0.27621539375795195,
      "confidence": 0.4999999998141525,
      "probabilities": {
        "0": 0.7412615353520668,
        "1": 0.24126153553791435,
        "2": 0.017476929110018805
      },
      "legend": {
        "0": "low urgency, can wait",
        "1": "medium urgency, handle soon",
        "2": "high urgency, handle immediately"
      }
    }
  },
  "usage": { "input_tokens": 743, "output_tokens": 252 },
  "token_usage": 995
}
```


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