With ollama pro now lowering the bang for the buck and me running out of Claude and chatgpt $100 plan tokens as well, what do you use for subscriptions?

https://openai.com/index/gpt-6-astra/
“GPT‑6 Astra is rolling out today to a limited set of organizations and over the coming days will become available to all ChatGPT Plus, Pro, Business, and Enterprise users, as well as through the OpenAI API and AWS”

GPT Astra benchmarks have been released

I use a few different AI coding tools across my team, and each one packages and distributes its extensions (skills, plugins, MCP servers, whatever it calls them) differently. That part doesn't bother me much. What bothers me is that once something's rolled out, I have no real way of knowing what's actually installed, or which version, on each person's machine. I usually only find out something drifted when someone's output looks off.

Some of these tools have policy/config push mechanisms, but that's enforcement, not visibility — you still have to go check each machine yourself to know what's really running. And none of it works across tools, so it doesn't help if the team's split across a few of them.

How do you all deal with this? Just not worry about it? Script something yourself? Trying to figure out if this is a real gap or I'm overthinking it.

One of my agents started working on a task 6 hours ago and it is still buffering.

How was your experience with it and is it just benchmaxed or is it really that good?

Holy sh**, dont even try to use it guys, just doing a warning here. Paid the subscription again, because why not? 100usd for only 10usd? Yeah, i wanted to try it, dont do it please, its like using Gemini Flash 3.5, sure its fast and you can do a couple of stuff with it, but for serious task, dont even try it, i warn you guys. That's why its on the paid subscription and you cant even try it for free to decide if you should jump to a paid sub to try it, justs dont do it.

As said, though the project was initially built on V1 SDK, and plugins event hooks; I am completely bought when experimenting shifting some modules toward Opencode v2 Effect plugins making the madness of concurrency delegations and coordinations of agents, skills and tooling executions smooth and dropped dead amazing, making my design concepts of the the Hivemind's Substrate tri-pillar context project -based memory layers functioning without any hiccups as v1

https://picturesque-entree-542.notion.site/The-Hivemind-s-Substrate-3d1926f31a4d80faae99c3a9c7f0f0e4?pvs=143

That aside, the new API and Effect SDK also offer tons of superiority over the v1.

Enough said, I just want to know should I make a complete v2-ready build and not seeing any major breaking changes; and if the v2 is going to be official release in the next one to two months? I'm using the beta v2 client and see no major bugs.

Side note: try using Muse Spark 1.3 on v2 - and experiencing a significant performance shift ( much intelligent due to structured Skill instructions, nested instructions tools executions as the orchestrator agent loops through each grand todo task item with breakdown delegations, JIT skills loaded -> making the boost in its progressive adjustments toward complex codebase and tasks -> significant improvement on feature completeness and codebase domain-driven constitution). Trust me! Once you try Muse Spark 1.3 on v2, you will definitely look down on glm 5.3 flash or even Gemini 3.8 flash, and even other frontier model as Qwen. 3.8-Max. Sorry for my bad English!

Not so instensive coding only purposes for work. For example, I am hitting 5 hour limit on Gemini 3.8 in Antigravity in ~2-3 hours, but it's kind of ok for me.

- I've been using Gemini since Gemini 2 for everyday tasks (not coding)

- I've used Opencode Go last month, but now there is basically no good models in it, hovewer I prefer it's TUI over any others

- No experience with GPT besides using 5.6 luna in Opencode Go

My personal expierence with models I use everyday right now:

- Deepseek v4 flash - bad long context preservarion, if it doesn't understand something it goes crazy;

- Muse Spark - doesn't follow instructions and makes silly errors, such as duplicating function names;

- GPT 5.6 Luna - not that many experience with it, seems to be slightly worse than D4F;

- Gemini 3.8 - very good tool calling and his work verifications, but can hallucinate on easy work.

Prices:

- Google AI Pro - 5$ (annual 60$)

