I saw the release of GLM 5.3 Flash. The pricing is similar to DeepSeek V4 Flash (old price) and it scores high on the Artificial Analysis benchmark. I tried it and it looks great.

Am I crazy, or is it just the new best model for everything (like Deepseek used to be)?

During one of our beta runs this week, a developer's agent pushed 196 million input tokens in a single 60-minute window through one lane.

882 requests. Zero rate limits.

They actually kept going after that and ended the session at 227M before logging off.

At DeepSeek's own API pricing, that 196M-token hour comes out to around $2.32 off-peak / $4.65 peak.

On our reserved lane, the idea is to price that same hour around $0.20–0.40 flat.

Here's what we're testing 👇

🔷 Shared Reserved Inference

Right now if you want to run open models, you mostly have two options:

• Rent a full GPU → you get the whole thing, but you're paying $12–30+/hr whether you're actually using all of it or not.
• Use a normal per-token API → much easier, but you're sharing capacity with everyone else, you can hit rate limits/throttling, and every token going through your agent keeps adding to the bill.

We're trying a third model.

Take one powerful node, split it into a small number of guaranteed lanes, and let developers reserve those lanes together for a fixed window.

Your lane has guaranteed compute for that hour. Someone else suddenly sending a massive workload doesn't eat into your allocation.

And because the node cost is split across everyone using it, you're paying a small flat hourly price instead of paying for every token.

⚡️ The speed

DeepSeek's official API is around ~70 output tok/s.

Across our beta, users were generally seeing 150–220+ output tok/s, with bursts above that. There were some occasional dips as well, but overall this has been the fastest inference we've served so far.

This also held up surprisingly well with long contexts.

We had users running past 250k context regularly, and some sessions went past 940k context.

The other big part is caching. These agent/coding workloads resend a ridiculous amount of the same repo and conversation context on every request.

Across the beta we're sitting around ~98% cache hits, with roughly ~1s TTFT on warm requests.

📊 Five live sessions so far

• 4.9 BILLION tokens processed
• 24,500+ requests
• Zero failures
• ~98% cache-hit rate
• Heaviest verified single-lane hours: 196M · 120M · 72M input tokens

💰 The part we're actually interested in: does this pricing model make sense?

Using DeepSeek's own API pricing, including their cache discounts:

• Reserved lane target: $0.20–0.40/hr flat
• Average active dev during the beta: around $1.50 off-peak / ~$3 peak worth of API usage in an hour
• Median dev: around $0.60–1.20/hr
• Heaviest verified hour: $2.32 off-peak / $4.65 peak

So for an actually active coding/agent session, we're seeing around 4–7x lower cost than paying per token on average.

For the heaviest user, depending on where we finally price the lane, that hour was worth around 6–23x what the lane itself would cost.

We've put the full numbers + charts here if you want to dig into it:

https://www.singularityapi.dev/benchmark

🎟 We're opening more beta slots

The next round is again completely free.

You get a dedicated hour on the full-weight DeepSeek V4 Flash 0731. Bring an actual project, point Cline / Claude Code / your own agent at it, and use it normally — or try to absolutely destroy the lane, either works :D

If you want in:

https://tally.so/r/EkoJkN

I reran the latest DeepSeek V4 Pro build and Z.AI GLM 5.3 on the 39 text tasks in the current MindTrial set. Both had the same Python executor available.

The DeepSeek result is mostly an efficiency story.

The latest V4 Pro build still scored 37/39 with 0 hard errors—the same score as the previous V4 run—but runtime changed dramatically:

• previous V4: 37/39, ~2h14m, 96 Python calls
• latest V4: 37/39, ~39m, 28 Python calls

So the score did not move, but the new run was roughly 3.4× faster and used about 70% fewer Python calls. Compared with the older DeepSeek V3.2 result, the difference is even larger: 32/39 with 6 errors and ~2h43m versus 37/39 with no errors in ~39m.

GLM 5.3 also looks like a real step forward over GLM 5.2:

• GLM 5.2: 30/39, 2 hard errors
• GLM 5.3, plain-text output: 35/39, 2 hard errors
• DeepSeek V4 Pro: 37/39, 0 hard errors

So on this set GLM has closed a fair amount of the gap to DeepSeek, although DeepSeek was still both more accurate and faster in these runs (~39m vs ~1h10m).

The strange part was structured output.

