Skip to main content
Applies to version 2.0.1 or later of the Archetype platform.
Newton models are moving from the Direct Query API (POST /lens/query) to the Inference API, which runs platform-hosted models by name and offers two of them for text, image, and video:
  • newton-c-2.6: Newton C 2.6, the model you called on the Direct Query API as Newton::c2_6_8b_fp8_.... An 8B model that answers directly.
  • newton-fusion-1.0: Newton Fusion 1.0, a larger model that can reason step by step before it answers.
POST /inference/query takes the familiar Direct Query body, so most scripts move with a new URL and a new model name. Images, video, and inline data are the exception: several ways of attaching them are refused, and the models see video differently. This page maps the old request to the new one, shows the attachment paths that work, and lists what changed in practice, from moving our own demos and agent skills. The Direct Query API is still available, and for some inputs it is still the only option. Check Current Limitations before you move a script that sends images, uploaded files, long videos, or asks for long answers. Moving Omega embedding calls instead? See Migrating Omega from the Direct Query API. To check that your platform serves the Inference API, send a short text query. A 200 means it does; a 404 means it doesn’t yet.

What Changed

Current Limitations

As of November 15, 2026, on the production platform. This section will be updated as these limitations change.
Some things that work on the Direct Query API don’t work on the Inference API yet. If your app depends on one of them, keep that call on the Direct Query API for now. To keep a long answer within the time limit, ask for a shorter one in the prompt (for example, “Keep the answer under 300 words”) and lower max_new_tokens to about 1536.

Old Fields, New Fields

The response has the same shape as before: the answer is at response.response[0].

Moving a Script

1

Change the URL and the model

Replace /lens/query with /inference/query, and Newton::c2_6_8b_fp8_... with newton-c-2.6. A text-only query now works as before.
2

Remove the fields the Inference API refuses

Drop max_frames, multi_image, presence_penalty, and template_name. A refused field returns 400 with the message model '<model>' refused this request, which doesn’t name the field. If you get that message, remove optional fields one at a time to find it.
3

Move images, video, and data to a path that works

Video goes inline in file_ids, images go to /chat/completions or /responses, and text or tabular data goes in the query itself. See Sending Images, Video, and Data.
4

Allow for the first call

Raise your client timeout to about 180 seconds. The first call after a model has been idle can take about 40 seconds while a copy of it starts; later calls take a few seconds.
5

Try Newton Fusion 1.0

Change the model to newton-fusion-1.0 and handle its reasoning block. See Choosing a Model and Reasoning.

Sending Images, Video, and Data

Video

Send the clip inline as base64: followed by the file’s base64 data, in file_ids. The model reads 16 evenly spaced frames from it.
analyze_video.py
Run against a 31-second assembly clip, newton-c-2.6 answered:
Keep the request body under 2 MiB, which leaves room for about 1.4 MB of video once it is base64-encoded. A body just over 2 MiB can hang without an answer, and larger ones are refused with 413. Because the model only sees 16 frames at 224 × 224, you lose nothing by shrinking the clip first:
The same clip can go to /chat/completions as a video_url content part, or to /responses as an input_video content part, each with a data:video/mp4;base64,... URL.

Images

Send images as a data URI on the OpenAI-compatible endpoints: an image_url content part on /chat/completions, or an input_image part on /responses. Because these endpoints follow the OpenAI format, the OpenAI SDK works with your Archetype API key:
describe_image.py
On /inference/query, data.base64_img events and base64: images in file_ids are refused, and so is multi_image: true. Every image is resized to 224 × 224 pixels, whatever its size or shape, so small text and fine detail are lost: a 1024-pixel image reads the same as a 224-pixel copy. To read a label, a gauge, or a part number, crop to it before sending. When it can’t read a detail, Newton Fusion 1.0 may guess, while Newton C 2.6 tends to say it can’t tell, so check answers that depend on fine detail.

Text and Tabular Data

data.text and data.json events are refused, and so are text files attached in file_ids. Put the data in the query, after the question:

Choosing a Model

Both models take the same inputs and the same request body, so you can switch with one field.
  1. Start with Newton C 2.6. It is the model you used on the Direct Query API, it answers quickly, and it is enough for describing a scene, summarizing a clip, or classifying a state.
  2. Try Newton Fusion 1.0 when the task needs judgement over several steps, such as checking that each step of a procedure was done. Send it one short clip per step rather than one long clip. In our test of three assembly steps, Fusion judged all three correctly from one clip per step, against none from the full clip; Newton C 2.6 judged one of three correctly either way.
  3. Turn on Fusion’s reasoning when accuracy matters more than speed. Reasoning takes longer and needs a larger token budget; see Reasoning.
Whichever model you use, frame the input for what it can see: 16 frames at 224 × 224. Trim a clip to the action, and crop to the region that matters.

Reasoning

Newton Fusion 1.0 is a reasoning model. Its answer starts with a <think>...</think> block, which is empty when it answers directly. Remove the block before showing the answer, as the video example does.
  • To answer directly, end the query with /no_think. This works when the request includes an image or video. On a text-only request the model reasons anyway.
  • To let it reason, send the query without a switch. /think doesn’t force reasoning; the model decides. Set max_new_tokens to at least 2048 for images and video and 4096 for text, and repetition_penalty to 1.1. With a smaller budget, the answer can run out of tokens inside the reasoning block and come back with no answer at all; without the penalty, the reasoning can repeat itself, for example while counting vehicles in a busy scene.
  • Expect it to take longer. On a short video clip, an answer that reasons can take 20 to 50 seconds, against a few seconds without reasoning. A model has a time budget of about 60 seconds, after which the request returns 504.
If an answer has an opening <think> and no closing </think>, the model ran out of tokens while reasoning: raise max_new_tokens.

What Changed in Practice

These notes come from moving a live traffic-camera demo and our Newton agent skills to the Inference API.

Video Frames

The Direct Query API let you choose how many frames to read from a video, up to 64. The Inference API reads 16 evenly spaced frames from every clip, at 224 × 224, and refuses max_frames. A brief action in a long clip can fall between frames, so cut long videos into short clips around the moments you care about, and send one request per clip.

Long Answers

Text-only questions that ask for an open-ended analysis can run past the time limit. Moving an earthquake-monitoring demo, the question “Are any of these earthquakes near major population centers?” returned 504 every time with the Direct Query API’s settings (max_new_tokens: 3072), while the Direct Query API answered it in 8 to 50 seconds. Asking for answers under 300 words and lowering max_new_tokens to 1536 brought all 24 test questions in at 8 to 23 seconds. Listing numbers, Newton C 2.6 sometimes repeats itself (“M1.8, M1.9, M1.8, …”) until it runs out of tokens; on /inference/query, a repetition_penalty of 1.1 stops it.

Errors

Errors use the standard envelope; see the Inference API errors. The ones you are most likely to meet while migrating:

No Memory Between Queries

Each query stands alone, as before. To ask a follow-up question, send the image or clip again with the new question.