New Models: Claude Fable 5.2, Gemini 4 Carbon, GPT Image 2.6

Date: 2026-11-11 / (1405-08-20)

Summary

Claude Fable 5.2, Gemini 4 Carbon, and GPT Image 2.6 Flare and Sunburst are now available on AvalAI. Fable adds a lower-priced option for demanding reasoning and agents; Carbon supports sustained multimodal work with promotional pricing through November 30. The two image models serve fast iteration and detailed editing.

Details

Anthropic: Claude Fable 5.2

Use claude-fable-5-2 for demanding software engineering, multi-step research, and agents that carry analysis through to a finished deliverable. Anthropic released Fable 5.2 on November 9 and reports improvements in coding, reasoning, vision, and clarity over Fable 5.1, with output generation up to 30% faster. These are provider evaluations; measure quality, latency, and cost on your own AvalAI workload.

Anthropic documents a shared 1M-token context window, up to 128K output tokens, text and image input, and text output. Adaptive thinking is always on. The upstream API effort default is high, with low, medium, high, xhigh, and max available. This API default differs from the medium default in Claude apps and Claude Code. Start without an effort override, then evaluate the selected endpoint's control before changing it.

For routine coding and knowledge work, Anthropic recommends starting with Opus 5.5 and moving to Fable when a higher-effort Opus evaluation still misses your requirements. Fable is also suited to an application-controlled advisor or coordinator role; your application supplies the tools and execution environment.

Migration points from Anthropic's documentation:

• Omit temperature, top_p, and top_k. Adaptive thinking cannot be disabled or replaced with a fixed budget_tokens configuration. Native Messages forced tool_choice values any and tool return an error.
• Preserve prior assistant blocks and keep the conversation prefix unchanged. Fable 5.2 applies the thinking-block prefix check to every upstream account; editing the system prompt, tools, or earlier messages can produce a 400 error. Other models, apart from Mythos 5.2, cannot read Fable 5.2's thinking blocks.
• Existing upstream computer-use integrations must review the move from computer_20251124 to computer_toolset_20260801. Endpoint access alone does not enable Anthropic's beta toolsets, advisor tools, or Fast mode through AvalAI.
• Anthropic requires 30-day data retention for Fable 5.2 unless it expressly authorizes zero data retention. Do not infer a zero-retention policy from a compatibility endpoint or a store parameter; confirm the applicable data terms before sending sensitive workloads.

See the Anthropic provider section and official migration notes.

Google: Gemini 4 Carbon

Use gemini-4-carbon for sustained reasoning, complex software engineering, multimodal knowledge work, and scientific analysis. Google announced general availability on November 10. Carbon accepts text, images, audio, video, and PDFs and produces text; it is not an image-generation, audio-generation, or Live API model.

Google specifies one shared 1,048,576-token window for input, thinking, and output. Ordinary synchronous output stops at 65,536 tokens, including thinking. Google's long-decode mode can use the remaining shared context through background execution or continuation; that upstream capability is not a promise of 1M-token synchronous output or background/continuation support on AvalAI.

Carbon uses more thinking tokens per turn than Argon, increasing latency and potential cost per task even at the same token rates. Google continues to recommend Argon for most interactive coding and routine advanced knowledge work. Carbon's upstream thinking levels are low, medium, and high, with medium the default; temperature, top_p, and top_k are ignored.

Google documents function calling, structured outputs, grounding, computer use, code execution, and implicit caching. Optional tools and parameter mappings depend on the selected AvalAI route. In particular, Carbon does not support upstream explicit cache creation or cached_content references: implicit caching starts with eligible prompts of at least 4,096 tokens. A listed cached-input price applies to actual hits, not every repeated prompt.

See the Google provider section and official Carbon guidance.

OpenAI: GPT Image 2.6 Flare and Sunburst

