Chat Playground (OAI)

Connection

OpenAI: https://api.openai.com/v1 (Responses API: https://api.openai.com/v1/responses) or Foundry base endpoint: https://resource.services.ai.azure.com or https://resource.openai.azure.com

Endpoint

API

Model Name

Deployment Name

Authentication Mode

API Key

Astra documents low through maximum reasoning and up to 128,000 output tokens. Ultra is an experimental option; use it only with an endpoint that supports it. Sampling controls are not supported; tool calling requires Responses. OpenAI model guide

Stream

Advanced

Model controls

Quick setup: Changes reasoning and verbosity only.

For stateless or Zero Data Retention conversations, disable response storage and include encrypted reasoning content. The returned opaque reasoning items are captured and replayed without exposing the model's private reasoning.

Max Output Token Count

Reasoning Level

Output Verbosity

Reasoning Summary Verbosity

Image Detail Level

File Detail Level

Include encrypted reasoning content

Adds reasoning.encrypted_content to include and captures the returned reasoning output item for stateless continuation.

Store response for conversation continuity

Sends the Responses API store setting. Disable it for stateless or Zero Data Retention workflows; changing an existing stored chat to stateless starts a new chat.

Safety Identifier (optional)

Use a stable, privacy-preserving identifier when the application serves individual end users.

Reasoning Mode

Reasoning Context

Prompt Cache Mode

Prompt Cache TTL

Prompt Cache Options

Comparison uses the last completed response ID, even with Store Response off. The first turn omits it.

Prompt Cache Key (optional)

Output and deliveryStructured output, service tier, and streaming options

Service tier

Availability depends on your project. Astra Fast costs 2x Standard and is unavailable in the EU; Flex costs 0.5x Standard.

Response format

JSON schema constrains the output structure. JSON object mode adds a JSON instruction.

Background generation over HTTP

OpenAI runs generation in the background. This page follows the event stream when Stream is on and polls for the complete response when it is off. This is separate from async tools.

Include stream obfuscation

Adds random padding to HTTP streaming events to reduce information leakage from packet sizes.

Conversation and contextCache-preserving reasoning changes, compaction, and context limits

Conversation reasoning effort

Adds a configuration_update before the next user message without changing the original request effort. Requires standard, single-agent mode with automatic compaction and truncation off.

Automatic compaction threshold (tokens)

Blank disables compaction. The minimum threshold is 1,000 tokens. Compaction preserves a condensed, opaque continuation.

Overflow behavior

Explicitly compact on the next request

Appends compaction_trigger as the final input item. Cleared after a successful operation. A conversation effort override is reapplied on the next user turn.

Tools and orchestrationTool selection, execution budgets, async work, and live steering

Tool use

Built-in tool-call limit (optional)

Shared by built-in tools per response. Blank uses the web-search limit when enabled. Not sent in multi-agent mode.

Allow parallel tool calls

Automatically disabled on the wire when combining async tools with multi-agent mode.

Connection

Native OpenAI only for WebSocket. A steering composer appears while a response is running. Updates cannot undo completed work. The code tab shows the equivalent HTTP request; raw events also record WebSocket frames.

Run application tools asynchronously

Uses your configured WebIQ and allowed X MCP tools. Jobs start as calls arrive while Astra continues working; their results return with the original call IDs. Hosted tools are not marked async.

Response continuation budget

Caps tool-result and steering continuations per operation. Each response has its own token budget.

Enable multi-agent orchestration (beta)

OpenAI can delegate to subagents. This can increase token usage. Reasoning summaries and built-in tool limits are omitted.

Maximum concurrent subagents

Defaults to 3; this limits active subagents, not the total number created or total cost.

Astra misalignment monitoring is managed by OpenAI, not a request toggle. Policy blocks stop this conversation without automatic retries. Configure safety alerts in OpenAI.