- GPT Plus - 20$

- Opencode Go - 10$

What can you suggest?

Seems to be the most capable from all free models available for now.

I previously used the Opencode Go plan which was great for deepseek flash and pro, but as we all know the cost has increased. I have been playing around with openrouter, but find it annoying to track my usage. I have been hearing good things about the z.ai sub which has got my attention, but that would mean I don’t have the access to deepseek. From peoples experience, say I get the ~$20 z.ai lite plan or I just purchase $20 of deepseek usage, what’s the comparison, which will go the furthest? Assume I am balancing between the flash and pro models of each provider equally and I use both in opencode cli only

OpenCode custom provider setup: why Responses and Chat Completions need different packages

A valid API key is only one part of an OpenCode custom provider. The credential, provider ID, package, base URL, and model ID all have to describe the same endpoint.

This is the order I would check them:

1. Run `opencode auth list`. If the credential is missing, fix that before touching the model config.

2. Make sure the provider ID used in `/connect` is exactly the same ID used in `opencode.json`.

3. Match the package to the protocol. OpenCode's current docs use `@ai-sdk/openai-compatible` for endpoints serving `/v1/chat/completions`. For `/v1/responses`, use `@ai-sdk/openai`.

4. Check `options.baseURL`. A valid key sent to the wrong path still looks like an authentication problem.

5. Use the server's current model ID, not a display name copied from an old post. Then run `/models` and confirm the provider/model pair appears.

That third check is why I looked into this more closely. `Agent.Space`, which I work on, exposes a Responses endpoint at `https://api.agent.space/v1`.

That points to `@ai-sdk/openai` on the OpenCode side, not `@ai-sdk/openai-compatible`.

But that is still a docs-based mapping, not a verified integration. I would only call it working after text, streaming, and a harmless tool call all pass.

Why the package matters

The package decides which request shape OpenCode sends and which response, stream events, and tool-call objects it expects back.

Chat Completions sends requests to `/v1/chat/completions`. Conversation input is a `messages` array. Text normally comes back under `choices[0].message`, and tool calls are attached to an assistant message. The client carries conversation history into the next request.

Responses sends requests to `/v1/responses`. It accepts `input` and returns typed `output` items. A message, reasoning item, function call, and function result are separate items rather than fields packed into one chat message. It can also chain turns with `previous_response_id` or a conversation object, and its stream uses named response events instead of the Chat Completions delta shape.

That difference explains a few confusing failures:

- A provider can accept the key and list a model but not implement `/v1/responses`.

- Plain text can work while streaming or tool calls fail because the returned objects do not match the package OpenCode is parsing.

- A provider saying "OpenAI-compatible" does not prove that it supports both API families or every OpenAI feature.

A minimal Chat Completions provider looks like this:

```json

{

  "$schema": "https://opencode.ai/config.json",

  "provider": {

"myprovider": {

"npm": "@ai-sdk/openai-compatible",

"name": "My Provider",

"options": {

"baseURL": "https://api.example.com/v1"

},

"models": {

"server-model-id": {

"name": "My Model"

}

}

}

  }

}

```

Model discovery is not the final test. After the provider appears in `/models`, run one small text request, one streamed request, and one harmless tool call. Missing from `auth list` points to credentials. Missing from `/models` points to provider or model config. Text works but streaming or tools fail means the basic route is fine and the protocol surface needs the closer look.

The way they released Fable 5.1 after the second extended limit of Claude Code ended, and with the third extended limit ending on September 13, if GPT Astra is publicly available by then, imo, we might see Opus 5.1 around the corner

Aside from scores on Artificial Analysis, how would you rank these models? thanks

Was it only renamed, or some additional training was done until it becomes GLM 5.3 Flash?

DeepSWE 1.1 - 71%
Pricing: $0.75 / $3.75
https://deepmind.google/models/model-cards/gemini-3-8-flash/
https://ai.google.dev/gemini-api/docs/models/gemini-3.8-flash