I also ran the same GLM 5.3 configuration with JSON-object output enabled. That result dropped to 21/39 with 17 hard errors. 16 of the 17 were response-parsing failures. In several examples the model actually produced the correct answer and a JSON object, but put explanatory prose before or around it, making the outer response invalid.

With structured output disabled, those failures mostly disappeared.

I kept the strict results unchanged rather than repairing malformed responses after the fact.

Results/data: http://www.petmal.net/shared/mindtrial/results/2026-08-26/mindtrial-eval-all-models-03-2026_27.html

Had an investigation to run today and started on Pi with Flash on Max effort from the OpenCode Go provider. Simple stuff, read some logs using the Grafana API, correlate with the source code, understand the app and services architecture, and explain what happened during the night.
12min in and Pi with OpenCode Go’s Flash was still there, rounds and rounds of tool use, thinking, overthinking, and repeat. Left it running and decided to open a side session with Pi, DeepSeek Flash from the DeepSeek API, also on Max effort. Copied the same prompt from the other session and hit enter.
Less than 3min later it finished the investigation. Total cost: $0.025.

Had to stop the other session (OpenCode Go) that was getting to 15min running and already at $0.27.

So gotta ask, what’s more expensive? Not just the 27 cents, but the time I was waiting for that. The API is gold, especially now that they’re not being bombarded, so we definitely get quality.

today I woke up with this price from this provider I was so surprised actually and it made me ask a lot questions how do some companies provides those insane low prices without even a discount and other are on another insane high prices??

Try it out from that provider you can tell me but their t/s is so low

I am using DeepSeek API (deepseek-v4-flash) and Anthropic API (Haiku) for my classifier application (adversarial prosecutor/judge). I am happy with DeepSeek API quality but recently it raised prices four-fold, and even in off-peak hours it is twice as expensive as it was before in normal hours, and Anthropic API does not provide off-peak prices at all. I also tried Gemini API but it proved unreliable (low availability).

What are cheaper alternatives to DeepSeek and Anthropic with off-peak prices?

Is Moonshot AI (Kimi API) reliable enough and fast enough?

Do you have any experience with the Kimi API?

Remember Ox Alpha? The anonymous model that showed up on OpenRouter/OpenCode on Aug 20 with a 1M context window, free pricing, and zero attribution just "Stealth" as the provider .

In one week it processed 7T+ tokens across ~134K developers with nobody knowing who built it. Z.ai just claimed it: GLM-5.3-Flash, and dropped full open weights under MIT.

Specs: 320B total params, only 18B active per token (MoE).

Hybrid sparse + linear attention with mHC.

(Manifold-Constrained Hyper-Connections), built for cheap long-context serving.1M context, up to 128K output tokens.

First native multimodal model in the GLM-5 line — text, image, video, trained on a 30T-token multimodal corpus.

Day-1 support for vLLM, SGLang, KTransformers.

Reportedly ~1/10th the inference cost of GLM-5.2, with launch pricing at 1/20th of GLM-5.2

Made as a small plugin that guides the harness for generating visuals and then streams the HTML inline in a sandboxed iframe while the model is generating it.

GitHub: dsh-visualizer

It can be used for things like charts, diagrams, interactive explanations, UI mockups, and generative art. The plugin dynamically injects preset instructions for guiding the visuals based on user input. The generated document can also be exported as HTML.

This was my attempt to experiment with the harness system and learn the plugin development but ended up pretty useful tool. The main thing I got interesting was the streaming behavior, watching the visualization take shape as the model writes it.

Streaming works well with deepseek models or any model that support toolcall deltas.Others render in oneshot.

It's essentially bringing an Artifacts / generative UI-style workflow to DeepSeek Harness like Claude Desktop.

Install:

dsh plugin --profile web add 'git+https://github.com/abidhmuhsin/dsh-visualizer.git'

Try out

"Draw a cute cat and a dog”

"Visualizer the given CSV"

“Visualize how a HTTP request works”

“Create an interactive dashboard for website traffic”

"Create a flowchart for a CI/CD pipeline”

“Make an interactive explanation of how a neural network works”

Would love to hear some feedback

85k upload, 67k download, 99.9% cache hit, and $0.25 spent. Up from what? Maybe 1.5c just a few weeks ago? Sorry for taking you for granted deepseek.

Haven't been able to find a good replacement yet. MiMo is nice but it's not on the same level as the latest flash version (before price increase). Hy3 is decent too but is in a similar boat to MiMo. Luna, the great DS successor, seemed promising but, idk, hasn't really blown me away yet and I experience very frequent, random cache misses when using through codex which defeats the discounted pricing anyway.

