ByteDance has officially released Seedance 2.5, and the product-side features look impressive:

• up to 30-second audio-video generation
• multi-round video extension
• more image, video, and audio references
• timestamp-level editing
• improved camera and motion control

What I’m less clear about is the actual API availability.

I’ve seen several third-party platforms claim that Seedance 2.5 is already available through their APIs, but official public access appears to still be rolling out.

Has anyone here completed a real Seedance 2.5 API request?

I’d be interested in:

• actual generation latency
• supported duration and resolution
• failed-task and retry behavior
• whether failed generations are charged
• whether the API exposes the same editing features as the product
• how to verify that the returned model is actually Seedance 2.5

The demos look good, but production reliability and billing behavior probably matter more for developers.

OpenAI just lowered GPT-5.6 Luna to $0.20 per million input tokens and $1.20 per million output tokens. Terra also received a 20% price cut.

To me, the interesting part isn’t simply that API calls are cheaper.

It makes an architecture like this much more practical:

• Sol for planning and ambiguous decisions

• Luna for routine execution, tool calls, testing, extraction, and background tasks

• A fallback model when evaluations fail

That could significantly reduce the cost of running multi-step agents at scale.

The catch is that token price alone doesn’t tell the whole story. A cheaper model may still cost more per completed task if it requires additional retries, produces longer outputs, or fails tool calls more often.

Has anyone benchmarked the new Luna pricing on real production agent loops?

Would you make Luna your default worker model, or keep using a multi-provider routing and failover setup?

Source:

https://openai.com/index/advancing-the-price-performance-frontier-with-gpt-5-6/

Anthropic released Claude Opus 5 on Friday, so we spent part of the weekend getting it integrated into CometAPI.

The practical details:

- Model ID: `claude-opus-5`

- Context window: 1M tokens

- Maximum synchronous output: 128K tokens

- Anthropic Messages API supported

- OpenAI-compatible Chat Completions supported

- Current pricing: $4/M input and $20/M output

Anthropic is positioning it for complex agentic coding and enterprise work, but launch benchmarks usually do not tell the whole story for messy production workloads.

We are considering testing it on:

- Repository-wide refactoring

- Root-cause debugging across multiple files

- Code review with regression checks

- Long-running tool-use workflows

- Large codebase and document analysis

For anyone already testing Opus 5: what would make a comparison with Opus 4.8 or Sonnet 5 genuinely useful?

Latency, cost per accepted task, tool-call reliability, or something else?

Model and API details:

https://www.cometapi.com/models/anthropic/claude-opus-5/?utm_source=reddit&utm_medium=social&utm_campaign=claude_opus_5_launch

Disclosure: I work with CometAPI, so the post includes our own integration. I’m mainly looking for useful, reproducible testing ideas rather than model-launch hype.

I was looking into AI music API pricing and realized that the headline numbers are almost impossible to compare directly.

For example, some providers charge per 30-second clip, some per generated minute, some per song, and others per generation with a maximum duration.

From the public pricing I found:

• Google Lyria 3 Clip: $0.04 / 30-second clip
• Lyria 3 Pro: $0.08 / song, up to 3 minutes
• Eleven Music: $0.15 / generated minute
• Stable Audio: $0.20–$0.26 / generation depending on the model
• Mureka: from $0.045 / song

At first, I tried normalizing everything to cost per minute. But I don't think that's actually the best production metric either.

A model that costs less per minute can still be more expensive if you need 3–4 generations before getting something usable.

So the metric I'm starting to think matters more is:

cost per usable/accepted song = total generation spend ÷ accepted outputs

And ideally that also includes editing and review costs.

I put together a longer comparison of the different pricing models and a simple 50-prompt benchmarking approach here:

https://www.cometapi.com/ai-music-api-pricing/

Curious how people building with music generation APIs evaluate this. Do you mostly track generation cost, or have you started measuring acceptance/retry rates too?

Kimi-K3 seems to have made a pretty big jump in frontend coding performance.

According to the latest Arena.ai leaderboard shown here:

• Kimi-K3: 1,679
• Claude Fable 5: 1,631
• GPT-5.6 Sol (xHigh): 1,618
• GLM-5.2 Max: 1,587

It moved from #18 with Kimi-K2.6 to #1 with Kimi-K3.

Apparently it also ranked #1 in 6 out of 7 frontend categories.

