How Standard One makes decisions
What its two sizes read and return, how to call them, and how we measured them.
DDana Whitfield
I was charged twice for order #48213. Please refund the extra charge…
Receipt photo1 image attached
+ 3 questions
routechoicerefundnoulurgencyscore
One 3B
/v1/judgments
3 answers
routeBilling.88refundYes.94urgencyHigh.58
What Standard One is
Standard One is Standard Thinking's decision model, in two sizes: Standard One 3B and Standard One 8B. Give it a state — a short piece of text, an image, or both — and one or more questions, each with the options you define, and it answers every question with one of those options and a probability. No paragraph to parse, no retry loop for a reply that came back in the wrong shape.
Both sizes take the same request and return the same answer format. Use /v1/systemone for text decisions and /v1/judgments for images and additional options. One 3B is the faster of the two and One 8B the more accurate; both are open weights, and both are served through the API. Choose a size compares them.
It's built for the narrow, closed-ended decisions a product makes over and over: which team should own a ticket, whether a photo is safe to publish, whether a message is a buying signal. Where teams use it has more examples. The model IDs are standardthinking/standard-one-3b and standardthinking/standard-one-8b.
This page is the technical reference. To see the models in use first, watch three demos on the Standard One page.
Choose a size
The choice comes down to speed, accuracy, and price:
| Model | Accuracy | Median time | Input / 1M tokens | Model ID | Weights |
|---|---|---|---|---|---|
| One 3B | 88.2% | 22.6 ms | $0.018 text · $0.055 image | standardthinking/standard-one-3b | Hugging Face |
| One 8B | 91.5% | 25.8 ms | $0.035 text · $0.08 image | standardthinking/standard-one-8b | Hugging Face |
Both read text and images and return the same answer fields. Accuracy is on a set of 600 realistic decisions, measured on v2.2 weights, served endpoint, October 3, 2026 (One 3B) and October 1–3, 2026 (One 8B). Median time is the p50 latency on one NVIDIA H200, measured on v2 weights, September 24–26, 2026. Both come from the evaluation below. Output tokens aren't billed.
One 8B is ahead on realistic decisions, 91.5% against 88.2%, and further ahead on hard cases: 56.76% against 45.95% on the JevBench public hard tier, both measured on v2.2 weights. In the earlier ten-suite average (One 8B v2, One 3B v2.1, both released in September 2026) it was 76.6% against 69.9%; the suites and their values are on the model cards. Start with One 8B for the decisions where accuracy matters most, and measure it on a sample of your own cases. Paths that run at high volume or on a tight latency budget can move to One 3B wherever accuracy holds on that same sample. On either size, keep a threshold, so a case the model isn't sure about goes to a person — see Probabilities and thresholds.
To run a model yourself, download its weights from Hugging Face: StandardThinking/StandardOne-3B or StandardThinking/StandardOne-8B, both under the Apache 2.0 license. The StandardThinking organization page also carries FP8, GGUF, and LoRA variants of both sizes.
What you send
POST /v1/systemone accepts exactly three top-level fields: model, state, and questions. The state is a string, or a JSON object or array rendered as text. The request is the same on One 3B and One 8B.
For images, options, or caller metadata, use POST /v1/judgments. It accepts the same text request plus these extensions. Send PNG, JPEG, or WebP images as base64 sources in state blocks; HTTP(S) image URLs are not supported. See the image example below.
| Form | Example |
|---|---|
| Text | "state": "Do you support SSO on the Team plan?" |
| Structured | "state": { "plan": "Team", "request": "SSO" } |
| Text and image | Use /v1/judgments with text and base64 image blocks in state. |
Every request needs a state. For image decisions, the Judgments state array can include a short text block explaining the image. Image limits are in Limits and pricing.
questions is a map of the questions you want answered about that state, in one call. Each one names its type (choice, noul, or score — the next section covers all three) and asks the question itself in instructions. criteria describes the options: for choice, a map from each option's name to one line about it; for score, a list of levels in order, the first being level 0; for noul, optionally, one line each for "true" and "false".
Three kinds of questions
Every question you ask is one of three types. All three come back in the same call, however many you send.
| Type | Ask it when | Returns | Example |
|---|---|---|---|
choice |
You want the model to pick one option from a list you define | choice, the most likely option, with probabilities for every option and a confidence |
"Who should pick this up?" → billing, technical, shipping, sales |
noul |
You want a yes-or-no judgment | noul, the probability that the answer is yes |
"Is the customer asking for a refund?" |
score |
You want a rating on an ordered scale you define | score, the expected level counting the first as 0, with probabilities for every level, a legend and a confidence |
"How urgent is it?" → low, medium, high |
We call a yes-or-no question noul in the API. It works like the other types with a fixed pair of outcomes instead of a list you supply: it takes instructions, can describe "true" and "false" in criteria, and returns the probability of yes as noul.
What comes back
One worked example, used the same way through the rest of this page: a support message about a duplicate charge, with three questions attached to it.
{
"model": "standardthinking/standard-one-3b",
"state": "I was charged twice for order #48213. Please refund the extra charge today.",
"questions": {
"route": {
"type": "choice",
"instructions": "Who should pick this up?",
"criteria": {
"billing": "Payments, charges, and refunds.",
"technical": "A bug or a broken feature.",
"shipping": "A delivery or fulfillment problem.",
"sales": "A new purchase or an upgrade."
}
},
"refund": {
"type": "noul",
"instructions": "Is the customer asking for a refund?"
},
"urgency": {
"type": "score",
"instructions": "How urgent is it?",
"criteria": [
"Low: can wait a few days.",
"Medium: should be handled today.",
"High: needs attention right now."
]
}
}
}
One 3B answers all three questions in one response. The example below illustrates the response shape; probabilities and usage vary with the input and serving model. Every answer carries its type back with its probabilities:
{
"model": "standardthinking/standard-one-3b",
"answers": {
"route": {
"type": "choice",
"probabilities": {
"billing": 0.88,
"technical": 0.07,
"shipping": 0.03,
"sales": 0.02
},
"confidence": 0.65,
"choice": "billing"
},
"refund": {
"type": "noul",
"noul": 0.94
},
"urgency": {
"type": "score",
"probabilities": {
"0": 0.03,
"1": 0.39,
"2": 0.58
},
"confidence": 0.28,
"score": 1.55,
"legend": {
"0": "Low: can wait a few days.",
"1": "Medium: should be handled today.",
"2": "High: needs attention right now."
}
}
},
"usage": {
"input_tokens": 214,
"output_tokens": 0
}
}
| Type | Answer field | Probability field |
|---|---|---|
choice | choice — the most likely option | probabilities — one number per option |
noul | — | noul — the probability of yes |
score | score — the expected level, counting the first as 0; legend maps each level back to your wording | probabilities — one number per level, keyed "0", "1", … |
confidence is one minus the normalized entropy of the probabilities: 1 when all the weight sits on one option, 0 when it is spread evenly. It describes spread, not correctness, so set your threshold on the probabilities. The /v1/systemone response contains only model, answers, and usage. The Judgments endpoint adds engine metadata and accepts options.temperature to override the default.
usage.input_tokens is the total across all evaluations: each question evaluates the shared state and its own instructions and criteria. On /v1/judgments, permutations multiplies the evaluations, and image tokens are included in that total. Its usage.input_tokens_details separates text and image tokens. Both endpoints return output_tokens: 0.
Several questions in one call
questions is a map: you choose the keys — route, refund, urgency, or anything else that reads well in your own code — and describe one question under each. The example above asks three questions about the same state and gets all three answers back together in one response, each under the same key it was asked with.
A call evaluates every question against the shared state, and input usage sums those evaluations. A single request does not mean the state is billed only once. Exactly how latency scales with each extra question is still being measured — see Limits and pricing.
Probabilities and thresholds
Every answer carries a probability: the model's estimate, given what's in state, that this option is the right one — not a measure of how clearly the question was asked, and not a guess dressed up as a number.
A calibrated model's probabilities mean what they say. Pull out every answer where it said "90% confident" — a well-calibrated model is right in about 90 of every 100 of them. A model that runs overconfident is right less often than its own numbers claim; one that runs underconfident is right more often than it admits.
Your code sets the threshold, not the model. Set the bar higher for decisions that are expensive to get wrong, and lower where a wrong guess costs little; anything below it is a signal to route the case to a person instead of forcing a choice. In the example above, a 60% bar lets your code act on route (88%) and refund (94%) directly, and sends urgency, which came back high at only 58%, to a person.
We report calibration two ways. ECE, expected calibration error: group every answer by the probability the model gave it, in ten bands (a 0.9–1.0 band, a 0.8–0.9 band, and so on); in each band, compare the model's average stated probability to how often it was actually right; ECE is the size of that gap, averaged across bands and weighted by how many answers fall in each one. Distance from the stated odds: on questions that state the true odds, the total-variation distance between the probabilities the model returns and those odds. Zero is perfect for both; lower is better — see them measured.
How it compares to a general-purpose model
A general-purpose model can do almost anything with language. Standard One does one thing: given a state and a small set of options, it picks. That trade shows up in four places.
| A general-purpose model | Standard One | |
|---|---|---|
| What comes back | A paragraph you still have to read or parse | One of the options you gave it |
| How sure it is | Usually described in words, if at all | A probability for every option |
| Format | You parse the reply and retry when it breaks | Always the shape you asked for |
| Speed and cost | Grows with how much it writes | A short answer for each question you ask |
A typed answer can't come back malformed — that's a guarantee about shape, not about truth. A miscalibrated or simply wrong answer can still arrive with a confident-looking probability attached. Treat the number as a calibrated estimate worth weighing against a threshold, not a promise that it's correct — see Probabilities and thresholds.
Where teams use it
Either size, with the questions you write. A few common shapes:
| Workflow | What it decides | Sample answer |
|---|---|---|
| Support triage | Which team should take this ticket | technical · 0.95 |
| Content moderation | Whether a photo can be published | publish · 0.98 |
| Lead scoring | How warm an inbound request is | hot · 0.63 |
| Expense approvals | Approve, reject, or ask for details | ask for details · 0.86 |
| Search relevance | Whether a passage answers the question | no · 0.88 |
| Agent routing | Which tool an agent should call next | check_calendar · 0.86 |
The sample answers show the shape of a reply; they aren't measured results. Two of these shapes are weak without fine-tuning: ten-way support triage and passage relevance for retrieval score 36% and 59% on One 8B (an earlier version of the weights; the model card gives no version or date). The support triage example on the Standard One page uses four options. For ten-way triage or retrieval relevance, fine-tune the open weights on your own labelled cases.
Call the API
The text examples below send model, state, and questions to POST /v1/systemone. The response carries one answer per question. You'll need a Standard Thinking API key — see Create an API key if you don't have one yet.
Set the STANDARD_API_KEY environment variable before running an example. Run JavaScript on Node.js 18 or newer from an .mjs file. For Python, install requests with python3 -m pip install requests. Keep the key in server-side code.
curl --fail-with-body --silent --show-error https://api.standardthinking.ai/v1/systemone \
-H "Authorization: Bearer $STANDARD_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "standardthinking/standard-one-3b",
"state": "I was charged twice for order #48213. Please refund the extra charge today.",
"questions": {
"route": {
"type": "choice",
"instructions": "Who should pick this up?",
"criteria": {
"billing": "Payments, charges, and refunds.",
"technical": "A bug or a broken feature.",
"shipping": "A delivery or fulfillment problem.",
"sales": "A new purchase or an upgrade."
}
},
"refund": {
"type": "noul",
"instructions": "Is the customer asking for a refund?"
},
"urgency": {
"type": "score",
"instructions": "How urgent is it?",
"criteria": [
"Low: can wait a few days.",
"Medium: should be handled today.",
"High: needs attention right now."
]
}
}
}'
import os
import requests
STANDARD_API_KEY = os.environ["STANDARD_API_KEY"]
response = requests.post(
"https://api.standardthinking.ai/v1/systemone",
headers={"Authorization": f"Bearer {STANDARD_API_KEY}"},
json={
"model": "standardthinking/standard-one-3b",
"state": (
"I was charged twice for order #48213. "
"Please refund the extra charge today."
),
"questions": {
"route": {
"type": "choice",
"instructions": "Who should pick this up?",
"criteria": {
"billing": "Payments, charges, and refunds.",
"technical": "A bug or a broken feature.",
"shipping": "A delivery or fulfillment problem.",
"sales": "A new purchase or an upgrade.",
},
},
"refund": {
"type": "noul",
"instructions": "Is the customer asking for a refund?",
},
"urgency": {
"type": "score",
"instructions": "How urgent is it?",
"criteria": [
"Low: can wait a few days.",
"Medium: should be handled today.",
"High: needs attention right now.",
],
},
},
},
timeout=130,
)
response.raise_for_status()
answers = response.json()["answers"]
print(answers)
const STANDARD_API_KEY = process.env.STANDARD_API_KEY;
if (!STANDARD_API_KEY) throw new Error("Set STANDARD_API_KEY first.");
const response = await fetch(
"https://api.standardthinking.ai/v1/systemone",
{
method: "POST",
signal: AbortSignal.timeout(130_000),
headers: {
"Authorization": `Bearer ${STANDARD_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "standardthinking/standard-one-3b",
state:
"I was charged twice for order #48213. " +
"Please refund the extra charge today.",
questions: {
route: {
type: "choice",
instructions: "Who should pick this up?",
criteria: {
billing: "Payments, charges, and refunds.",
technical: "A bug or a broken feature.",
shipping: "A delivery or fulfillment problem.",
sales: "A new purchase or an upgrade.",
},
},
refund: {
type: "noul",
instructions: "Is the customer asking for a refund?",
},
urgency: {
type: "score",
instructions: "How urgent is it?",
criteria: [
"Low: can wait a few days.",
"Medium: should be handled today.",
"High: needs attention right now.",
],
},
},
}),
},
);
if (!response.ok) {
throw new Error(`HTTP ${response.status}: ${await response.text()}`);
}
const { answers } = await response.json();
console.log(answers);
Set model to standardthinking/standard-one-3b or standardthinking/standard-one-8b; nothing else in the request changes.
Python and JavaScript SDKs, CSV batch processing, and a LangChain integration are planned.
Images and options with Judgments
Use POST /v1/judgments when a decision needs images or options. The example embeds a complete 32 × 32 red PNG, so it can run as written with your API key. Replace source.data with the base64-encoded bytes of your own PNG, JPEG, or WebP image. Supply only the base64 string in that field, without a data URL prefix.
{
"model": "standardthinking/standard-one-3b",
"state": [
{
"type": "text",
"text": "Inspect this sample image."
},
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAKElEQVR4nO3NsQ0AAAzCMP5/un0CNkuZ41wybXsHAAAAAAAAAAAAxR4yw/wuPL6QkAAAAABJRU5ErkJggg=="
}
}
],
"questions": {
"red": {
"type": "noul",
"instructions": "Is the image predominantly red?"
}
},
"options": {
"temperature": 1.65,
"permutations": 1
},
"metadata": {
"example": "red-image"
}
}
This Python example uses the same STANDARD_API_KEY environment variable and requests dependency as the text example:
import os
import requests
payload = {
"model": "standardthinking/standard-one-3b",
"state": [
{
"type": "text",
"text": "Inspect this sample image."
},
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAKElEQVR4nO3NsQ0AAAzCMP5/un0CNkuZ41wybXsHAAAAAAAAAAAAxR4yw/wuPL6QkAAAAABJRU5ErkJggg=="
}
}
],
"questions": {
"red": {
"type": "noul",
"instructions": "Is the image predominantly red?"
}
},
"options": {
"temperature": 1.65,
"permutations": 1
},
"metadata": {
"example": "red-image"
}
}
response = requests.post(
"https://api.standardthinking.ai/v1/judgments",
headers={
"Authorization": f"Bearer {os.environ['STANDARD_API_KEY']}",
"Judgments-Version": "2026-10-01",
},
json=payload,
timeout=130,
)
response.raise_for_status()
result = response.json()
print(result["answers"])
print(result["usage"]["input_tokens_details"])
print(result["request_metadata"])
The answers use the same choice, noul, and score shapes as /v1/systemone. Judgments adds id, object: "judgment", engine metadata, and usage.evaluations. Its usage.input_tokens_details contains text, image, audio, video, and cached; audio and video are currently zero. Caller metadata, when supplied, is echoed as request_metadata. The response does not include a monetary cost.
options.temperature must be greater than zero. options.permutations accepts 1–16; the default is 1. Other optional fields are temperature_scaling and return_logprobs (booleans), plus assistant_prefix (string or null). The number of questions multiplied by permutations must stay within the model's max_evaluations. Caller metadata accepts up to 16 string values, with keys of 1–64 UTF-8 bytes and values up to 512 UTF-8 bytes.
The optional Judgments-Version: 2026-10-01 header pins the current API version; the response includes the version used. Unknown versions return 400 unsupported_version. Images, options, and metadata sent to /v1/systemone return 422 invalid_request. See Errors for authentication, credit, and rate-limit failures.
Deployment and data
Both sizes are called the same way as any other Standard Thinking model, over HTTPS. Standard One inference through the API is Zero Data Retention (ZDR): Inputs and Outputs are not kept as content logs, histories, or backups, and temporary processing follows the Terms, §5. Where requests are processed is described in the Terms, §5.5. Both can also be run from their open weights, linked in Choose a size. A dedicated deployment — capacity reserved for one team rather than shared — is planned for teams that need one.
"Dedicated" can mean several different things — separate capacity, a private network path, or data that never leaves a chosen region. We'll say exactly which of these a dedicated deployment provides once it's confirmed, rather than imply all of them.
Evaluation
Results below are measured on v2.2 weights through the served endpoint. One 3B was measured on October 3, 2026 and One 8B from October 1 to 3, 2026. The endpoint is the merged BF16 weights behind SGLang 0.5.20 and jev-adapter, with the adapter's default prompt wording, no system prompt, one option order and a temperature of 1.65 for every answer type; the temperature was not refit for v2.2. These are our measurements, not official sealed-set JevBench scores. The API now serves Standard One SH; the figures below are this earlier v2.2 measurement, and they stay until the evaluation is re-run on SH.
These results compare models on one narrow kind of task — picking from a short list of options, under a strict response format — not on writing or conversation generally. A general-purpose model given room to answer in its own words, or wired up with its own constrained decoding, can close some of this gap on an equivalent narrow task. Read the comparison on that basis, not as a general capability ranking.
Accuracy on the served endpoint, v2.2 (higher is better)
| Suite (questions) | One 3B | One 8B |
|---|---|---|
| JevBench public, easy (48) | 100.00% | 100.00% |
| JevBench public, standard (72) | 93.06% | 98.61% |
| JevBench public, hard (111) | 45.95% | 56.76% |
| Realistic transfer set (600) | 88.17% | 91.50% |
| Hard proxy (600) | 44.67% | 53.50% |
| Held-out decision set (600) | 82.00% | 82.50% |
| Many-option questions, 53–151 options (18,000) | 79.97% | 82.67% |
| The same questions, at most 26 options (750) | 85.47% | 88.13% |
| Long-document questions (150) | 38.00% | 40.00% |
Previous measurement: v2.1 and v2, September 2026
Measured on the v2.1 and v2 weights in the release configuration of the time: merged BF16 weights behind SGLang 0.5.20 and jev-adapter, native prompt wording, no system prompt, one option order, and the temperature fitted for each answer type. The wording and the temperatures were chosen on data outside JevBench. Jev 1.13 was measured on the same questions through its hosted endpoint, with its raw probabilities. One 3B is version 2.1, released September 27, 2026; One 8B is version 2, released September 26, 2026 and measured from September 24 to 26, 2026.
Accuracy on the served endpoint, v2.1 and v2 (higher is better)
| Suite (questions) | One 3B | One 8B | Jev 1.13 |
|---|---|---|---|
| JevBench public, easy (48) | 100.00% | 100.00% | 100.00% |
| JevBench public, standard (72) | 86.11% | 93.06% | 98.61% |
| JevBench public, hard (111) | 47.75% | 54.95% | 72.07% |
| Judge proxy: routing and answer adequacy (600) | 87.50% | 89.33% | 90.50% |
| Realistic transfer set (600) | 90.17% | 90.83% | 86.67% |
| Stated-distribution probability (1,036) | 78.38% | 81.18% | 72.97% |
| Hard proxy (600) | 44.17% | 53.00% | 54.83% |
Latency, p50 (ms, lower is better)
One 3B
22.6 ms
One 8B
25.8 ms
Probability quality (lower is better)
| Measure | One 3B | One 8B | Jev 1.13 |
|---|---|---|---|
| Distance from the stated odds (total variation) | 0.124 | 0.108 | 0.192 |
| ECE on JevBench public, hard (111) | 0.212 | 0.184 | 0.099 |
Public classification suites (400 cases each, whole percentages, higher is better)
| Suite | One 3B | One 8B |
|---|---|---|
| Topics, AG News | 85% | 84% |
| Typed decisions | 67% | 71% |
| Intent, MASSIVE, mean of nine languages | 83% | 86% |
| Email spam | 92% | 92% |
| Phishing | 89% | 85% |
- Versions: the results above are for v2.2, updated October 4, 2026 on both model cards, which keep earlier versions under their own tags. “Served endpoint” means the reference server on the cards, SGLang 0.5.20 with
jev-adapter. Pin the version you evaluated when you run the weights yourself. The previous measurement covers One 3B v2.1, released September 27, 2026, and One 8B v2, released September 26, 2026; One 8B was measured from September 24 to 26, 2026. - Every accuracy figure is for text decisions. Accuracy on image inputs hasn't been benchmarked yet.
- A sealed-set JevBench v1.4.1 run has been requested; its result isn't available yet.
- Ten-way support triage (36%) and passage relevance for retrieval (59%) were weak without fine-tuning on One 8B. The model card reports them for an earlier version and gives no version or date; fine-tune for those shapes.
- Full tables, per-language results, offline runs and the server code are on the model cards: StandardOne-3B and StandardOne-8B.
Limits and pricing
| Limit | Value |
|---|---|
| Questions per call | Up to 64 on the current hosted models with one permutation. The request schema allows 1–256, but the model's max_evaluations also applies |
Options per choice | 2 to 255 |
Levels per score | 2 to 10 |
| Context per evaluation | 32,768 tokens on both hosted models; the shared state, question, and any image tokens must fit together |
| Image format | /v1/judgments only: base64 PNG, JPEG, or WebP in image blocks; detail may be omitted or set to auto |
| Image limits | Image count and decoded byte limits depend on the model release. Requests over these limits return 422 media_limit_exceeded |
| Evaluations | Questions × permutations must be at most 64 on the current hosted models. Read max_evaluations in GET /v1/models for the current value; /v1/systemone uses one permutation |
| Languages | English, Japanese, Chinese, Spanish, French, German, Portuguese and Russian, with a smaller share of Korean; accuracy varies by language |
| Request rate | See general rate limits |
| Price, One 3B | $0.018 per 1M text input tokens, $0.055 per 1M image input tokens |
| Price, One 8B | $0.035 per 1M text input tokens, $0.08 per 1M image input tokens |
| Output tokens | Not billed on either size |
Frequently asked questions
Does Standard One read images?
Yes, both sizes do through /v1/judgments. Send base64 PNG, JPEG, or WebP image blocks in state — see What you send. The published accuracy figures are for text; accuracy on images hasn't been benchmarked yet.
Can I run Standard One myself?
Yes. Both sizes are open weights, published on Hugging Face as StandardThinking/StandardOne-3B and StandardThinking/StandardOne-8B, and both are also available through the API — see Choose a size. The hosted API contract on this page applies to Standard Thinking's gateway. When running the weights yourself, follow the server version's own endpoint and configuration instructions.
What does noul mean?
It's our API's name for a yes-or-no question. It returns noul, the probability that the answer is yes. If the question needs it, say what yes and no mean in criteria under "true" and "false".
Can Standard One write free text?
No. Every answer is one of the types you asked for — a choice, a yes-or-no, or a score — never a paragraph. For open-ended writing or conversation, use a general-purpose model instead.
What happens when it isn't sure?
Your own code decides. Choose the probability above which it acts on its own; below that, route the case to a person instead of forcing a choice — see Probabilities and thresholds.
Is there a live demo?
Yes. The API is live: sign in and send it a request — see Call the API. To see it in use first, watch three demos on the Standard One page. The demos replay recorded model outputs; measured results are in Evaluation.
Are there SDKs?
Python and JavaScript SDKs, CSV batch processing, and a LangChain integration are planned; package names and availability are being confirmed.