How Ollama Declares, Requests, and Reports Model Capabilities

Ollama documents capability-related behavior through three distinct surfaces:

1. A Modelfile can declare CAPABILITY decision.
2. The CLI can request a decision from nimble.
3. The API can report and select model-specific thinking controls.

These examples should not be treated as stages in a universal capability lifecycle. The cited documentation does not establish that every Modelfile capability is discoverable through /api/show, that CLI options map directly to API fields, or that a declaration guarantees particular runtime behavior.

Evidence boundary: This is a documentation-based explanation. No commands or API requests were run.

Three examples, three conclusions

The key distinction is between declaring, invoking, and inspecting or selecting. Each example documents one surface, not an interchangeable system.

1. Declaring decision in a Modelfile

The Modelfile reference defines CAPABILITY as an instruction for declaring an additional model capability. Its documented example is:

CAPABILITY decision

This establishes the declaration syntax for the named decision capability (Ollama Modelfile reference). It does not, by itself, specify:

• How an application invokes a decision
• What response format to expect
• Whether particular CLI options are available
• Whether the declaration appears in API metadata
• What validation or runtime behavior occurs
• Whether results are accurate, stable, or deterministic

The same reference says Modelfile instructions are case-insensitive and may appear in any order; uppercase is used in examples to distinguish instructions from arguments (Ollama Modelfile reference). These are syntax conventions, not evidence that an underlying model successfully implements a declared capability.

The supported conclusion is narrow: CAPABILITY decision declares decision in a model definition. Invocation and runtime behavior require separate evidence.

2. Requesting decisions through the CLI

The CLI reference documents this basic decision-model command:

ollama run nimble --ask "Is a refund being requested?" < ticket.txt

The command invokes nimble, supplies a question through --ask, and passes the contents of ticket.txt through standard input (Ollama CLI reference). It establishes a command pattern, not the answer a given input will produce.

Supplying named choices

A second example provides named alternatives:

ollama run nimble --ask "Which team should handle this?" \
  --choice billing="Payments and refunds" \
  --choice technical="Software problems" < ticket.txt

Repeated --choice options supply identifiers and descriptions for the decision request (Ollama CLI reference). The example does not define a response schema, confidence scores, tie handling, selection guarantees, error behavior, or a corresponding API payload. An API client therefore should not infer a JSON field solely from the CLI option’s name.

Supplying levels

The CLI also shows repeated --level options:

ollama run nimble --ask "How urgent is this?" \
  --level "Routine" \
  --level "Soon" \
  --level "Immediate" < ticket.txt

This establishes that the command supplies those three labels to the request (Ollama CLI reference). Although the labels look like a progression, the supplied documentation does not formally define ordering, scoring, or distances between them. They are best described simply as level labels.

Together, these examples document CLI invocation. They do not show that adding CAPABILITY decision creates this interface for every model, nor do they document how the CLI maps its options to lower-level requests.

3. Inspecting and selecting thinking controls

Thinking uses a separate API surface. Ollama documents this /api/show request:

curl http://localhost:11434/api/show -d '{
  "model": "gpt-oss"
}'

The example response includes:

{
  "thinking": {
    "values": ["low", "medium", "high"],
    "default": "medium"
  }
}

For this gpt-oss example, /api/show reports three supported strings and a default of medium (Ollama thinking documentation). These values are model-specific, not universal levels for every thinking model.

The documentation defines several metadata cases:

• thinking.values may contain booleans for on/off controls.
• It may contain model-defined strings for named levels.
• thinking.default is used when think is not set.
• values: [false] means the model does not support thinking.
• If thinking is omitted, the model has no thinking metadata.

All of these interpretations are specific to the documented thinking interface (Ollama thinking documentation). Missing metadata does not prove that a model never conducts thinking; the documentation says the model might still do so through its existing behavior.

Selecting a thinking value

The think request control accepts these documented values:

Numbers are not supported. For a string value, clients should use the exact value returned by /api/show rather than assume that every model accepts names such as "low" or "high" (Ollama thinking documentation).

These controls select documented thinking behavior. They do not establish output quality, reasoning length, or deterministic results, and they do not describe the separate decision capability.

A practical reading checklist

When evaluating an Ollama capability example, ask:

1. Which surface is involved? A Modelfile, CLI command, or API response?
2. What operation is documented? Declaration, invocation, introspection, or request-time selection?
3. Is the value model-specific? Thinking strings returned by /api/show are model-defined.
4. What remains unspecified? Do not infer output schemas, quality, determinism, negotiation, or CLI-to-API mappings.

The resulting interpretation is limited but clear:

• CAPABILITY decision declares a capability in a Modelfile.
• nimble --ask, optionally with choices or levels, requests a decision through the CLI.
• /api/show reports model-specific thinking controls, while think selects a documented request value.

These are separate documented examples, not proof of a universal Ollama capability system.

Sources and further reading

• https://docs.ollama.com/modelfile
• https://docs.ollama.com/cli
• https://docs.ollama.com/capabilities/thinking