41% fewer made‑up answers than GPT-⁠6.1 Sol, for 91% less

Send an image with a question, from a product label to a screenshot, and get a short answer back. SIE runs open vision models for you behind one API.

Get started Run in your cloud

SIE Qwen3.8 27B

9 of 10 people agree

Question from a blind userWhat kind of coffee is this?

AnswerFolgers

VizWiz · CC BY 4.0

GPT-⁠6.1 Sol and Claude Sonnet 5.5 answer what the photo doesn’t show

The blue lid of a yogurt tub on a floor next to a pair of jeans; no date is printed on the visible part — VizWiz · CC BY 4.0

Question from a blind userWhat is the expire date on this yogurt?

10 of 10 people said the photo doesn’t show it

GPT-6.1 Sol, default reasoning

Gave a date that isn’t there

17/03

GPT-6 Luna, high reasoning

Gave a date that isn’t there

12/14

SIE Qwen3.8 27B

Said it can’t tell

unanswerable

A completely blurred close-up of a bottle label with a few dark stripes of unreadable text and an orange edge — VizWiz · CC BY 4.0

Question from a blind userWhat is in this bottle?

9 of 10 people said the photo doesn’t show it

Claude Sonnet 5.5, default thinking

Guessed what’s inside

Prescription medication (pills).

GPT-6.1 Sol, default reasoning

Guessed what’s inside

Orange juice

SIE Qwen3.8 27B

Said it can’t tell

Unanswerable

arXiv:2602.13469 CHI 2026 A GPT-4o vision app gave blind users false information in 1 of 5 follow-up answers
How Multimodal Large Language Models Support Access to Visual Information: A Diary Study With Blind and Low Vision People

Gonzalez Penuela, Jung, Lin, Hu and Azenkot

“the AI did not abstain when the text was unreadable but still attempted to provide confident-sounding answers.”
13 February 2026
arXiv:2604.14799 ServiceNow Research GPT-5 and Claude Sonnet 4.5 answered over 80% of unanswerable image and document questions
Knowing When Not to Answer: Evaluating Abstention in Multimodal Reasoning Systems

Madhusudhan, Yadav and Lacoste

“all three models still answer incorrectly on more than 80% of unanswerable instances”
16 April 2026

Fewer made‑up answers than GPT and Claude, for 91% less than GPT-⁠6.1 Sol

Run this eval

Made-up answers against cost

299 photos

Answered anyway ↓ Cost per 1,000 questions →

Share of 299 photos that don't show the answer where each model answered anyway, against list-price cost per 1,000 questions
Model	Answered anyway	Cost per 1,000 questions
SIE Qwen3.8 27B	47.5%	$0.42
GPT-6 Luna, high reasoning	72.6%	$0.32
Claude Haiku 5.5	79.3%	$0.31
GPT-6.1 Sol	80.6%	$4.75
Claude Sonnet 5.5	84.6%	$5.19

Photo-question evaluation

600 new questions blind people asked about their own photos (VizWiz), with the same prompt for every model.

Counted: Any reply other than “unanswerable” on the 299 photos most of ten people said don’t show the answer. Claude often declines in a full sentence, which counts as a guess here; read leniently, Claude Sonnet 5.5 still guesses 62%
Like people: On 300 photos people could answer, SIE gave one of their answers 75% of the time; a person agrees with the others 78% of the time
Run: SIE on 2026-10-08; rivals on 2026-10-11 through their APIs: GPT-6.1 Sol at its default reasoning, GPT-6 Luna at high, the Claude models at their defaults
Cost: List price on each rival’s recorded usage, 2026-10-11; SIE at its published Serverless rate

Send an image and a question, get the answer

from pathlib import Path
from sie_sdk import SIEClient
client = SIEClient(api_key="API keysk-sie-…")
image = {"data": Path(imageVizWiz_test_00000984.jpgbrowse).read_bytes(), "format": "jpeg"}
result = client.generate(
    "modelQwen/Qwen3.8-27B-FP8",
    "queryWhat kind of coffee is this?
Answer the question using a single word or phrase. Give your best answer from what is visible, even if the photo is blurry or shows only part of it.
Reply 'Unanswerable' only if the answer cannot be seen in the photo at all.",
    max_new_tokens=128,
    images=[image],
    temperature=0,
    presence_penalty=0,
)
print(result["text"])

