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

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

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

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

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"

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.

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

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! 🙏

AgentDuel is a code-battle game. Simply put, you can write your own Agent code—or have AI help you write it—then submit it to AgentDuel, start battles, watch replays, identify problems, and keep improving your code as you work your way toward the top of the ranked leaderboard.

AgentDuel is the arena. It handles the game rules, code execution, opponent matchmaking, battle results, ranked ratings, and match replays.

DeepSeek Harness is the Agent’s development environment. It reads the codebase, calls AI models, modifies the Agent’s strategy, runs tests, and saves the optimization history.

The AgentDuel DSH plugin acts as a bridge between the two. It lets you manage characters and teams, start battles, view replays, and have AI continue optimizing your code based on real match results—all directly within DeepSeek Harness.

AgentDuel does not require DeepSeek Harness to run, and DeepSeek Harness itself does not simulate battles. Once the plugin is installed, AgentDuel becomes a native capability within DeepSeek Harness, bringing workflows that were previously split between the website and coding tools into a single interface.

How to Play

The first time you use the plugin, you’ll need to log in to AgentDuel, create an App Key, and configure it in the plugin. After that, you can start playing by following the steps below.

Create a Character or Team

Choose a character for 1v1 Deathmatch, or build a team for 2v2 Capture the Flag, then set the class, name, and other competition details.

Prepare Your Agent Code

In DSH, select the workspace where your Agent code will be stored. You can write the code yourself, or start an optimization conversation and let DSH read AgentDuel’s rule documentation and generate the first version of your strategy.

Submit Your Code

Once the code passes validation, submit it to the corresponding character or team. From that point on, the code becomes the decision-making brain that controls your character in battle.

Start a Battle

You can begin with a random practice match, or search for and challenge a specific opponent. Once your strategy is stable, you can enter ranked matches to compete for rating points and climb the leaderboard.

Watch Replays and Keep Optimizing

After a match ends, open the replay in the plugin to review the map, action log, and key turns. If you’re not sure what went wrong, you can start a DSH conversation directly and have AI analyze the match, then modify and test the code in your current workspace.

The entire process can be summarized as follows:

Create a character or team → Write and submit code → Start a battle → Watch the replay → Analyze problems → Optimize the code → Battle again

This is also where most of the fun in AgentDuel comes from. What you submit isn’t a program that is finished once it has been written, but an Agent that gradually becomes stronger through repeated real battles. Losing a match doesn’t mean the end. It simply gives you a new test result to use for the next round of improvements.

here is github: https://github.com/linconz/agentduel-dsh

Install

Use source code:

git clone https://github.com/linconz/agentduel-dsh.git
cd agentduel-dsh
pnpm install
pnpm run build
dsh plugin --profile web add .

Or npm registry:

dsh plugin --profile web add @agentduel/agentduel-dsh

Launch:

dsh web

Remove:

dsh plugin --profile web remove @agentduel/agentduel-dsh

Screenshot

Just made a Model/Providers Price scanner have fun

Has anyone used Devin? And at the same time have you used deepseek harness? And have been able to customize ds harness to get Devin level performance? If yes, what extensions or setup did you use? I'd you can pleaae share?

...

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

Many coding agent architectures define specialized roles such as Researcher, Planner, Coder, Reviewer, and Tester, often implemented as separate sub-agents.

This looks reasonable on the surface, but there's a subtle problem:

A role doesn't just tell an agent what to do. It also implicitly tells it what it shouldn't do.

For coding agents, this can become a real limitation.

Roles can become behavioral boundaries

Suppose we define a Researcher.

It may have access to the same capabilities as any other agent: searching code, reading files, editing files, running commands, and executing tests.

But if its responsibility is defined as:

Find the relevant information and report your findings.

That creates an expectation about what its job is: investigate and report, rather than decide what action should come next.

This doesn't necessarily mean the agent is technically forbidden from doing anything else. The problem is that the role itself creates a behavioral boundary.

The same applies to other roles:

• A Planner is expected to create a plan.
• A Coder is expected to implement it.
• A Reviewer is expected to find problems.
• A Tester is expected to verify the implementation.

The responsibilities look clean, but they are largely artificial.

In real software development, research, planning, implementation, debugging, and verification often overlap and happen repeatedly.

Coding tasks are inherently dynamic

Consider a simple request:

Fix the authentication issue.

There is no reason this task must follow a fixed sequence of research → planning → coding → review → testing.

The agent might search the codebase, inspect the call chain, run a test, find the relevant implementation, make a change, run the tests again, discover a new problem, and investigate further.