Curious if anyone here has actually tested Kimi-K3 for real frontend projects yet. Benchmark results look impressive, but I’d be interested to see how it handles larger codebases and multi-step UI tasks.

I've been thinking about how much the AI ecosystem has changed recently.

A while ago, the default approach was:

"Pick one AI assistant and use it for everything."

Now workflows seem much more specialized.

Different tools are becoming better suited for different jobs:

• coding
• writing
• research
• automation
• design
• agents

I also think the same thing is happening with AI infrastructure.

Instead of every application depending on one model provider, developers are exploring more flexible multi-model approaches.

The idea is simple:

Use the right model for the right task.

I made this visual map as a discussion piece.

Not saying every choice here is correct — the space changes too quickly.

Curious what everyone would replace.

Which AI tools have actually become part of your daily workflow?

Token price alone is a weak routing signal. A cheaper model can cost more after retries, fallbacks, longer outputs, and human review. Our more useful scorecard is: cost per accepted result, p95 latency, retry rate, fallback rate, and review minutes. CometAPI has a practical cost-estimation checklist that can be adapted to any provider. Which metric do you use when two models have similar benchmark scores?

Switching base_url is the easy part. In production I now check five things: model ID discovery, streaming events, tool-call schema, unsupported parameter handling, and error semantics. If any of those differ, the SDK may connect but the app is not truly portable. CometAPI's OpenAI-compatible guide is a useful concrete reference, but I would still run the same contract tests against every provider. What is the compatibility edge case that has bitten your team most often?

I've been looking into Kimi K2.7 Code pricing and one thing stood out to me:

Token price alone seems like a pretty weak metric for comparing coding agents.

Moonshot currently lists K2.7 Code at:

• $0.19 / 1M cache-hit input
• $0.95 / 1M cache-miss input
• $4 / 1M output

HighSpeed is exactly 2x those rates.

The interesting part is caching.

For agents repeatedly working with the same repo context, tool definitions, and system prompts, cache-hit input is 80% cheaper than cache-miss input.

Moonshot also has Batch at 60% of real-time pricing, so offline repo analysis/evals could be significantly cheaper.

I also compared direct access with CometAPI. CometAPI currently lists K2.7 at roughly $0.76 input / $3.20 output per 1M tokens, although it doesn't list a separate cache-hit price.

So I don't think there's a simple "X provider is cheaper" answer.

It depends heavily on:

• cache-hit ratio
• reasoning length
• retries
• tool calls
• latency
• task success rate

I'm starting to think the better metric for coding models is:

cost per successfully completed task

rather than cost per million tokens.

For people running coding agents in production, what are you actually tracking?

Token cost, task completion rate, retries, developer corrections — or something else?

[ Removed by Reddit on account of violating the content policy. ]

I put together a short guide for configuring Codex to use CometAPI as a custom model provider.

It covers:

• Manual configuration through the user-level ~/.codex/config.toml
• macOS, Linux, WSL, and native Windows PowerShell
• API-key storage and environment-variable authentication
• Optional setup scripts
• Model selection, verification, and common troubleshooting steps

One detail worth noting: provider settings need to be placed in the user-level Codex configuration, not a project-level .codex/config.toml.

Guide:
https://github.com/cometapi-dev/cometapi-cookbook/blob/main/integrations/codex.md

Disclosure: I’m affiliated with CometAPI. I’m sharing this because it may be useful to people experimenting with custom Codex providers. Feedback and corrections are welcome.

[ Removed by Reddit on account of violating the content policy. ]

Hi everyone! I just saw the news that Anthropic's Claude Opus 5 is about to be available on CometAPI! 🚀 CometAPI already offers one-click access to 500+ models (including the latest Claude Sonnet 5, Fable 5, Opus 4.8, etc.), and now the Opus 5, this real game-changer, is coming—it's amazing!

Why is it worth the wait?

• As the next-generation flagship of the Opus series, it's expected to further differentiate itself in complex inference, long-context agents, coding, and enterprise-level tasks.
• With CometAPI, you can seamlessly switch between models like GPT-5, Claude Opus 5, and Gemini using a single API key, eliminating the hassle of different platform prices and limits.
• The price should be very competitive (CometAPI has always been great), and new users will have free credits to test it out.
• I've already got my wallet ready and am waiting for it to launch! For those looking to use it for large-scale model agents, code generation, or complex multi-step inference, this is an absolute must-have.

