xAI: Grok 3 Mini Beta

Grok 3 Mini implements a two-stage generation pipeline where the model first produces internal reasoning tokens (thinking phase) before generating the final response. This architecture uses a separate thinking token budget that allows the model to decompose complex problems, verify logic, and self-correct before committing to output. The thinking phase is hidden from users but influences response quality through improved chain-of-thought reasoning without exposing intermediate steps.

Grok 3 Mini maintains conversation state across multiple turns through a standard message history protocol, where each turn includes role (user/assistant), content, and optional metadata. The model processes the full conversation history to maintain context coherence, allowing it to reference previous statements, correct misunderstandings, and build on prior reasoning. Context is managed client-side (no persistent server-side session storage), requiring the client to maintain and replay the full history for each request.

Grok 3 Mini is architected as a smaller, distilled model variant optimized for inference efficiency without sacrificing reasoning capability. The model uses parameter reduction, quantization-friendly architecture, and optimized attention patterns to achieve faster inference latency and lower memory footprint compared to full-scale models. This enables deployment on resource-constrained environments (edge devices, mobile, low-cost cloud instances) while maintaining reasoning performance through the thinking token mechanism.

Grok 3 Mini is accessible through OpenAI-compatible API endpoints (via OpenRouter), allowing drop-in integration with existing OpenAI client libraries and workflows. The model accepts standard OpenAI message format (system/user/assistant roles), supports streaming responses, and implements compatible parameter schemas (temperature, max_tokens, top_p). This compatibility eliminates the need for custom client code and enables easy model swapping in existing applications.

Grok 3 Mini supports server-sent events (SSE) streaming where response tokens are delivered incrementally as they are generated, allowing clients to display partial results in real-time. The streaming protocol delivers individual tokens or chunks with metadata, enabling responsive UIs that show progress during the thinking and generation phases. This is implemented through standard OpenAI-compatible streaming format, compatible with most client libraries.

Grok 3 Mini exposes standard sampling parameters (temperature, top_p, top_k) that control response randomness and diversity. Temperature scales logit distributions (0 = deterministic, 1+ = more random), top_p implements nucleus sampling to limit token probability mass, and top_k restricts to top-k most likely tokens. These parameters allow fine-tuning the balance between consistency (for deterministic tasks) and creativity (for open-ended generation).

Grok 3 Mini allows clients to specify max_tokens parameter to cap the maximum number of tokens in the response, and implicitly respects a context window limit (likely 128k or similar based on modern model standards). The model stops generation when either limit is reached, returning a stop_reason indicating whether completion was natural, hit token limit, or hit context window. This enables cost control and prevents runaway generations.

Grok 3 Mini accepts a system prompt (via the 'system' role in message arrays) that defines the model's behavior, tone, constraints, and instructions. The system prompt is processed before user messages and influences all subsequent reasoning and generation. This enables behavior customization without fine-tuning, allowing developers to define custom personas, enforce output formats, or add domain-specific constraints.