Ostra Pro
TestRelic's testing model for writing and fixing tests, analysing failures and logs, reading screenshots and video, and planning coverage — limits, thinking, tools, images and video, streaming, sessions, cold starts, compatibility and pricing.
Ostra Pro (API id ostra-pro, version 1.0) is a testing model your team can use in place of a general-purpose assistant for test work. It reasons before it answers, calls tools, reads images and video, and speaks both the OpenAI and the Anthropic API formats, so the SDKs and tools you already use work by changing a base URL.
What it's good at
| Job | Example ask |
|---|---|
| Write tests | "Write a Playwright test for the password-reset flow, using role locators." |
| Fix tests | "This test times out on CI but passes locally. Here's the test and the trace. Why, and what's the fix?" |
| Analyse failures and logs | "Find the first real failure in this 2,000-line CI log and explain it." |
| Read screenshots and video | "Compare this checkout screenshot with the design and list visual regressions." |
| Review test changes | "Review this test diff for flakiness risks and missing assertions." |
| Plan coverage | "Turn this bug report into test cases", "Plan the tests for a coupon feature." |
Limits
| Limit | |
|---|---|
| Context window | 262,144 tokens |
Output per request (max_tokens) | Default 8,192; maximum 32,768 (higher values are lowered to 32,768). Reasoning counts toward it. |
| Images | 8 per request (https or data: URLs) |
| Video | 1 per request |
| Request body | 5.5 MB (images and video included) |
| Messages | 4,000 per request |
| Tools | 128 per request |
Choices (n) | 1 |
Ostra Pro shares your workspace's requests-per-minute limit with Ostra Decision.
Thinking and reasoning effort
Thinking is on by default: the model reasons first, then answers. Its reasoning comes back separately (reasoning_content in OpenAI format, a thinking block in Anthropic format) and bills as output tokens.
reasoning_effort | Use for |
|---|---|
low | Quick edits, short answers, simple questions. Fastest and cheapest. |
medium | Most debugging and test writing. |
xhigh (default) | Hard failures, subtle flakiness, planning. Slowest; most thorough. |
To answer directly with no reasoning at all, send "chat_template_kwargs": {"enable_thinking": false} (OpenAI format). Over MCP, use reasoning_effort: "none". In the Anthropic format, output_config.effort accepts low and medium (higher values run as medium).
If an answer comes back empty with finish_reason: "length", the reasoning used up max_tokens: raise max_tokens or lower reasoning_effort.
Tools
Pass functions in tools (OpenAI or Anthropic format). When the model wants one, it answers with tool_calls (finish_reason: "tool_calls"); run the tool yourself and send the result back as a tool message (OpenAI) or a tool_result block (Anthropic), then call again. Ostra Pro never runs your tools itself.
import json
import os
from openai import OpenAI
client = OpenAI(base_url="https://ostra.testrelic.ai/api/v1", api_key=os.environ["OSTRA_API_KEY"])
tools = [{
"type": "function",
"function": {
"name": "run_tests",
"description": "Run part of the test suite and return its output.",
"parameters": {
"type": "object",
"properties": {"path": {"type": "string", "description": "Test file or directory"}},
"required": ["path"],
},
},
}]
completion = client.chat.completions.create(
model="ostra-pro",
messages=[{"role": "user", "content": "Run tests/checkout.spec.ts and tell me what failed."}],
tools=tools,
reasoning_effort="low",
)
for call in completion.choices[0].message.tool_calls or []:
print(call.function.name, json.loads(call.function.arguments))Images and video
Send screenshots as image_url parts and a recording as a video_url part, with an https:// URL the model can fetch or a data: URL:
{
"model": "ostra-pro",
"messages": [
{
"role": "user",
"content": [
{ "type": "text", "text": "List the visual bugs on this checkout page." },
{ "type": "image_url", "image_url": { "url": "https://docs.testrelic.ai/img/samples/checkout.png" } }
]
}
]
}In the Anthropic format use image blocks. Large media count toward the 5.5 MB body limit when sent inline as data: URLs; prefer links for big files.
Streaming
Set "stream": true to receive the answer as it's written (server-sent events, OpenAI or Anthropic format). Streaming is also the easiest way to ride out a cold start: the request waits for the model instead of failing. See Streaming.
Sessions and prompt caching
Repeated prompt prefixes (system prompt, tools, earlier turns) are served from a prompt cache and billed as cached input at $0.06 per 1M tokens instead of $0.64. Send x-ostra-session with one stable value per conversation so follow-up turns go to the replica that holds the cache when possible:
-H "x-ostra-session: checkout-suite-run-42"It's best effort and scoped to your workspace. See Sessions and caching.
Cold starts and warm-up
Ostra Pro scales to zero after 5 quiet minutes. The next request starts it: usually under a minute, up to about 5 minutes the first time after a model update. Streaming requests wait; non-streaming ones may get 503 with state: "starting" and Retry-After: 60, at no charge.
To avoid the wait, call POST /api/v1/warm before a burst of work (it's free), or press Warm up now in the Playground. See Cold starts.
OpenAI and Anthropic compatibility
| Format | Endpoint | SDK base URL | Auth |
|---|---|---|---|
| OpenAI Chat Completions | POST /api/v1/chat/completions | https://ostra.testrelic.ai/api/v1 | Authorization: Bearer or x-api-key |
| Anthropic Messages | POST /api/v1/messages | https://ostra.testrelic.ai/api | x-api-key or Authorization: Bearer |
OpenAI fields Ostra doesn't validate (for example top_p, stop, seed, response_format, tool_choice) are passed to the model as-is.
In the Anthropic format, a few options are adapted:
modelis required by the SDKs but ignored: Ostra Pro always answers, and responses sayostra-pro.output_config.effortabovemediumruns asmedium.tool_choiceanyortoolruns asauto;noneremoves the tools.systemmessages in the middle of a conversation are folded into the next user turn.count_tokensisn't supported.- Errors use Anthropic's error shape, with the Ostra error type in
ostra_type.
See OpenAI and Anthropic clients for SDK, LangChain and Vercel AI SDK setups.
Pricing
| Per 1M tokens | |
|---|---|
| Input | $0.64 |
| Cached input | $0.06 |
| Output, reasoning included | $4.47 |
Before a request runs, the most it could cost is held from your balance, and the unused part is released when it ends. With the default max_tokens, a text request holds at most about $0.20; the largest possible hold is about $0.31. If the balance can't cover the hold you get 402 insufficient_balance; lowering max_tokens lowers the hold. Requests that fail, and requests that time out while the model starts, cost nothing. A stream that breaks partway is charged only for what it produced. See Billing and usage.
In the Console
The Playground opens on Ostra Pro. It has:
- Presets for the system prompt: Failure analyst (default), Test writer, Code reviewer and Custom.
- Thinking on or off, with Reasoning effort Low, Medium or Max (
xhigh). - Max output tokens, temperature, top-p, and your own Tools.
- Attachments (images and one video), Insert a failed run to pull in an Ostra Decision triage, Compare to send one prompt with two settings, and a Code tab that shows the request as cURL, Python or TypeScript.
See Playground.
Reference
Selector survival
Predict which UI locators will break in the next release before they break your tests — what to send, what the answers mean, and how to act on them.
CI triage
After every Playwright run in GitHub Actions, send the failures to Ostra Decision in one batch, write a triage table to the job summary, and fail the build only on product bugs.