Both gpt-image-2.6-flare and gpt-image-2.6-sunburst accept text and reference images and produce images. OpenAI recommends Flare when response time and interactive iteration matter most, and Sunburst for demanding detail, layout, and edit accuracy. Compare both with the same prompt, reference images, dimensions, and quality setting before choosing for a workload.

OpenAI documents generation, editing, transparent backgrounds, and a new complexity control with low, medium, and high settings; both models default to high. Complexity controls planning separately from rendering quality, and has no separate upstream fee. Higher complexity can increase latency or introduce unwanted edits, so more is not always better for a focused change.

The upstream guide also describes markup-guided edits, SVG generation, and animated GIF output. These optional extensions need separate AvalAI compatibility verification; the examples below use ordinary PNG generation and editing. For GPT Image responses, decode data[0].b64_json; do not request a hosted image URL with the legacy response_format field.

See the OpenAI provider section and OpenAI's image prompting guide.

Enabled AvalAI endpoints

Exact model ID	Enabled routes	Minimum account tier
claude-fable-5-2	POST /v1/chat/completions, POST /v1/responses, native Anthropic POST /v1/messages	2
gemini-4-carbon	POST /v1/chat/completions, POST /v1/responses, native Gemini /v1beta/models	0
gpt-image-2.6-flare	POST /v1/images/generations, POST /v1/images/edits	1
gpt-image-2.6-sunburst	POST /v1/images/generations, POST /v1/images/edits	1

Use the exact IDs above. These additions do not announce redirects from Fable 5.1, Argon, or GPT Image 2.5. Endpoint availability does not establish every hosted tool, beta feature, or stored-conversation behavior. The minimum tiers above come from the current AvalAI rate-limit data; check your account's request, token, and image limits before sizing a workload.

Pricing

All rates below are AvalAI prices in USD per 1,000,000 tokens.

Text and reasoning models

Model / period	Input	Cached input	Cache creation input	Output
claude-fable-5-2	$8.00	$0.20	$10.00	$40.00
gemini-4-carbon — promotional through November 30, 2026 inclusive, 2026-11-30 (1405-09-09)	$2.00	$0.10	—	$10.00
gemini-4-carbon — standard from December 1, 2026, 2026-12-01 (1405-09-10)	$4.00	$0.20	—	$20.00

Fable 5.2's four announced rates are 20% lower than Fable 5.1's $10.00/$0.25/$12.50/$50.00 rates. Its cached-input rate is 97.5% below ordinary input; Carbon's cached-input rate is 95% below ordinary input in either period. Cache reads and cache creation are distinct billing categories: count each input token once in its applicable category. The $10.00 Fable cache-creation rate does not announce the upstream one-hour cache rate or guarantee a cache lifetime. A dash for Carbon means no separate cache-creation rate is announced here.

Output pricing includes billed reasoning tokens. At Fable's rates, 1,000 ordinary input tokens and 200 output tokens cost $0.016. At Carbon's promotional rates, the same usage costs $0.004, rising to $0.008 from December 1. These calculations exclude separately charged tools and do not imply equal reasoning usage or task quality.

Image models

Model	Text input	Image input	Cached text input	Cached image input	Text output	Image output
gpt-image-2.6-flare	$5.00	$8.00	$1.25	$2.00	$0.00	$30.00
gpt-image-2.6-sunburst	$5.00	$8.00	$1.25	$2.00	$0.00	$30.00

These are token rates, not flat prices per image or per edit. Add prompt text, reference-image inputs, and generated-image output in their respective categories, using cached rates only for actual cached input. Dimensions, quality, and request composition affect usage. A $0.00 text-output rate does not make image generation free; SVG/GIF costs cannot be inferred from a PNG example. See the paired pricing breakdown.

API request and response examples

Set AVALAI_API_KEY in your server-side environment. Each example makes one attempt with no automatic retry and a 10-second curl connection timeout. Text and image deadlines are examples, not latency guarantees; Carbon's 900-second deadline accommodates Google's guidance for difficult reasoning tasks. Output budgets include reasoning and may be exhausted before final text appears.