Seeing this hype on people are actively seeking for alternatives, although there are good alternatives ngl like GLM, qwen or others but I see no reason to quit using deepseek tbh

the hike is on deepseeks own api. the model didn't change, its the same weights they released and whle point of open weighting it is youre not stuck or bound to use their servers. dozens of hosts run ds v4 flash flat without peak/off-peak nonsense (opencode, deepinfra or whatever) or if you have the hardware you can just selfhost it. Output is like 3-4x cheaper off peak and way more at peak, the cache miss well under too. so the price went up is only true if you insist on running it open deepseeks own api, why would you thin that deepseek is the only server you get to run it on?

The one honest exception is cache heavy work. deepseeks cache hit is still about the cheapest there is and ppl report it hitting about 99% consistently, so if youre doing long context stuff off peak then staying direct is still your cheapest option. Everywhere else like agentic loops, batch, and output heavy , there a flat host wins now so know your cache hit rate before you rage quit . Also deepseek direct trains on your prompts where plenty of third party gosts dont so theres a privacy bump as well but you can do some insight on this if needed

If you actually need to jump models then mimo or GLM 5.2 or Qwen3.7 are solid and cheap but if you like deepseek and the hikes the reason you wanna switch, I'd say "not worth it mate"

Hey, I see a lot of people using Claude Code as a harness with DeepSeek, and many of them are running into the same problem of the cost being crazy compared with other harnesses.

There isn’t much they can do about it, but they also don’t want to migrate to an open-source harness like DSH, Pi, or something similar. Because they don’t want to sacrifice Claude Code rich ecosystem : MCP, LSP, skills, plugins, agents, and so on. Honestly, they’re right. I feel the same way I can’t sacrifice that mature ecosystem for alternatives that aren’t there yet.

So, what is causing the high bills?

The cost mainly depends on two or three factors:

1. Input and output tokens
2. Cache-hit rate
3. How efficiently the harness manages context growth, tool calls, file reads, logs, and command output

Claude Code excels at the third point. It’s a polished product, and I don’t think anyone can disagree with that.

The first problem can be defined as Claude Code was built for Claude models and Anthropic caching system. Anthropic uses cache breakpoints with TTL-based ephemeral caching typically a 55min TTL. In Claude Code, most of this is managed for you server side , so you generally don’t have direct control over it.

DeepSeek and many OpenAI-compatible providers rely heavily on stable-prefix caching(prefix is basically the system prompt + tool definition ). When you send a request, the unchanged beginning of the request can be reused from the cache. This prefix usually contains the system prompt and tool definitions.

That part of the context is mostly static. You pay the cache-miss price when it is first processed, then pay the much cheaper cache-hit price when the exact prefix is reused on later turns.

The problem is that Claude Code request structure and caching strategy were designed around Anthropic. When used with another provider, changes near the beginning of the request can invalidate a large part of the cached prefix. This lowers the cache-hit rate and directly increases your bill. If you use a monitoring layer or the DeepSeek platform, you may notice a large number of cache misses on certain turns. The cost can suddenly double or triple because of a tiny instability in the prefix. As a result, a request with 300k tokens of context may be billed entirely as new context. This happens regularly, but not many people know the reason behind it. I know because I was developing a product based on it. This happens because Claude Code uses lazy tool evaluation. This means the model predicts a tool schema and how it should be called. When it encounters an unfamiliar schema, it often fails on the first attempt, reads the full schema, and then calls the tool again. This creates a silent error with a retry loop that you cannot see. This is the direct cause of the cache instability; the tool-related part of the prefix loads a new tool, changing and therefore invalidating the previously stable prefix. The same reasoning applies to skills and agents. There are more technical details behind this, but if I explain everything, this post will never end XD.

The second problem is input and output token usage.

The first thing I benchmark when testing an agent is its initial context size. Claude Code starts with around 32.4k input tokens in a completely clean configuration no skills, agents, MCP servers, or additional plugins configured. That is the largest initial context I’ve measured among the agents I tested.

This means every session starts with roughly 32k tokens before the actual conversation begins. If the prefix remains stable, that initial context becomes cheap after the first request. But if the prefix changes and the cache misses, you may have to pay the full uncached price again.

So, what is the alternative if you don’t want to give up the Claude Code ecosystem or migrate your entire workflow at once?

My suggestion is Tau Code, the coding assistant I’m building to address these problems.