import { readFile } from 'node:fs/promises';
import { SIEClient } from '@superlinked/sie-sdk';

const client = new SIEClient(undefined, { apiKey: 'sk-sie-…' });

const image = await readFile("VizWiz_test_00000984.jpg");
const result = await client.generate(
  'Qwen/Qwen3.8-27B-FP8',
  "What kind of coffee is this?\nAnswer the question using a single word or phrase. Give your best answer from what is visible, even if the photo is blurry or shows only part of it.\nReply 'Unanswerable' only if the answer cannot be seen in the photo at all.",
  { maxNewTokens: 128, images: [image], temperature: 0, presencePenalty: 0 },
);
console.log(result.text);

image_bytes=$(base64 < 'VizWiz_test_00000984.jpg' | tr -d '\n')
curl https://api.superlinked.com/v1/generate/Qwen__Qwen3.8-27B-FP8 \
  -H "Authorization: Bearer sk-sie-…" \
  -H "Content-Type: application/json" \
  -d "{\"prompt\":\"What kind of coffee is this?\\nAnswer the question using a single word or phrase. Give your best answer from what is visible, even if the photo is blurry or shows only part of it.\\nReply 'Unanswerable' only if the answer cannot be seen in the photo at all.\",\"max_new_tokens\":128,\"images\":[{\"data\":\"$image_bytes\",\"format\":\"jpeg\"}],\"temperature\":0,\"presence_penalty\":0}"

Build the "Image questions" capability into my app using the Superlinked Inference Engine (SIE).

Context
- SIE is an OpenAI-style inference API. Python SDK: `from sie_sdk import SIEClient`; TypeScript: `@superlinked/sie-sdk`.
- Base URL: https://api.superlinked.com (or my regional endpoint). Auth: Bearer key from env `SIE_API_KEY` (never hard-code it).
- Model: Qwen/Qwen3.8-27B-FP8 (SIE primitive: /generate). Keep the model id configurable.

Task
- Input: an uploaded image plus a question or caption instruction.
- Behaviour: return a detailed caption or answer the question about the image
- Send one POST https://api.superlinked.com/v1/generate/Qwen__Qwen3.8-27B-FP8 request (SDK: generate) with the question as prompt, the image in images, max_new_tokens 128, temperature 0 and presence_penalty 0, so answers are greedy and repeatable. Read the answer from text.

Deliverables
- A typed client wrapper, an application-level function for this task, error handling for timeouts/empty input, and unit tests with a stubbed client.
- Wire it into my existing stack (ask me which framework if unclear) and add a short usage example.

Run

Output

A hand holding a red Folgers Gourmet Supreme coffee can — VizWiz_test_00000984.jpg

text Folgers

Answer image questions with SIE

Serverless API

We host the models; you call one API.

No idle GPUs, pay for what you use
SOC 2 Type 2, US or EU data residency
$50 of credit to start, no card required

Get started

Self-hosted (Kubernetes)

SIE in your clusters, backed by our engineers.

Data stays in your own cloud account
Same models and API as Serverless
Terraform to your cloud in minutes

Talk to us Deploy guide

Run locally

The open-source server on your own machine.

docker run --gpus all -p 8080:8080 ghcr.io/superlinked/sie-server:latest-cuda12-sglang

Quickstart

Switch to SIE in 5 minutes

from openai import OpenAI

client = OpenAI(api_key="sk-…")
reply = client.responses.create(
    model="gpt-6-luna",
    input=[{"role": "user", "content": [
        {"type": "input_image", "image_url": image_data_url},
        {"type": "input_text", "text": prompt},
    ]}],
)
answer = reply.output_text

import anthropic

client = anthropic.Anthropic(api_key="sk-ant-…")
reply = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": [
        {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": image_b64}},
        {"type": "text", "text": prompt},
    ]}],
)
answer = next(block.text for block in reply.content if block.type == "text")

SIE

from sie_sdk import SIEClient

client = SIEClient(api_key="sk-sie-…")
reply = client.generate("Qwen/Qwen3.8-27B-FP8", prompt, images=[image])
answer = reply["text"]

from sie_sdk import SIEClient

client = SIEClient(api_key="sk-sie-…")
reply = client.generate("Qwen/Qwen3.8-27B-FP8", prompt, images=[image])
answer = reply["text"]