All response JSON below is illustrative, not a live AvalAI capture. IDs, timestamps, text, token counts, and exchange rates are sample values. Optional metadata may differ or be absent. The sample exchange rate is 100,000 Tomans/USD. Use returned usage and the User API for billing records. Truncated Base64 strings cannot be decoded as shown.

Chat Completions: Fable or Carbon

This example uses Fable. To use Carbon on the same endpoint, replace the model with gemini-4-carbon and allow a longer deadline for difficult prompts. Both use messages; read final text from choices[0].message.content.

Bash

curl --silent --show-error --fail-with-body \
  --connect-timeout 10 --max-time 120 --retry 0 \
  https://api.avalai.ir/v1/chat/completions \
  -H "Authorization: Bearer $AVALAI_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "model": "claude-fable-5-2",
    "messages": [{"role": "user", "content": "In one sentence, explain why a migration needs a rollback plan."}],
    "max_tokens": 2048
  }'

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AVALAI_API_KEY"],
    base_url="https://api.avalai.ir/v1",
    timeout=120.0,
    max_retries=0,
)
completion = client.chat.completions.create(
    model="claude-fable-5-2",
    messages=[
        {
            "role": "user",
            "content": "In one sentence, explain why a migration needs a rollback plan.",
        }
    ],
    max_tokens=2048,
)
print(completion.choices[0].message.content)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.AVALAI_API_KEY,
  baseURL: "https://api.avalai.ir/v1",
  timeout: 120_000,
  maxRetries: 0,
});
const completion = await client.chat.completions.create({
  model: "claude-fable-5-2",
  messages: [{ role: "user", content: "In one sentence, explain why a migration needs a rollback plan." }],
  max_tokens: 2048,
});
console.log(completion.choices[0].message.content);

{
  "id": "chatcmpl-fable-example",
  "object": "chat.completion",
  "created": 1794355200,
  "model": "claude-fable-5-2",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "A rollback plan provides a tested way to restore service if a migration fails."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 20,
    "completion_tokens": 100,
    "total_tokens": 120,
    "prompt_tokens_details": {
      "cached_tokens": 0
    }
  },
  "estimated_cost": {
    "unit": "0.0041600000",
    "irt": 416.0,
    "exchange_rate": 100000
  }
}

The sample cost is (20 × 8 + 100 × 40) / 1,000,000 = $0.00416. Carbon with the same illustrative usage would cost $0.00104 during the promotion, then $0.00208. Check finish_reason; length means the output budget was reached.

Responses: Carbon or Fable

This example uses Carbon. Replace model with claude-fable-5-2 to use Fable on Responses. Responses uses input and max_output_tokens. SDK clients expose response.output_text; in raw JSON, scan typed output items for messages containing output_text content rather than assuming output[0] is the answer. Check status, error, and incomplete_details.

Bash

curl --silent --show-error --fail-with-body \
  --connect-timeout 10 --max-time 900 --retry 0 \
  https://api.avalai.ir/v1/responses \
  -H "Authorization: Bearer $AVALAI_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "model": "gemini-4-carbon",
    "input": "In one sentence, explain why a migration needs a rollback plan.",
    "max_output_tokens": 2048
  }'

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AVALAI_API_KEY"],
    base_url="https://api.avalai.ir/v1",
    timeout=900.0,
    max_retries=0,
)
response = client.responses.create(
    model="gemini-4-carbon",
    input="In one sentence, explain why a migration needs a rollback plan.",
    max_output_tokens=2048,
)
print(response.output_text)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.AVALAI_API_KEY,
  baseURL: "https://api.avalai.ir/v1",
  timeout: 900_000,
  maxRetries: 0,
});
const response = await client.responses.create({
  model: "gemini-4-carbon",
  input: "In one sentence, explain why a migration needs a rollback plan.",
  max_output_tokens: 2048,
});
console.log(response.output_text);