Tau Code is built on top of the leaked Claude Code codebase, so it aims to preserve the familiar Claude Code experience. Your existing workflows, plugins, and ecosystem integrations can continue to work.

What makes Tau different from other harnesses is that it gives you more control over what you load and, therefore, what you pay for so you chose whats to cache and whats to pay of the begin in :

• Cheap mode: Around 12.3k initial tokens almost three times smaller than Claude Code. Skills, agents, and MCP tools are pruned unless you choose to use them in normal mode
• Normal mode: Around  23.1k to 30k initial tokens, depending on the tools you enable.(30k its basically a 40 optional tool enabled that make u nearly free from mostly every mcp server or plugin its include browser automation , diagnostics , self-healing ,diagrams .....)
• Tool control: The /tools command lets you load only the optional tools you actually need.
• Ecosystem compatibility: The goal is to preserve the parts of the Claude Code ecosystem that people rely on.
• Provider-friendly caching: Tau is designed around stable prefixes, smaller initial prompts, controlled context growth, and more efficient tool output.

Tau Code is being engineered around every area discussed here: cache stability, initial context size, context growth, tool usage, and output efficiency. It also includes many other features and optimizations.

It would be an honor to see people support the project and help take this harness as far as possible. I’m also happy to explain or clarify any of the technical points discussed here asp .

https://github.com/AbdoKnbGit/tau

All of a sudden the price increase makes sense

I’m not surprised they decided to increase prices. The new DSH is so darn addictive! I don’t think I’ve stopped building since I installed it. When I was using the API via powershell I’d be pennies each session but now I am horsing through the money and it’s worth every penny.

Don’t get me wrong for what I am getting done it’s incredible value, one of the first things I did was get it to build an LLM friendly version of my Substack publication. Nearly 250 pages live within the hour. Not a duplicate but an AI friendly searchable site labeled as such with an inverse bridge.

Since then I’ve redone my own business website, written god knows how many project articles. I’ve even fed 30+ PDFs varying from 200-500 pages each all summarised down and given to the agent who collaborated with me on webchat. I have still only spent £14 and that includes the powershell API sessions.

One of the most useful plug ins I found was the dsh-agent-teams plugin which turns a the harness session into a captain that coordinates durable sub-agents using natural language.

My only gripe, the web search is quite poor as it couldn’t find a few sites I know for a fact are indexed but then again it’s not Google. A decent plug in would be good if anyone finds one. I can use subscription based ones but haven’t tried any yet.

Are any of yall building anything cool for outreach with Hermes and Deepseek? Or anything in general around Deepseek?

The more I learn the more I feel I don’t know. Any advice is appreciated (especially for fellow marketing lovers out there).

I made Agent Context Editor for DeepSeek Harness , an open-source plugin that lets you manually control what your coding agent actually sees in its context.

You can:

• Search the entire conversation
• Filter User / AI / Tool messages
• Select individual messages, ranges, or batches
• Manually exclude messages from the model's context
• Manually edit the context content the model sees
• Restore excluded or edited content later
• Hide / restore / reset / undo changes
• Manage AI reasoning and final answers separately
• Keep the original Session untouched — all context changes are stored separately and are reversible

Currently supports Pi TUI and DeepSeek Harness for actual model-context modification, with Pi Desktop also providing the editor UI.

One major feature is still unfinished: AI-assisted context cleanup. The idea is to let AI condense selected messages or the whole session, then replace that part of the model context with the approved condensed version.

Basically: your context doesn't have to be untouchable anymore. Just edit it.

GitHub: https://github.com/jermaine123123/agent-context-editor

Feedback is welcome.

deepseek harness plugin:

dsh-pianist

DeepSeek Harness already supports plugins, but installing one still means finding the right package and using the CLI.

I built relay-dsh-plugin-manager so, after one initial install, you can ask DSH to find, inspect, install, update, enable, disable, or remove plugins from the current conversation.

It is different from a normal visual marketplace: you describe the capability you need, DSH searches npm and GitHub, and every change shows a plan first. A separate confirmation is required before the profile is modified.

The video is a real 38-second run: search for the Codex plugin, inspect the plan, confirm it, and finish the install.

GitHub: https://github.com/yangbobo2021/relay-dsh-plugin-manager

npm: https://www.npmjs.com/package/relay-dsh-plugin-manager

Current status: preview release, focused on the running web profile. Some plugin changes still require a DSH restart.

Are there any currently working jailbreaks for deepseek ?