Grok 4.1 Fast Non-Reasoning is xAI’s named direct-response variant in the Grok 4.1 Fast family. The manufacturer releases it separately from the reasoning variant, identifying it as the choice for immediate responses. It is useful for a text conversation or tool-assisted step with a clear instruction, known inputs and a defined result. Non-Reasoning selects the response mode; Grok 4.1 Fast remains a distinct family from the ordinary Grok 4.1 model and from Grok 4 Fast.
xAI develops Grok 4.1 Fast around real-world tool use. Its reinforcement-learning training uses simulated environments with varied tools across many domains, with customer support highlighted as a practical application. For a task of that kind, give the model the user’s request, the relevant rules and the functions the application permits. State what information is needed to choose the next action. An illustrative workflow is to identify the user’s current issue, request a missing detail, select a lookup and then prepare a short response based on the returned information.
The producer also emphasises long-horizon reinforcement learning and multi-turn scenarios. This matters when a request continues through several actions or clarifications. Preserve the original goal, important constraints, previous answers and actual function results so the next response can reflect the current task state. If a tool reports that information is missing or an action failed, include that result instead of assuming success. Ask the model to explain the next required step in terms of the observed state, and keep a proposed action distinct from an action that the application has completed.
The family has a manufacturer-described two-million-token context. A large window can hold substantial conversation history, instructions and supporting documents, but the prompt should still make the current question easy to find. Give documents stable titles, preserve relevant identifiers and identify the source of a factual statement. For a long support case, ask for the issue as it stands now, the facts already established and the next unanswered question. For document processing, specify the fields to extract and how an absent or conflicting value should be represented.
The Grok 4.1 Fast announcement also introduces a separate tool service for search, code execution and document retrieval. The model’s tool-calling capability and the availability of a particular tool are different parts of the workflow. Describe the tools your application actually provides and return their results to the conversation. In a research task, define the question, scope and evidence you need, then ask for a synthesis tied to the retrieved material. In a data task, use actual calculation results as input to the explanation instead of treating a generated number as a completed computation.
For a direct text operation, make the output brief compact and precise. You might ask for a rewritten paragraph that preserves specified facts, a short summary of supplied material, a category chosen under explicit rules, or a table of extracted details. Include examples when the expected format has important edge cases. These are illustrative applications of the text and agentic workflow, rather than claims that every input will produce a correct result. The direct-response mode can keep the result focused when the task is already well specified.
For factual work, ask it to distinguish source-backed information from assumptions and to flag missing evidence. Check important names, identifiers, values and claimed action outcomes against the original material or actual tool response. A large context and a quick response process do not replace that check. Choose the separately named reasoning variant when you want a different problem-solving process, while retaining Non-Reasoning for clear instructions and a direct final answer. Define completion by the requested result and any confirmed operation outcome, not merely by the model having produced a response.
", "aboutText": "Grok 4.1 Fast Non-Reasoning is xAI’s named direct-response variant in the Grok 4.1 Fast family. The manufacturer releases it separately from the reasoning variant, identifying it as the choice for immediate responses. It is useful for a text conversation or tool-assisted step with a clear instruction, known inputs and a defined result. Non-Reasoning selects the response mode; Grok 4.1 Fast remains a distinct family from the ordinary Grok 4.1 model and from Grok 4 Fast.\n\nxAI develops Grok 4.1 Fast around real-world tool use. Its reinforcement-learning training uses simulated environments with varied tools across many domains, with customer support highlighted as a practical application. For a task of that kind, give the model the user’s request, the relevant rules and the functions the application permits. State what information is needed to choose the next action. An illustrative workflow is to identify the user’s current issue, request a missing detail, select a lookup and then prepare a short response based on the returned information.\n\nThe producer also emphasises long-horizon reinforcement learning and multi-turn scenarios. This matters when a request continues through several actions or clarifications. Preserve the original goal, important constraints, previous answers and actual function results so the next response can reflect the current task state. If a tool reports that information is missing or an action failed, include that result instead of assuming success. Ask the model to explain the next required step in terms of the observed state, and keep a proposed action distinct from an action that the application has completed.\n\nThe family has a manufacturer-described two-million-token context. A large window can hold substantial conversation history, instructions and supporting documents, but the prompt should still make the current question easy to find. Give documents stable titles, preserve relevant identifiers and identify the source of a factual statement. For a long support case, ask for the issue as it stands now, the facts already established and the next unanswered question. For document processing, specify the fields to extract and how an absent or conflicting value should be represented.\n\nThe Grok 4.1 Fast announcement also introduces a separate tool service for search, code execution and document retrieval. The model’s tool-calling capability and the availability of a particular tool are different parts of the workflow. Describe the tools your application actually provides and return their results to the conversation. In a research task, define the question, scope and evidence you need, then ask for a synthesis tied to the retrieved material. In a data task, use actual calculation results as input to the explanation instead of treating a generated number as a completed computation.\n\nFor a direct text operation, make the output brief compact and precise. You might ask for a rewritten paragraph that preserves specified facts, a short summary of supplied material, a category chosen under explicit rules, or a table of extracted details. Include examples when the expected format has important edge cases. These are illustrative applications of the text and agentic workflow, rather than claims that every input will produce a correct result. The direct-response mode can keep the result focused when the task is already well specified.\n\nFor factual work, ask it to distinguish source-backed information from assumptions and to flag missing evidence. Check important names, identifiers, values and claimed action outcomes against the original material or actual tool response. A large context and a quick response process do not replace that check. Choose the separately named reasoning variant when you want a different problem-solving process, while retaining Non-Reasoning for clear instructions and a direct final answer. Define completion by the requested result and any confirmed operation outcome, not merely by the model having produced a response.", "editorialOverlay": { "copy_fields": { "practical_html": "Technical example in English
Continue a support case from its state\n\nContinue this support conversation with one concise reply. Customer: I cannot find order K19. Earlier reply: Please confirm the checkout email. Customer: It is pat@example.test. Supplied lookup result: No order found for K19 and that email. Ask for the next useful detail without saying the order was cancelled, refunded or located.One customer-facing reply acknowledging the unsuccessful lookup and asking for a relevant missing order detail.Check that the reply reflects the supplied no-match result and claims no completed account or order action.grok-4-1-fast-non-reasoningGrok 4.1 Fast Non-Reasoning is xAI’s direct-response variant for text conversations and tool-assisted tasks. The family’s two-million-token context and multi-turn training help keep substantial task history, instructions and returned tool information together.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Grok 4.1 Fast Non-Reasoning is xAI’s named direct-response variant in the Grok 4.1 Fast family. The manufacturer releases it separately from the reasoning variant, identifying it as the choice for immediate responses. It is useful for a text conversation or tool-assisted step with a clear instruction, known inputs and a defined result. Non-Reasoning selects the response mode; Grok 4.1 Fast remains a distinct family from the ordinary Grok 4.1 model and from Grok 4 Fast.
xAI develops Grok 4.1 Fast around real-world tool use. Its reinforcement-learning training uses simulated environments with varied tools across many domains, with customer support highlighted as a practical application. For a task of that kind, give the model the user’s request, the relevant rules and the functions the application permits. State what information is needed to choose the next action. An illustrative workflow is to identify the user’s current issue, request a missing detail, select a lookup and then prepare a short response based on the returned information.
The producer also emphasises long-horizon reinforcement learning and multi-turn scenarios. This matters when a request continues through several actions or clarifications. Preserve the original goal, important constraints, previous answers and actual function results so the next response can reflect the current task state. If a tool reports that information is missing or an action failed, include that result instead of assuming success. Ask the model to explain the next required step in terms of the observed state, and keep a proposed action distinct from an action that the application has completed.
The family has a manufacturer-described two-million-token context. A large window can hold substantial conversation history, instructions and supporting documents, but the prompt should still make the current question easy to find. Give documents stable titles, preserve relevant identifiers and identify the source of a factual statement. For a long support case, ask for the issue as it stands now, the facts already established and the next unanswered question. For document processing, specify the fields to extract and how an absent or conflicting value should be represented.
The Grok 4.1 Fast announcement also introduces a separate tool service for search, code execution and document retrieval. The model’s tool-calling capability and the availability of a particular tool are different parts of the workflow. Describe the tools your application actually provides and return their results to the conversation. In a research task, define the question, scope and evidence you need, then ask for a synthesis tied to the retrieved material. In a data task, use actual calculation results as input to the explanation instead of treating a generated number as a completed computation.
For a direct text operation, make the output brief compact and precise. You might ask for a rewritten paragraph that preserves specified facts, a short summary of supplied material, a category chosen under explicit rules, or a table of extracted details. Include examples when the expected format has important edge cases. These are illustrative applications of the text and agentic workflow, rather than claims that every input will produce a correct result. The direct-response mode can keep the result focused when the task is already well specified.
For factual work, ask it to distinguish source-backed information from assumptions and to flag missing evidence. Check important names, identifiers, values and claimed action outcomes against the original material or actual tool response. A large context and a quick response process do not replace that check. Choose the separately named reasoning variant when you want a different problem-solving process, while retaining Non-Reasoning for clear instructions and a direct final answer. Define completion by the requested result and any confirmed operation outcome, not merely by the model having produced a response.
POST /v1/chat/completionstexttext| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits grok-4-1-fast-non-reasoning | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits Minimum items: 1 | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits Examples: system, user, assistant, tool, function Conditions: These roles are explicitly represented by Source compatibility types; the exact model role set remains model-specific. Model-specific | Default— |
Fieldmessages[].content | Typestring|content_part[]|null | RequirementOptional | Values & limits | Default— |
Fieldmessages[].tool_calls | Typetool_call[] | RequirementOptional | Values & limits | Default— |
Fieldmessages[].tool_call_id | Typestring | RequirementOptional | Values & limits Applies when: role=tool; use actual returned ID | Default— |
Fieldmessages[].name | Typestring | RequirementOptional | Values & limits | Default— |
Fieldmessages[].reasoning_content | Typestring | RequirementOptional | Values & limits Applies when: Round-trip actual returned reasoning where this model uses it | Default— |
Fieldmessages[].reasoning_details | Typeobject|array | RequirementOptional | Values & limits Model-specific | Default— |
Fieldmax_tokens | Typeinteger | RequirementOptional | Values & limits Minimum: 1 Model-specific | Default— |
Fieldmax_completion_tokens | Typeinteger | RequirementOptional | Values & limits Minimum: 1 Model-specific | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Fieldstream_options.include_usage | Typeboolean | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtemperature | Typenumber | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtop_p | Typenumber | RequirementOptional | Values & limits Model-specific | Default— |
Fieldstop | Typestring|string[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtools | Typefunction_tool[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtools[].type | Typestring | RequirementOptional | Values & limits function Model-specific | Default— |
Fieldtools[].function.name | Typestring | RequirementRequired | Values & limits Applies when: function tool supplied | Default— |
Fieldtools[].function.description | Typestring | RequirementOptional | Values & limits | Default— |
Fieldtools[].function.parameters | TypeJSON_schema | RequirementOptional | Values & limits | Default— |
Fieldtool_choice | Typestring|object | RequirementOptional | Values & limits Model-specific | Default— |
Fieldparallel_tool_calls | Typeboolean | RequirementOptional | Values & limits Model-specific | Default— |
Fieldresponse_format | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldreasoning_effort | Typestring | RequirementOptional | Values & limits Model-specific | Default— |
Fieldreasoning | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldservice_tier | Typestring | RequirementOptional | Values & limits Model-specific | Default— |
Fieldinstructions | Typestring | RequirementOptional | Values & limits Compatibility field | Default— |
Fieldfunctions | Typefunction[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldfunction_call | Typestring|object | RequirementOptional | Values & limits Model-specific | Default— |
Fieldprompt_cache_options | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldmodalities | Typestring[] | RequirementOptional | Values & limits text | Default— |
Fieldprovider | Typeobject | RequirementOptional | Values & limits Conditions: provider.options is rejected on this Ultra text route | Default— |
Fieldcache_control.ttl | Typestring | RequirementOptional | Values & limits Conditions: 1h is rejected in actual prompt-cache locations | Default— |
Text · UTF8 text
messages[].content
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages |
Parametermaterial_types | Contracttext |
Parametermessages | Contractmessage array with role/content shape |
Parameterfile_material | Contractactual UTF-8 document inserted as literal text; no file ID inferred |
Parameteroptional_controls | Contractstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Parametercontrol_scope | Contractmodel-specific; user function tools differ from hosted tools |
Parameteroutput_modalities | Contracttext |
Parameterhosted_operations | Contractfalse |
Parametermultimodal_input_binding | Contractnull |
Lifecycle: synchronous_or_streamed
Send exact model ID with messages.
Context length is not an output cap.
A text file may supply literal text; image/audio/file-object inputs need exact binding.
Tariff references do not add request options. Supported parameters are listed for the selected method.
| Configuration | Rate schedule | Charge |
|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Charge Input · Input tokens $0.0004 / 1K tokens Output · Output tokens $0.001 / 1K tokens Input · Cache read $0 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "grok-4-1-fast-non-reasoning", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model='grok-4-1-fast-non-reasoning',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\nfrom openai import OpenAI\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.chat.completions.stream(model='grok-4-1-fast-non-reasoning',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_completion()\n save_result(final.to_dict(mode="json"),"stream-result")\njson or SSE
Keep every complete returned response, file and content part.
Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldchoices[].index | Typeinteger |
Fieldchoices[].message.content | Typestring|null |
Fieldchoices[].message.tool_calls | Typetool_call[] |
Fieldchoices[].message.reasoning_content | Typestring |
Fieldchoices[].message.reasoning_details | Typeobject|array |
Fieldchoices[].finish_reason | Typestring|null |
Fieldusage | Typeobject |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |
Ailoot Ultra grok-4-1-fast-non-reasoning
Use the method paths shown above.
grok-4-1-fast-non-reasoningGrok 4.1 Fast Non-Reasoning is xAI’s direct-response variant for text conversations and tool-assisted tasks. The family’s two-million-token context and multi-turn training help keep substantial task history, instructions and returned tool information together.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Grok 4.1 Fast Non-Reasoning is xAI’s named direct-response variant in the Grok 4.1 Fast family. The manufacturer releases it separately from the reasoning variant, identifying it as the choice for immediate responses. It is useful for a text conversation or tool-assisted step with a clear instruction, known inputs and a defined result. Non-Reasoning selects the response mode; Grok 4.1 Fast remains a distinct family from the ordinary Grok 4.1 model and from Grok 4 Fast.
xAI develops Grok 4.1 Fast around real-world tool use. Its reinforcement-learning training uses simulated environments with varied tools across many domains, with customer support highlighted as a practical application. For a task of that kind, give the model the user’s request, the relevant rules and the functions the application permits. State what information is needed to choose the next action. An illustrative workflow is to identify the user’s current issue, request a missing detail, select a lookup and then prepare a short response based on the returned information.
The producer also emphasises long-horizon reinforcement learning and multi-turn scenarios. This matters when a request continues through several actions or clarifications. Preserve the original goal, important constraints, previous answers and actual function results so the next response can reflect the current task state. If a tool reports that information is missing or an action failed, include that result instead of assuming success. Ask the model to explain the next required step in terms of the observed state, and keep a proposed action distinct from an action that the application has completed.
The family has a manufacturer-described two-million-token context. A large window can hold substantial conversation history, instructions and supporting documents, but the prompt should still make the current question easy to find. Give documents stable titles, preserve relevant identifiers and identify the source of a factual statement. For a long support case, ask for the issue as it stands now, the facts already established and the next unanswered question. For document processing, specify the fields to extract and how an absent or conflicting value should be represented.
The Grok 4.1 Fast announcement also introduces a separate tool service for search, code execution and document retrieval. The model’s tool-calling capability and the availability of a particular tool are different parts of the workflow. Describe the tools your application actually provides and return their results to the conversation. In a research task, define the question, scope and evidence you need, then ask for a synthesis tied to the retrieved material. In a data task, use actual calculation results as input to the explanation instead of treating a generated number as a completed computation.
For a direct text operation, make the output brief compact and precise. You might ask for a rewritten paragraph that preserves specified facts, a short summary of supplied material, a category chosen under explicit rules, or a table of extracted details. Include examples when the expected format has important edge cases. These are illustrative applications of the text and agentic workflow, rather than claims that every input will produce a correct result. The direct-response mode can keep the result focused when the task is already well specified.
For factual work, ask it to distinguish source-backed information from assumptions and to flag missing evidence. Check important names, identifiers, values and claimed action outcomes against the original material or actual tool response. A large context and a quick response process do not replace that check. Choose the separately named reasoning variant when you want a different problem-solving process, while retaining Non-Reasoning for clear instructions and a direct final answer. Define completion by the requested result and any confirmed operation outcome, not merely by the model having produced a response.
POST /v1/messagestextjson, sse| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits grok-4-1-fast-non-reasoning | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits user, assistant | Default— |
Fieldmessages[].content | Typestring | RequirementRequired | Values & limits | Default— |
Fieldmax_tokens | Typeinteger | RequirementRequired | Values & limits | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Text · UTF-8 text
messages[].content string
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages, max_tokens |
Parameteroptional_controls | Contractstream |
Parametermaterial_types | Contracttext |
Parametertext_file_material | ContractRead the actual UTF-8 document and put its text in the indicated input or message content string. |
Lifecycle: synchronous_or_streamed
Tariff references do not add request options. Supported parameters are listed for the selected method.
| Configuration | Rate schedule | Charge |
|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Charge Input · Input tokens $0.0004 / 1K tokens Output · Output tokens $0.001 / 1K tokens Input · Cache read $0 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →
{\n "model": "grok-4-1-fast-non-reasoning",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'grok-4-1-fast-non-reasoning', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'grok-4-1-fast-non-reasoning', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON or SSE
Keep every complete returned response, file and content part.
Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldid | Typestring |
Fieldmodel | Typestring |
Fieldcontent[] | Typetext|thinking|tool_use|other content block |
Fieldstop_reason | Typestring|null |
Fieldusage | Typeobject |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |
Ailoot Ultra grok-4-1-fast-non-reasoning
Use the method paths shown above.
Technical example in English
Continue a support case from its state\n\nContinue this support conversation with one concise reply. Customer: I cannot find order K19. Earlier reply: Please confirm the checkout email. Customer: It is pat@example.test. Supplied lookup result: No order found for K19 and that email. Ask for the next useful detail without saying the order was cancelled, refunded or located.One customer-facing reply acknowledging the unsuccessful lookup and asking for a relevant missing order detail.Check that the reply reflects the supplied no-match result and claims no completed account or order action.