{
  "id": "resp_carbon_example",
  "object": "response",
  "created_at": 1794355200,
  "status": "completed",
  "error": null,
  "incomplete_details": null,
  "model": "gemini-4-carbon",
  "output": [
    {
      "id": "msg_carbon_example",
      "type": "message",
      "status": "completed",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "A rollback plan provides a tested way to restore service if a migration fails.",
          "annotations": []
        }
      ]
    }
  ],
  "usage": {
    "input_tokens": 20,
    "input_tokens_details": {
      "cached_tokens": 0
    },
    "output_tokens": 100,
    "output_tokens_details": {
      "reasoning_tokens": 80
    },
    "total_tokens": 120
  },
  "estimated_cost": {
    "unit": "0.0010400000",
    "irt": 104.0,
    "exchange_rate": 100000
  }
}

The 100 output tokens include 80 reasoning tokens. At promotional rates, (20 × 2 + 100 × 10) / 1,000,000 = $0.00104; the same usage costs $0.00208 from December 1. Native Google background/continuation features are not established by this Responses example.

Native Anthropic Messages: Fable

Messages requires max_tokens and returns typed content blocks. With an Anthropic SDK, use https://api.avalai.ir as the base URL, without /v1. Preserve returned thinking blocks when continuing a conversation; the illustrative text-only envelope below does not promise that every response omits them.

Bash

curl --silent --show-error --fail-with-body \
  --connect-timeout 10 --max-time 120 --retry 0 \
  https://api.avalai.ir/v1/messages \
  -H "x-api-key: $AVALAI_API_KEY" \
  -H 'anthropic-version: 2023-06-01' \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "model": "claude-fable-5-2",
    "max_tokens": 2048,
    "messages": [{"role": "user", "content": "In one sentence, explain why a migration needs a rollback plan."}]
  }'

{
  "id": "msg_fable_example",
  "type": "message",
  "role": "assistant",
  "model": "claude-fable-5-2",
  "content": [
    {
      "type": "text",
      "text": "A rollback plan provides a tested way to restore service if a migration fails."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 20,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0,
    "output_tokens": 100
  },
  "estimated_cost": {
    "unit": "0.0041600000",
    "irt": 416.0,
    "exchange_rate": 100000
  }
}

Read text blocks by their type. Anthropic documents that a classifier refusal may return HTTP 200 with stop_reason: "refusal"; HTTP success alone is not a completed task. Verify refusal handling on your selected AvalAI route.

Native Gemini: Carbon

Native Gemini uses contents and parts with the model-qualified :generateContent action. In the Google GenAI SDK, use the host https://api.avalai.ir with API version v1beta, rather than appending /v1. No explicit cache or thinking override is needed for this baseline.

Bash

curl --silent --show-error --fail-with-body \
  --connect-timeout 10 --max-time 900 --retry 0 \
  https://api.avalai.ir/v1beta/models/gemini-4-carbon:generateContent \
  -H "x-goog-api-key: $AVALAI_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "contents": [{"role": "user", "parts": [{"text": "In one sentence, explain why a migration needs a rollback plan."}]}],
    "generationConfig": {"maxOutputTokens": 2048}
  }'

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": "A rollback plan provides a tested way to restore service if a migration fails."
          }
        ]
      },
      "finishReason": "STOP",
      "index": 0
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 20,
    "candidatesTokenCount": 20,
    "thoughtsTokenCount": 80,
    "totalTokenCount": 120
  },
  "modelVersion": "gemini-4-carbon",
  "responseId": "carbon-native-example",
  "estimated_cost": {
    "unit": "0.0010400000",
    "irt": 104.0,
    "exchange_rate": 100000
  }
}

The sample bills 20 input tokens and 100 output tokens: 20 candidate tokens plus 80 thinking tokens. Inspect finishReason and any prompt feedback before reading an answer; a blocked or incomplete request may have no usable candidate.