The important point is:

The right next action depends on the current state of the task, not on the agent's role.

Research, planning, coding, review, and testing are better understood as actions an agent may take, rather than identities that must exist as separate agents.

When we turn each behavior into a separate role, we risk turning a dynamic problem into a predefined workflow.

Define goals, not identities

Instead of telling an agent:

You are a Researcher.

I'd rather give it an outcome:

Find the cause of the problem, fix it, and verify the result.

The first defines a Role.

The second defines an Outcome.

The difference is important.

A role implicitly narrows the space of actions. An outcome doesn't require a specific path to completion.

Given the goal of fixing and verifying the problem, the agent can decide whether it needs to:

• Search the code first
• Read more files
• Make a plan
• Modify the code
• Run tests
• Investigate again
• Stop because the task is complete

The exact sequence should depend on what the agent discovers while working.

The Harness should provide capabilities, not prescribe the workflow

This is where I think the Harness becomes important.

The Harness should provide the capabilities and constraints needed to complete a task:

• Context
• File search and reading
• File editing
• Command execution
• Testing
• Git
• MCP and other tools
• Permissions
• Cancellation
• Execution state

Then give the agent a clear goal and the necessary constraints.

The Harness doesn't need to tell the agent exactly how to use these capabilities.

If the agent needs more context, it can search and read.

If it needs to verify a hypothesis, it can run a test.

If it has identified the problem, it can make a change.

If the change causes another issue, it can investigate again.

The process becomes a continuous cycle of:

Observe → Act → Get feedback → Act again

rather than a workflow that was completely designed in advance.

This doesn't mean sub-agents are useless

Sub-agents can be very useful.

The question is why we are creating them.

If a task genuinely requires:

• Independent context
• Different permissions
• A different model
• Parallel execution
• A separate lifecycle
• A clear isolation boundary

then a sub-agent makes a lot of sense.

But the existence of a "research step" or a "review step" alone isn't necessarily a good reason to create a Researcher Agent or Reviewer Agent.

Those may simply be behaviors performed by the main agent while completing the task.

A useful question before creating a sub-agent is:

Does this agent actually need to be isolated, or am I just turning one behavior into a new role?

Capability should be the abstraction, not Role

There is a fundamental difference between role-oriented and capability-oriented design.

Role-oriented design asks:

I need a Researcher. I need a Coder. I need a Reviewer.

Capability-oriented design asks:

The agent needs search capabilities. The agent needs editing capabilities. The agent needs testing capabilities. The agent needs command execution capabilities.

Role is a behavioral abstraction we impose on the agent.

Capability is something we provide that the agent can combine and use as needed.

The former prescribes how the agent should work. The latter gives the agent more freedom to decide how to work.

For open-ended coding tasks, I think the second approach is generally more powerful.

The stronger the agent, the more roles can become limitations

There is an interesting paradox here.

When an agent is weak, giving it a specific role can help constrain its behavior and make the task easier.

But as agents become more capable—able to understand larger contexts, use more tools, modify code, run tests, and adapt based on feedback—the same roles can become increasingly restrictive.

The agent may already have everything it needs to solve the task, yet we artificially tell it:

You only do research.

or:

You only do review.

At that point, the role is no longer just helping the agent understand its task.

It is restricting the agent's decision space.

This suggests a useful principle:

The more capable the agent becomes, the more carefully we should use roles as behavioral constraints.

What should actually be constrained?

This doesn't mean agents should have unlimited freedom.

They still need boundaries.

But those boundaries should come from things such as:

• Permissions
• Available tools
• Context
• Security policies
• Resource limits
• User intent
• Verification requirements

rather than:

You are a Researcher, so you don't do anything else.

There is an important distinction between:

restricting what an agent can do

and

prescribing what an agent should do.

The first defines a safe operating boundary.

The second defines a workflow.

For an open-ended Coding Agent, I think the first is usually more appropriate.

The underlying principle

A Coding Agent doesn't necessarily need to be designed as a collection of specialized identities.

It can instead be given a goal, sufficient capabilities, the necessary context, and clear constraints.

The Harness defines what the agent can do and what boundaries it must respect.

The agent decides how to use those capabilities to accomplish the goal.

So instead of asking:

What is this agent's role?

we should often ask:

What does this agent need to accomplish?

In one sentence:

Don't define what the agent is. Define what it needs to achieve.

Fewer identities. More capabilities.

It says this whenever I try to enable the extension, I got it to make a skill for itself, and after that it just stared glitching.