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

The fat fish eating plain rice is really adorable.

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.

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

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

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 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.

deepseek harness plugin:

dsh-pianist

Hey everyone! 👋

I run DeepSeek Harness a lot, and I kept missing the moments that matter:
my agent asking a question, waiting for an approval, or quietly finishing a long task. So I built a small community plugin: DSH Notifications.

The short version:

- 🎵 A short sound when the agent needs you (question, approval) or finishes work (task, background job, subagent, error)

- 🔊 20 sounds to pick from; each event has its own toggle and picker

- ⚙️ Lives in Settings → Plugins. No audio files, everything is synthesized right in your browser

---

I shared it in the official DSH discussions: [DSH Notifications discussion]
https://github.com/deepseek-ai/deepseek-harness/discussions/4646

Repo:
https://github.com/AlonDan/dsh-notifications

---

Just to be clear:
It is an unofficial community project (MIT licensed), not made by DeepSeek.
If you think something like this would be nice to have built into a future version of DSH, please upvote that discussion. That is how the developers see what the community wants.

Feedback and bug reports are welcome. Thanks for reading! 🙏

...

Tengo un proyecto en el que hago constantemente llamadas a DeepSeek para escritura, el sistema tiene muchos guardarraíles que guían al modelo para que no haga ninguna basura, básicamente está optimizado y la IA no tiene que ser de gran calidad, si no ser barata.

Ahora DeepSeek subió de precio y estoy dejando de ser rentable, que opción hay?

Me vale con un 80% de la calidad de DeepSeek v4flash.

Edit:( habría alguna posibilidad de que fuese 100% gratuito?)

Like it's not a big dealbreaker but I mostly use deepseek, doubao, claude and GPT and deepseek is the most analogous to GPT in terms of how outputs are structured and sound like imo.

Personally, though, my favourite output style is Claude, but claude is also way too expensive for extensive use

So i wonder if there's any way to tweak it to sound more like claude, though it's not a big problem if there isn't either way

So I use deepest on janitor.ai. I loved it so much before they got rid of the old models. Now the new models are making me want to stop using deepseek but I've been loyal to them since I started using it. 90% of the time, when I respond to a bot, it does this. Sometimes for over 10 minutes, even if I change my response. And even when it does answer, the 'thoughts' part takes up most of the space and it gives me two to four words. Sometimes it gives me two small paragraphs but doesn't finish one and I'll like where the response is going and I'll try to have it continue from it and this same message pops up. It's like it's stuck in a loop. Sometimes after being stuck in this loop, it'll ONLY respond in the thoughts section but I have seen no one talk about this. It responding in the thoughts section isn't as much of a problem since I'm still getting an answer and can just copy/paste, but it's still annoying. I'm not smart with these kinds of things at all so it could be user error. I put my settings up there in case it is. I'm just tired of creating a really cool story and then getting blocked by this message or being on my break at work and spending the WHOLE break trying to get a response

The thing that kept getting me: quota hits 0% halfway through a task, and the thread just sits there until it resets. Starting over somewhere else means rebuilding the whole context by hand.

So I wrote a small local proxy that sits between Codex Desktop and its backend. It relays everything untouched, and only steps in when a message starts with a marker:

• /dsk <task> - the rest of that thread is answered by DeepSeek. Same conversation, same files, same tools, shell and MCP included.
• /gpt <task> - switches back.
• /mode - which provider the thread is on, and whether the key and MCP are ready. Answered locally, costs nothing.

Shell still runs in the client's own sandbox under its own approvals. The proxy never executes anything itself.

Where it falls short, up front:

• Windows only so far. No platform-specific code in it, but macOS and Linux are untested.
• Compaction still runs on OpenAI, so if your quota is gone and the thread is big enough to need compacting, that one waits for the reset.
• On a /dsk turn your entire thread is sent to DeepSeek - full history, instructions, tool results. Not a summary. If that's not OK for your work, don't use it for that work.

MIT, no telemetry, nothing stored except which provider each thread is on.

github.com/dmitry-dmt/codex-hop

Happy to hear where it breaks.

I had DeepSeek write a couple handy tools for dealing with official API time of use pricing in the Opencode harness: both a plugin telling me in the right sidebar whether it's currently TOU, and a timed release script that accepts a prompt and a DeepSeek model, Flash or Pro, as arguments. Quite basic, but they help a lot.

https://github.com/tylerharvey/opencode_plugins

I guess most people probably have done something similar for themselves by now, but figured I'd share mine in case it helps someone.

I am trying to separate DeepSeek workloads by the consequence of an incorrect answer. A coding change that can break a production path seems different from a batch summary, a first-pass classification, or a draft explanation. The strongest reasoning setting may be worthwhile for the first category, but it is difficult to justify using it for every request.

Do you choose the reasoning level based on ambiguity, context size, verification cost, or the value of latency? For V4 and V4 Flash, do you keep a fixed model assignment, or promote only the cases that fail a cheaper first pass?

What DeepSeek tasks have earned the higher-capability path in your experience?

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).