Images generation: Flare or Sunburst

Start with Flare for interactive iteration; replace the model with gpt-image-2.6-sunburst for detailed work. The request selects one 1024x1024 PNG at medium quality. Save the complete JSON response, then decode its b64_json field into image bytes; the displayed response is truncated for readability.

Bash

curl --silent --show-error --fail-with-body \
  --connect-timeout 10 --max-time 180 --retry 0 \
  https://api.avalai.ir/v1/images/generations \
  -H "Authorization: Bearer $AVALAI_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "model": "gpt-image-2.6-flare",
    "prompt": "A studio product photo of a ceramic mug, soft natural lighting, plain cream background.",
    "size": "1024x1024",
    "quality": "medium",
    "output_format": "png",
    "n": 1
  }' --output image-generation-response.json

{
  "created": 1794355200,
  "data": [
    {
      "b64_json": "iVBORw0KGgoAAAANSUhEUg...[TRUNCATED]"
    }
  ],
  "output_format": "png",
  "size": "1024x1024",
  "quality": "medium",
  "usage": {
    "input_tokens": 20,
    "input_tokens_details": {
      "text_tokens": 20,
      "image_tokens": 0
    },
    "output_tokens": 1000,
    "output_tokens_details": {
      "text_tokens": 0,
      "image_tokens": 1000
    },
    "total_tokens": 1020
  },
  "estimated_cost": {
    "unit": "0.0301000000",
    "irt": 3010.0,
    "exchange_rate": 100000
  }
}

This arbitrary sample usage costs (20 × 5 + 1000 × 30) / 1,000,000 = $0.0301 for either model. It is not a measured output-token count or a 1024x1024 medium-quality price quote. The Images envelope does not require a chat-style id, model, or choices field.

Images editing: Sunburst or Flare

Use the plural /v1/images/edits endpoint and an existing local product.png. Replace the model with gpt-image-2.6-flare to compare the same edit. Let curl set the multipart content type and boundary; do not add a JSON content-type header. State both the desired change and the details to preserve.

Bash

curl --silent --show-error --fail-with-body \
  --connect-timeout 10 --max-time 180 --retry 0 \
  https://api.avalai.ir/v1/images/edits \
  -H "Authorization: Bearer $AVALAI_API_KEY" \
  -F 'model=gpt-image-2.6-sunburst' \
  -F 'image=@product.png' \
  -F 'prompt=Change only the background to pale blue; preserve the mug, lighting, and composition.' \
  -F 'size=1024x1024' \
  -F 'quality=medium' \
  -F 'output_format=png' \
  -F 'n=1' --output image-edit-response.json

Editing returns the same Images envelope. For illustration, 20 text-input tokens, 500 uncached image-input tokens, and 1,000 image-output tokens cost (20 × 5 + 500 × 8 + 1000 × 30) / 1,000,000 = $0.0341. Reference-image input is an additional category, not a flat editing surcharge. Inspect the actual edit for preserved subject, geometry, text, and lighting before accepting it.

Integration checks

Begin with the text or PNG examples, then evaluate optional tools, effort controls, caching, and streaming separately for each route. Test the intended prompt set, output schema, conversation-history handling, token budget, and total cost before switching an existing workflow. An upstream capability or a successful call to one endpoint does not establish another endpoint's optional features.

For a failed request, retain the HTTP status, error body, and avalai-request-id. Fix invalid parameters, authentication, or account access before retrying. Terminal quota errors require account intervention. A timeout can occur after processing and billing, so do not automatically repeat image generation or agentic work without inspecting the result and your retry policy.

Related links

• AvalAI pricing
• Chat Completions, Responses, Messages, and native Gemini
• Image Generation API and image workflow guide
• Official Claude Fable 5.2 overview
• Official Gemini 4 Carbon model reference
• Official GPT Image 2.6 Flare and Sunburst