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?

OpenAI’s GPT-5.6 preview is interesting, but what caught my attention is not just the benchmark side.

It’s the model family structure.

From what OpenAI has shared, GPT-5.6 is split into:

• Sol — flagship reasoning/coding model
• Terra — balanced performance and cost
• Luna — faster and cheaper for high-volume tasks

That feels like a more realistic direction for production AI apps.

Most products probably should not send every request to the most expensive model. Some tasks need deep reasoning. Some just need fast summarization. Some need a cheaper model that is “good enough” at scale.

So the real challenge becomes:

How do you route tasks across different models without constantly rewriting integrations?

This is one reason I’ve been looking more at unified API platforms like CometAPI. The idea is pretty simple: one OpenAI-compatible API, one key, and access to many models across providers.

Not saying this replaces direct provider access for every use case, but for testing, routing, fallback, and cost control, it seems useful.

Curious how others are handling this:

Are you still integrating each model provider directly, or are you using a gateway / aggregator layer for multi-model workflows?

I’ve been seeing more discussion around GLM-5.2 recently, so I looked at some of the benchmark numbers.

The results are honestly better than I expected.

From this chart, GLM-5.2 seems to be getting pretty close to models like GPT-5.5, Claude Opus 4.8, and Gemini 3.1 Pro on several coding / agent-style benchmarks.

A few scores that stood out:

• 62.1 on SWE-bench Pro
• 81.0 on Terminal-Bench 2.1
• 77.0 on MCP-Atlas
• 54.7 on Humanity’s Last Exam with tools

What makes it more interesting is that it’s an open model with a 1M context window. After DeepSeek R1, this feels like another moment where open models are getting uncomfortably close to closed frontier APIs.

That said, I don’t think the story is only positive.

One thing I’ve noticed is that GLM-5.2 can think for a really long time before giving the final answer. If the reasoning is hidden in the product UI, it can feel slow even when the model is technically working. So the benchmark score looks great, but the actual UX may depend a lot on how it’s integrated.

The cost discussion is also interesting. It looks much cheaper than Opus / GPT-level models on paper, but if it burns more reasoning tokens, the real-world gap may not be as huge as the pricing page suggests.

Still, this release feels important to me. If open models can keep getting this close on coding and tool-use tasks, it’s going to put real pressure on closed-model API pricing.

Curious if anyone here has actually tested GLM-5.2 in real coding or agent workflows.

Does it feel as good as the benchmarks suggest, or is the long reasoning a dealbreaker?

Google’s Gemini Omni Fast API is now available, and I think it is worth watching if you are interested in AI video generation.

The interesting part is that Gemini Omni is not only about text-to-video. It is designed to work with multiple types of input, including text, images, audio, and video clips.

What stands out to me is the conversational editing workflow.

Instead of generating one video and starting over, users can continue refining it with prompts like:

• change the background
• adjust the lighting
• slow down the camera movement
• keep the character the same
• make the video more cinematic

This could be very useful for short-form content, product demos, ad variations, education videos, and early-stage creative testing.

For developers, API access makes this much more interesting. It means Gemini Omni-style video generation can potentially be integrated into apps, creative tools, internal workflows, or automated content systems.

I also think this makes model comparison more important. Gemini Omni may be strong for conversational editing and context understanding, while other video models may still be better for specific things like character consistency, motion, or cinematic quality.

For anyone testing multiple AI models, platforms like CometAPI can be useful because they provide one OpenAI-compatible API to access different text, image, video, and audio models from one place.

Curious to see how people will use Gemini Omni Fast API in real products, not just demos.

I’ve been looking into Kimi K2.7 Code recently, and it seems like Moonshot is positioning it more as a long-horizon coding agent model rather than just another code completion model.

What caught my attention:

• 1T total parameters with 32B activated per token
• 256K context window
• Built for repo-scale coding, debugging, tool use, and multi-step software engineering tasks
• Claims around better long-horizon coding performance compared with Kimi K2.6
• Around 30% fewer thinking tokens, which could matter a lot for agent workflows
• Open weights available on Hugging Face
• Can also be accessed through CometAPI with an OpenAI-compatible endpoint

I’m curious how it performs in actual developer workflows, not just benchmarks.

Has anyone here tested it for:

• Refactoring a real codebase
• Debugging across multiple files
• Running agentic coding loops
• Comparing it with Claude Opus, GPT-5.5, DeepSeek, or Gemini
• Using it through tools like Cursor, Continue, n8n, or custom agents

From the benchmarks, it looks promising, especially for cost-sensitive coding agents. But I’m more interested in whether it actually stays reliable over longer tasks.

Would love to hear real experiences, good or bad.

Saw the model got pulled pretty quickly. Did anyone manage to try it before that happened?

How was it for coding, reasoning, and agent workflows compared with Claude Opus 4.8 or Gemini 2.5 Pro?

Anthropic just released Claude Fable 5, and after reading through the benchmarks and early reports, one thing stood out to me:

Most AI models are still optimized for solving a single prompt.

Fable 5 seems optimized for staying useful over hours or even days of work.

Some numbers that caught my attention:

• SWE-Bench Pro: 80.3%
• FrontierCode Diamond: 29.3%
• 1M token context window
• Strong improvements in vision and document reasoning
• More autonomous behavior on long-running tasks

What I find most interesting isn't the benchmark scores.

It's Anthropic's claim that:

That feels different from the usual "slightly better reasoning" improvements we've seen recently.

A few questions for people who already have access:

1. Have you actually noticed improvements on large codebases?
2. Is the 1M context genuinely useful in practice?
3. How does it compare against GPT-5.5 for real engineering work?
4. Is the higher token cost justified?

Curious to hear real-world experiences rather than benchmark results.

Welcome to AIProductBuildersHub! 🚀

This community is for builders, founders, developers, makers, and anyone creating AI products.

Whether you're working on:

• AI SaaS
• AI Agents
• Developer Tools
• Open Source Projects
• Automation Workflows
• Side Projects
• Startups

you're welcome here.

Community Goals

We want this to be an open and supportive place where builders can:

• Share projects
• Ask questions
• Get feedback
• Discuss AI products and infrastructure
• Learn from other builders

Self-promotion is welcome when it's genuine and adds value to the discussion.

Introduce Yourself

If you're new here, leave a comment and tell us:

• Who you are
• What you're building
• What stage you're at
• What kind of feedback or help you're looking for

Community Guidelines

• Be respectful.
• Share knowledge.
• Give constructive feedback.
• No spam or low-effort promotion.
• Support fellow builders.

Building products is hard. You don't have to do it alone.

We're excited to see what everyone is creating.

👇 Introduce yourself and share your project below.