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

JobExample 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 window262,144 tokens
Output per request (max_tokens)Default 8,192; maximum 32,768 (higher values are lowered to 32,768). Reasoning counts toward it.
Images8 per request (https or data: URLs)
Video1 per request
Request body5.5 MB (images and video included)
Messages4,000 per request
Tools128 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_effortUse for
lowQuick edits, short answers, simple questions. Fastest and cheapest.
mediumMost 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

FormatEndpointSDK base URLAuth
OpenAI Chat CompletionsPOST /api/v1/chat/completionshttps://ostra.testrelic.ai/api/v1Authorization: Bearer or x-api-key
Anthropic MessagesPOST /api/v1/messageshttps://ostra.testrelic.ai/apix-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:

  • model is required by the SDKs but ignored: Ostra Pro always answers, and responses say ostra-pro.
  • output_config.effort above medium runs as medium.
  • tool_choice any or tool runs as auto; none removes the tools.
  • system messages in the middle of a conversation are folded into the next user turn.
  • count_tokens isn'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

Was this page helpful?

On this page