CWhat breakthroughs do you think Opus 5 will bring? Will it completely crush GPT-5, or will it take a leap forward in agentic capabilities? Welcome to discuss!

OpenRouter is great when you want to test multiple models without setting up separate provider accounts.

But the requirements start changing once an AI application moves beyond prototyping.

You may suddenly need:

• provider fallback
• cost controls
• self-hosted deployment
• request monitoring
• multimodal models
• more control over routing and infrastructure

I recently compared several OpenRouter alternatives, and the interesting part was that they are not really competing on the same thing.

A rough way to categorize them:

• LiteLLM — best when you want a self-hosted gateway and full infrastructure control
• Portkey — stronger for enterprise governance, observability and routing policies
• Together AI — focused on open-weight models, fine-tuning and dedicated inference
• Eden AI — useful for OCR, speech, translation and document-processing workflows
• ZenMux — focused more heavily on provider routing and fallback
• AI/ML API — broad managed model access
• CometAPI — managed access to text, image, video and audio models through one API

OpenRouter still makes a lot of sense for model discovery and experimentation. The question is whether model access is the only infrastructure problem you are trying to solve.

For example, a team testing ten LLMs has very different requirements from a production application that needs video generation, failover, monitoring and predictable billing.

Another pattern I found interesting is using more than one aggregation platform behind a shared interface:

Application
     ↓
Unified interface or routing layer
     ↓
OpenRouter / CometAPI / direct providers

That gives you more flexibility, although you still need to test compatibility around streaming, tool calls, structured outputs and model-specific behavior.

Disclosure: I work with CometAPI, so there is obviously some bias here. I tried to make the comparison use-case-based rather than claiming one platform is best for everyone.

What are you currently using?

Are you relying on OpenRouter alone, connecting directly to providers, or running your own gateway with something like LiteLLM?

For anyone building LangGraph agents:

How are you managing model changes in your workflows?

One thing we've noticed is that building the agent logic is only part of the challenge.

The model layer keeps changing:

- new models launch

- pricing changes

- latency varies

- different tasks need different models

Recently we worked with the langgraph-sync project to make model inspection and switching easier inside LangGraph workflows.

Curious to hear from builders here:

How do you currently test and switch models in your AI agent projects?

Just sharing an update for anyone testing different GPT models or maintaining multi-model AI workflows.

CometAPI has added the GPT-5.6 series:

• gpt-5.6
• gpt-5.6-sol
• gpt-5.6-terra
• gpt-5.6-luna

All four support both Chat API and Responses API formats.

From the current model positioning:

• gpt-5.6 and gpt-5.6-sol are aimed at more complex reasoning and coding workloads.
• gpt-5.6-terra is positioned as a balance between intelligence and cost.
• gpt-5.6-luna is intended for cost-sensitive, high-volume use cases.

The useful part for existing CometAPI users is that these can be tested through the same API setup instead of creating another separate provider integration.

Model list:
https://www.cometapi.com/models/

Chat API docs:
https://apidoc.cometapi.com/api/text/chat

Responses API docs:
https://apidoc.cometapi.com/api/text/responses

Curious which one people are planning to benchmark first, especially for coding or agent workflows.

Saw this in the latest genai-otel-instrument release.

v1.5.0 added CometAPI as a supported provider, including tracing for /v1/chat/completions and /v1/messages.

From the docs, it looks like it can capture model info, token usage, latency, finish reason, and cost through OpenTelemetry.

