# Model types

> Which models you call over HTTP and which run in your own program, and what each takes.

Section: Models. Web page: https://www.launchables.ai/docs/model-types

Every Myles model is a decision model. It reads a situation, a question and a list of options, and returns a probability for every option in one forward pass. No Myles model writes text, and we do not offer a text or chat model: there is no `/v1/chat/completions` or `/v1/completions` endpoint, and a request to either gets `404`. For drafting, summarising or conversation, use a general-purpose LLM beside Myles (see [Myles vs general LLMs](https://www.launchables.ai/compare)).

What differs between models is how you call them. There are two kinds.

| Kind | Models | How you call it | You send | You get back |
|---|---|---|---|---|
| **GPU decision model** | Myles-G 31B, 12B, Edge | HTTP: `POST /v1/decide` | One state and up to 16 typed questions, and on Myles-G 12B and Myles-G 31B up to 8 [images](https://www.launchables.ai/docs/api/images) | An answer per question, and token usage |
| **CPU decision model** | Myles-400M, 150M, 22M | A function in your own program | One state, one question and a list of options | A probability per option |

## GPU decision models: the Decision API

Myles-G is served only for decisions: the server reads one answer position and never returns generated text. Myles-G is called over HTTP, on our [hosted endpoint](https://www.launchables.ai/docs/deploy/hosted) (Myles-G 12B and Myles-G 31B) or on a server you run yourself, with the same request.

- **Endpoint:** `POST /v1/decide`. `POST /v1/systemone` is the same, for existing decision-model clients.
- **Request:** `state` (text or JSON), `questions` (named `noul`, `choice` or `score` questions), an optional `model`, and, on Myles-G 12B and Myles-G 31B, optional images in `assets` (see [Images](https://www.launchables.ai/docs/api/images)).
- **Response:** one JSON object, sent when every question is answered. There is no streaming.
- **Limits:** 16 questions and 26 options per question; 32,768 tokens of context on the hosted Myles-G 12B, 16,384 on the hosted Myles-G 31B. See [Errors and limits](https://www.launchables.ai/docs/api/errors).

```bash
curl https://api.launchables.ai/v1/decide \
  -H "Authorization: Bearer $LAUNCHABLES_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Your parcel is on hold. Pay the £1.99 customs fee here to release it today.",
    "questions": {
      "scam": {"type": "noul", "instructions": "Is this message a scam, phishing or fraud attempt?"}
    }
  }'
```

```json
{
  "model": "myles-g-12b",
  "answers": { "scam": { "type": "noul", "noul": 0.97 } },
  "usage": { "input_tokens": 104, "output_tokens": 1 }
}
```

Illustrative probability and token counts. On Node, the [JavaScript SDK](https://www.launchables.ai/docs/sdk-javascript) sends the same request:

```
import { Launchables, noul } from "launchables";

const client = new Launchables(); // reads LAUNCHABLES_API_TOKEN
const resp = await client.decide(
  "Your parcel is on hold. Pay the £1.99 customs fee here to release it today.",
  { scam: noul("Is this message a scam, phishing or fraud attempt?") },
);
console.log(resp.answers.scam.probability);
```

Every field is in the [API reference](https://www.launchables.ai/docs/api/decide), and each question type in [Question types](https://www.launchables.ai/docs/question-types).

## CPU decision models: in your own program

Myles-400M, 150M and 22M are small encoders. We do not host them and they have no HTTP API: you run the model file on your own CPU, with the short Python helper (`myles.py`) that comes with the weights. The API keys, the console and the SDK are not used.

- **Call:** `decide(state, question, options)`, one question per call.
- **Options:** a list of at least two short texts. There are no question types: for yes or no, pass `["no", "yes"]`; for a choice, the labels; for a scale, the levels in order.
- **Returns:** a dictionary of option to probability.
- **Input:** question, options and state together, up to 4,096 tokens on 400M, 1,536 on 150M and 320 on 22M. Longer states are cut.

```
from myles import Myles   # myles.py, in the folder with the weights

model = Myles(folder, threads=4)
model.decide(
    state="Your parcel is on hold. Pay the £1.99 customs fee here to release it today.",
    question="Is this message a scam, phishing or fraud attempt?",
    options=["no", "yes"],
)
# {'no': 0.1032, 'yes': 0.8968}
```

Output from Myles-150M. The weights are on Hugging Face for internal evaluation, on request: [Myles-400M](https://huggingface.co/launchables/myles-400m), [Myles-150M](https://huggingface.co/launchables/myles-150m) and [Myles-22M](https://huggingface.co/launchables/myles-22m). Production use is under a [licence](https://www.launchables.ai/licensing). Myles-22M also runs in a browser: [try it](https://www.launchables.ai/developers).

## Which to use

- **Several questions about one situation, or the hardest decisions:** Myles-G, through the Decision API.
- **No GPU, no network, or text that must stay on the device:** a CPU model, in your own program.
- **Writing or summarising text:** not a Myles model. Use a general-purpose LLM, and Myles for the decisions around it.