Cognitio Infer

Overview #

Cognitio Infer answers the questions Cognitio would get wrong by answering too fast. You give it a conversation — and, if you like, a list of tools it may ask you to run — and it works the problem through before it replies: a short reasoning trace first, then the answer. Ask for more effort and it thinks longer. Use it when the reply has to be right rather than quick, or when the task needs several steps.

Cognitio Infer is the larger sibling of Cognitio in the Response family. Where Cognitio is a 1.5B-parameter base with a small persona adapter, Cognitio Infer is a 7.6B-parameter open-weight instruct model served as its vendor published it, on the same GPU, in the same process. Falcon adds no weights of its own: what makes it a Falcon model is the serving contract around it — a whole-conversation endpoint, prompted thinking at three efforts, tool calling parsed into a stable shape, and the two public routes that expose them.

Input is a conversation as a list of messages: system, user, assistant and tool turns, oldest first, plus optional tool specifications and a thinking effort. Output is one assistant message: the answer as content, the thinking as reasoning when it was asked for, and zero or more tool_calls for the host to run. The cognitio command line, released with this model, is the reference host: its code mode gives Cognitio Infer six tools over a repository and runs the loop.

Like Cognitio, it has no classification heads and does not decide whether a reply is safe to give; a host that needs that check runs an intention model such as ELIM before calling it.

Intended use #

• Questions with a right answer that takes a few steps — arithmetic, unit reasoning, a small plan — where the thinking trace is worth the seconds it costs.
• Tool-using tasks: the host offers functions, the model asks for them one or more at a time, the host runs them and sends the results back until the model finishes.
• Agentic coding over a repository through the cognitio code harness, which reads, searches, edits and runs with the user's confirmation.

Out of scope #

• Small talk and one-line replies; Cognitio does those in under a second and at a fraction of the cost.
• Anything that must be answered inside a second, or many requests at once: one generation runs at a time on the shared GPU.
• Current facts, retrieval or memory of earlier conversations; it knows only what the messages and the tool results tell it.

Choose Cognitio Infer when #

• The answer has to be worked out rather than recalled, or the task needs tools, and a wait of several seconds is acceptable.
• The host can hold the whole conversation and run the tool loop itself; the model only ever sees what it is sent.
• Otherwise pick Cognitio: the same route, an answer in under a second, and a friend style for casual chat.

Specification #

Try it #

You send

“A shop sells pens at 3 for $2. How much do 21 pens cost, and what is the change from $20?”

You get back

A short reasoning trace (the ratio, the multiplication, the subtraction) followed by the answer: $14, with $6 change.

The same exchange as the API sees it:

{
  "model": "cognitio-infer",
  "think": "low",
  "tools": [
    { "type": "function", "function": { "name": "read_file", "description": "Read a file from the repository", "parameters": { "type": "object", "properties": { "path": { "type": "string" } }, "required": ["path"] } } }
  ],
  "messages": [
    { "role": "system", "content": "You are Cognitio Infer working as a coding assistant inside a software repository." },
    { "role": "user", "content": "What does bin/report.mjs print when it is given no arguments?" }
  ],
  "max_new_tokens": 640,
  "temperature": 0.3
}

{
  "message": {
    "role": "assistant",
    "content": "",
    "reasoning": "I have not seen the file yet, so I should read it before answering.",
    "tool_calls": [
      { "id": "call_1", "name": "read_file", "arguments": { "path": "bin/report.mjs" } }
    ]
  },
  "model": "cognitio-infer",
  "usage": { "prompt_tokens": 214, "completion_tokens": 58 },
  "latency_ms": 4100
}

Limits & safety #

Cognitio Infer does not see the host's files, shell, memory or user beyond what the messages and tool results carry: it reads a rendered conversation of at most 14,000 tokens and nothing else. It does not see images, locations, dates or the real time.

• Its reasoning is prompted, not trained: the trace is the base model thinking aloud under an instruction, it can be wrong while the answer is right and the reverse, and no effort level guarantees correctness.
• It is slow and single-file: seconds per turn, one generation at a time on a GPU shared with Cognitio, and a long tool loop is many turns.
• Its tools are whatever the host offers; it can ask for a call with wrong or harmful arguments, and it is the host that runs them. The reference harness confirms every write and command with the user for that reason, and refuses paths outside the repository.
• It has no retrieval, no current data and no memory across requests; long tool output crowds older turns out of the window, and the service refuses a conversation over 14,000 tokens rather than trimming it.
• It performs no input or output moderation of its own; an intention model such as ELIM, run before the call, is the intended check.
• It is non-deterministic at the default temperature, and the same conversation can produce a different trace and a different answer on a second call.
• The weights are a third party's published model; its knowledge, biases and licence are the vendor's, and Falcon distributes no weights for this model.

Related models #

Latest versions #