Model types

Myles-G is called through the Decision API; the CPU models run inside your own program.

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.

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

Detail	GPU decision model	CPU decision model
Models	Myles-G 31B, 12B, Edge	Myles-400M, 150M, 22M
How you call it	The Decision API: `POST /v1/decide`	A function in your own program
You send	One state and its typed questions (up to 256 on the hosted models), and on Myles-G 12B and Myles-G 31B up to 8 images	One state, one question and a list of options
You get back	An answer per question, and token usage	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 through the Decision API over HTTPS, on our hosted endpoint (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), model (always send it: myles-g-12b or myles-g-31b) and, on Myles-G 12B and Myles-G 31B, optional images in assets (see Images).
Response: one JSON object, sent when every question is answered. There is no streaming.
Limits: 256 questions and 256 options per question (4,096 options over a request), and 24,576 tokens of context on the hosted Myles-G 31B or 32,768 on the hosted Myles-G 12B. See Errors.

bash

curl https://api.mellix.com/v1/decide \
  -H "Authorization: Bearer $MELLIX_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "myles-g-12b",
    "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 }
}

The probability and token counts are illustrative. On Node, the JavaScript SDK sends the same request:

javascript

import { Mellix, noul } from "mellix";
 
const client = new Mellix(); // reads MELLIX_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?") },
  "myles-g-12b",
);
console.log(resp.answers.scam.probability);

Every field is in the API reference, and each question type in 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 it. You request access and download the files in the console; running them needs no API key, no SDK and no connection to us.

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, and 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.

python

from myles import Myles   # myles.py, in the folder with the model files
 
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}

That output is from Myles-150M. All three are available by request in the console (see Model access). Production use is under a licence per deployment, so talk to us. Myles-22M also runs in a browser.

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.