Applies to version 2.0.1 or later of the Archetype platform.
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 asNewton::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
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 asbase64: followed by the file’s base64 data, in file_ids. The model
reads 16 evenly spaced frames from it.
analyze_video.py
newton-c-2.6 answered:
413. Because the model only sees 16 frames at 224 × 224, you lose nothing by shrinking the
clip first:
/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: animage_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
/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.- 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.
- 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.
- Turn on Fusion’s reasoning when accuracy matters more than speed. Reasoning takes longer and needs a larger token budget; see Reasoning.
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.
/thinkdoesn’t force reasoning; the model decides. Setmax_new_tokensto at least2048for images and video and4096for text, andrepetition_penaltyto1.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.
<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 refusesmax_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?” returned504 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.