Reasoning Effort

The reasoning effort parameter lets you control how much reasoning depth Ring-2.6-1T applies when responding, balancing response quality against token efficiency. This parameter is currently only available for Ring-2.6-1T.

Effort Levels

Ring-2.6-1T supports two reasoning effort levels:

Choosing a level:

• Omitting the parameter is equivalent to high — suitable for most Agent and production scenarios.
• Use xhigh when the task demands maximum reasoning depth and you’re less sensitive to cost or latency.
• xhigh consumes significantly more tokens. Start with high and upgrade only when results don’t meet your quality bar.

Basic Usage

Ant Ling supports both the Anthropic API and the OpenAI-compatible API. The effort parameter field differs between the two styles.

Anthropic API

Use the /anthropic/v1/messages endpoint with output_config.effort:

import anthropic
 
client = anthropic.Anthropic(
    base_url="https://api.ant-ling.com",
    api_key="YOUR_API_KEY"
)
 
response = client.messages.create(
    model="Ring-2.6-1T",
    messages=[
        {"role": "user", "content": "Analyze the trade-offs between microservices and monolithic architectures"}
    ],
    extra_body={
        "output_config": {"effort": "xhigh"}
    }
)
 
print(response.content[0].text)

import Anthropic from '@anthropic-ai/sdk';
 
const client = new Anthropic({
  baseURL: 'https://api.ant-ling.com',
  apiKey: 'YOUR_API_KEY',
});
 
const response = await client.messages.create({
  model: 'Ring-2.6-1T',
  messages: [
    { role: 'user', content: 'Analyze the trade-offs between microservices and monolithic architectures' }
  ],
  // @ts-ignore
  output_config: { effort: 'xhigh' },
});
 
console.log(response.content[0].text);

curl https://api.ant-ling.com/anthropic/v1/messages \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "Ring-2.6-1T",
    "output_config": {"effort": "xhigh"},
    "messages": [
      {"role": "user", "content": "Analyze the trade-offs between microservices and monolithic architectures"}
    ]
  }'

OpenAI-compatible API

Use the /v1/chat/completions endpoint with reasoning.effort:

from openai import OpenAI
 
client = OpenAI(
    base_url="https://api.ant-ling.com/v1/",
    api_key="YOUR_API_KEY"
)
 
response = client.chat.completions.create(
    model="Ring-2.6-1T",
    messages=[
        {"role": "user", "content": "Analyze the trade-offs between microservices and monolithic architectures"}
    ],
    extra_body={
        "reasoning": {"effort": "xhigh"}
    }
)
 
print(response.choices[0].message.content)

import OpenAI from 'openai';
 
const client = new OpenAI({
  baseURL: 'https://api.ant-ling.com/v1/',
  apiKey: 'YOUR_API_KEY',
});
 
const response = await client.chat.completions.create({
  model: 'Ring-2.6-1T',
  messages: [
    { role: 'user', content: 'Analyze the trade-offs between microservices and monolithic architectures' }
  ],
  // @ts-ignore
  reasoning: { effort: 'xhigh' },
});
 
console.log(response.choices[0].message.content);

curl https://api.ant-ling.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "Ring-2.6-1T",
    "reasoning": {"effort": "xhigh"},
    "messages": [
      {"role": "user", "content": "Analyze the trade-offs between microservices and monolithic architectures"}
    ]
  }'

When to Adjust Reasoning Effort

• Use high (default): High-frequency Agent workflows, multi-turn tool collaboration, task decomposition, and production deployments. Prioritizes speed and cost for the majority of use cases.
• Use xhigh: Math competition problems, research paper analysis, complex logical reasoning, and multi-path exploration — tasks that demand the deepest possible reasoning.

Reasoning Effort and Tool Use

The effort level affects tool-calling behavior. At xhigh, Ring-2.6-1T tends to:

• Plan tool call sequences more carefully
• Reason more thoroughly between steps in multi-tool tasks
• Perform deeper analysis on tool responses

At high, the model completes tool collaboration more efficiently with less intermediate reasoning overhead — well suited for high-frequency automated pipelines.

Best Practices

1. Start with the default: high delivers excellent results for most scenarios. Evaluate the default before upgrading.
2. Match effort to task type: Use high for coding agents, tool-use workflows, and task decomposition; use xhigh for math reasoning, research analysis, and complex decision-making.
3. Monitor token usage: xhigh consumes significantly more tokens. Track usage in production to control costs.
4. Adjust dynamically: In complex pipelines, switch effort per subtask — high for routine steps, xhigh for critical reasoning steps.

Related Resources

• Ring Model Overview - Learn about Ring-2.6-1T’s capabilities and use cases
• Streaming - Use streaming responses to reduce perceived latency in reasoning tasks
• Quick Start - Make your first API call in 5 minutes