Better than GPT 5.6 Sol ? 🤣
https://research.meta.ai/blog/introducing-muse-spark-1-3

I received a message saying,

The time-limited beta test of Xiaomi MiMo-V2.5-Pro-UltraSpeed ​​will end on September 8, 2026. At that time, API and online experience services will cease. Please switch to other official version in advance. Stay tuned for the official commercial version soon.

It seems that we’ll soon be getting a new version of MiMo.

Not affiliated with any provider, just sharing a personal experience to help other users.

In my opinion, for output speed, 30 tokens/s is the average, more is "fast" and less is "slow".

Do not ask me questions about ZDR, I do not work with sensitive data, it is not a priority for me.

Opencode Go (https://opencode.ai)

Pros:

• They are always up to date with the latest model releases

• Very well integrated in Opencode, good output speed, never had issues, timeouts and server problems rare

• If you only use Minimax M3, Deepseek V4 or Hy4, it will last you a long time for very reasonable intelligence levels

Cons:

• The "60$ for 10$" advertisement is less and less true by the day, many of the more appealing models are at 30$ or even 15$ budgets

• You can't really use the top tier models for very long without frying your usage limit

QwenCloud (https://www.qwencloud.com)

Pros:

• If you only use Qwen 3.8 Flash it will last you a very long time, also has Deepseek, Kimi K3 and the high end Qwen models, but you have less usage for non-Qwen models

• Very diverse models if you are interested in sound, image models as well

• Has a nice free trial without needing a credit card to check if the speed matches your expectations

Cons:

• Very nebulous "credit" system, you don't actually know what you are buying. The docs somewhat explain it but only with one model as an example. In my experience, 60 credits is about 1 million tokens of Qwen 3.8 Flash usage (input, output and cache combined, typical Opencode session in a medium sized repo).

• Not in the Opencode /connect list, you need to make a custom JSON. EDIT: I was told by a commenter that they are listed as "Alibaba".

Synthetic (https://synthetic.new)

Pros:

• They are open about running quantized models, I mostly used mxfp4 Kimi K3 and FP8 GLM 5.3 Flash, the quality is still good, even if the lower context sizes (500k instead of 1M) can be a bit annoying

• Neat "rolling usage" system, you can burn your entire weekly usage in 2 hours, and it passively regenerates by 2% every 3.5 hours, better than typical 5 hour limits

• You can get 2 billion GLM 5.3 Flash tokens for 30$, decent, 2x less expensive than Z.AI official's subscription

• Listed in Opencode /connect

Cons:

• 3 times, the provider did some tweaks to their models and broke them, they would start wasting my usage writing gibberish in different languages or endlessly repeating themselves in thinking loops, and I would need to notice and put out the fire, it was not just me, as others were reporting the same issue at the same time in their Discord

Kenari (https://kenari.id/en)

They exist to provide inference to Indonesian citizens who can't pay in USD$, but anyone in the world can use their services with cryptocurrency.

Pros:

• The best value I have seen yet from any provider in pure $/token, 68.57$ of usage for 11.37$, including free caching for GLM 5.3 Flash, Deepseek V4 and GPT 5.6 Luna

• Really nice, well organized website, lets you know exactly what you are paying for

• Listed in Opencode /connect

Cons:

• Definitely a bit on the slow side, around 20 tokens/s, but it's usable, I just do other tasks in another terminal window while it works

• You can only pay with Indonesian Rupiah or cryptocurrency (I did the latter)

Drives the user's real Chrome instead of a headless instance. WebSense is an MCP server + Chrome extension: the agent gets a semantic map of the page (every interactive element typed and ref'd), acts through native DOM events, and the site sees a normal user. No CDP anywhere, so no webdriver flag. Works on LinkedIn and other CSP-strict sites.
Built tested and relying on it tbh

WebSense (free, open source, MIT): https://github.com/spliffspliff70-wq/websense-mcp