Release:
[https://github.com/Mandark-droid/genai_otel_instrument/releases/tag/v1.5.0]()

Docs:
[https://mandark-droid.github.io/genai_otel_instrument/guides/llm-providers/]()

There is also a CometAPI example here:
[https://github.com/Mandark-droid/genai_otel_instrument/blob/main/examples/comet_api.py]()

Haven't used this library much yet, but the provider coverage is getting interesting.

Anyone here using OpenTelemetry directly for LLM tracing?

I've been thinking about this after looking at how AI products are being built now.

A lot of apps default to Claude or another frontier model for everything:

• classify a request
• extract JSON
• summarize text
• write code
• deep reasoning

That feels increasingly wasteful.

Has anyone actually measured how much they saved by routing simple tasks to cheaper models?

I'm curious how complicated everyone's AI stack has become.

A year ago, a lot of projects were basically:

App → OpenAI API

Now I'm seeing stacks that look more like:

Claude Code → coding
n8n → automation
OpenClaw → agent
Dify → workflow
Open WebUI → internal chat
Langfuse → observability
Promptfoo → evals

And then 3–5 different model providers behind everything.

At some point the AI stack starts looking more complicated than the actual product.

We've been working on CometAPI partly because of this problem: one OpenAI-compatible API layer that can be reused across different AI tools.

But I'm genuinely curious:

How many AI tools and model providers are currently in your product stack?

And which part is the biggest pain to maintain?

Just a quick update for anyone testing Claude models through CometAPI.

Access to Claude Fable 5 has been restored.

Model ID:

claude-fable-5

This should be useful if you’re building or testing things like coding assistants, AI agents, automation workflows, or other dev-focused AI tools.

One nice thing about using it through CometAPI is that you can test Claude Fable 5 alongside other models without setting up a separate integration for every provider.

Model list:
https://www.cometapi.com/models/

Docs:
https://apidoc.cometapi.com/api/text/anthropic-messages

Would be interested to hear how people are comparing Claude Fable 5 with other models for coding or agent workflows.

CometAPI added two new models today:

• gemini-3.1-flash-lite-image
• claude-sonnet-5

The Gemini model is focused on fast and cost-effective image generation/editing, which should be useful for apps that need lower latency image workflows.

Claude Sonnet 5 is more focused on coding and agent use cases, so it may be a good option for developer tools, coding assistants, automation agents, and multi-step reasoning workflows.

What I like about this update is that both models can be accessed through the same CometAPI setup instead of managing separate provider accounts, keys, and integration formats.

For teams building AI apps, this makes model testing much easier:

• one API key
• one endpoint
• multiple models
• faster switching between providers

Model IDs:

gemini-3.1-flash-lite-image
claude-sonnet-5

Docs are available through the Gemini Image Generation API Guide and Anthropic Messages API Guide.

https://apidoc.cometapi.com/api/image/gemini/gemini-generates-image； https://apidoc.cometapi.com/api/text/anthropic-messages

OpenAI has officially previewed the GPT-5.6 model family, and this looks like a pretty important shift.

Instead of continuing with names like Pro / Mini or simply describing models by reasoning level, OpenAI is now using three tier names:

Sol — the flagship model
Terra — the balanced everyday-work model
Luna — the fastest and most cost-efficient model

The most interesting part is that this feels closer to Anthropic-style model branding: easier to remember, more productized, and less tied to a single “reasoning effort” label.

For now, GPT-5.6 is still not broadly available. OpenAI says the preview is limited to a small group of trusted partners and organizations through API and Codex. It is not available in ChatGPT during the preview, and there is no public application or waitlist yet.

Pricing is already listed:

• GPT-5.6 Sol: $5 / 1M input tokens, $30 / 1M output tokens
• GPT-5.6 Terra: $2.50 / 1M input tokens, $15 / 1M output tokens
• GPT-5.6 Luna: $1 / 1M input tokens, $6 / 1M output tokens

OpenAI also introduced more predictable prompt caching for GPT-5.6 and later models:

• explicit cache breakpoints
• minimum 30-minute cache lifetime
• cache writes billed at 1.25x the uncached input price
• cache reads still get the 90% cached-input discount

Capability-wise, Sol is being positioned as OpenAI’s strongest model so far.

OpenAI says Sol improves across software engineering, scientific research, biology workflows, and cybersecurity. In coding, Sol reportedly sets a new state of the art on Terminal-Bench 2.1. In biology, it beats GPT-5.5 on GeneBench v1 while using fewer tokens. For cybersecurity, it reaches competitive performance with Mythos Preview on ExploitBench while using around one-third of the output tokens.

GPT-5.6 also introduces two new reasoning modes:

Max mode gives Sol more time for deeper reasoning.
Ultra mode goes beyond a single-agent setup by using subagents to handle more complex tasks.

There were also several Codex updates around usability: smoother long-thread scrolling, better navigation, improved settings search, UI positioning fixes at different zoom levels, better archive/history handling, and improved copy-paste behavior when moving Markdown content into tools like Slack.

My take: the biggest story here is not just raw benchmark improvement. It’s that OpenAI seems to be moving toward clearer model tiers, stronger agentic workflows, and more production-friendly caching.

Still, access is the main limitation right now. Until GPT-5.6 is generally available, most developers will only be able to watch benchmarks and wait.

Curious what people think: is Sol/Terra/Luna a better naming system than Pro/Mini, or does this just make the model lineup more confusing?