r/DeepSeekHarness

Hey folks 👋

We just open sourced TrueForge, our vendor-neutral agent harness for building general-purpose agents.

It handles the runtime pieces that get painful quickly : context management, tool/MCP execution, subagents, sandboxing, approvals, persistent state, and more.

We also benchmarked the harness itself. With the same Opus 4.8 model, TrueForge delivered a similar solve rate at ~30% lower cost than Claude Managed Agents. Switching to an open model pushed that to ~75% lower cost on the same benchmark.

Would love feedback from people building agents.

⭐ Star the repo: https://github.com/truefoundry/trueforge

📖 Read the launch article: https://x.com/truefoundry/status/2090081376330715176

i just asked the v4 flash 0731 from both api and opencode go both think themselves as a anthropic's claude model ....

Which they previously complain about .

i am a openmodels big fan but it is real and i tested on deepseek minimal harness since there are no tools to get the model name from environment it thought and told me ...

It may due to post training since its possible to use a deepseek model inside claude code by changing env variables ...

therefore it think itself as a claude model after the post training , what do you guys think about that ?

Hello! Since DeepSeek Harness doesn't have an official mobile app yet, I decided to create my own Mobile Client because I like to be able to code from anywhere at any moment.

I created DSH Mobile, a lightweight mobile client to easily add your Harness server(s) (via Tailscale, LAN, or HTTPS) and connect in one tap. I mainly made this for my own use, but figured I'd open source it in case anyone else finds it useful.

Also, I saw earlier that someone else posted a mobile app. We took two completely different approaches but mine was already finished so I'm sharing it anyway :)

Links :

Github

Standalone Android APK

(I didn't test ios)

Why I built this

Codex ships the feature in twenty minutes. I'm still the one who reviews it, debugs it at 11pm, and explains it in front of people. That gap is the uncomfortable part of this era for me: the bottleneck quietly moved from "how fast can we build" to "how fast can we genuinely learn." We got a 10x tool for building. I wanted one for understanding.

So I built Engram. An engram is the physical trace a memory leaves in your brain, which is literally what this thing is supposed to produce.

Full honesty up front: this started as a Claude Code plugin, and a post about it recently blew up on r/claudeskill. But learning infrastructure shouldn't be locked to one agent, so I made the repo omni-agent: same skills, same engine (they're the open SKILL.md standard, shared verbatim), now running natively on Codex, with more agentic platforms coming in the next few days.

How it works

Three skills: $learn, $review, $coach. Underneath is the boring learning science that actually replicates, and none of the fun stuff that doesn't:

- retrieval practice: it tests you constantly, because testing IS the treatment, not the measurement (Roediger & Karpicke 2006)
- real spaced repetition: FSRS, the same modern scheduler Anki uses, fitted to your own review history over time
- generation first: you predict or attempt before it explains. It won't just hand you the answer, unless you say "just tell me", in which case it complies and quietly books that concept for an earlier review, because told-not-derived decays faster
- every topic becomes a first-principles concept graph ("why must this be true given that"), never textbook chapter order
- threshold concepts get generated interactive HTML explorables, sliders and prediction gates, because some things you have to poke
- explicitly no "learning styles". That theory failed every controlled test. It adapts from your measured retention instead.

The design decision I'm happiest with: the tutor never grades you. A separate assessor agent grades your free recall blind, rubric in hand, without ever seeing the lesson, and writes a receipt to disk. In my first real session the tutor was convinced things went great; the assessor came back with 1 recalled, 4 partial, 1 lapsed. It was right. (It also once logged confidence scores I never actually stated, so "never invent the learner's confidence" is now a hard rule in the code. A system that pushes back on its own optimism turned out to be the whole point.)

One Codex-specific difference: Codex spawns subagents only when you name them, so you summon the examiner explicitly with $engram-assessor at the end of a session. It stays exactly as blind, it just doesn't appear uninvited.

Does it work

Same honest answer as the original post: the science underneath is some of the most replicated stuff in psychology, the plugin itself is still small-n, and my retention data is still cooking. What I can report is that I used it to learn transformer internals and derived about half the concepts myself before being shown anything, which never happens when I just read.

And the part I want you to hold me to: the Codex glue is the newest code in the repo. The skills and the stdlib-only Python engine are shared verbatim with the Claude Code version and selftested, but the plugin route hasn't seen many live Codex installs yet. If it misbehaves, "npx skills add nagisanzenin/engram" installs the skills directly and carries the whole loop, and an issue describing what you saw is worth gold to me.

Install

codex plugin marketplace add nagisanzenin/engram
codex plugin add engram@engram

Then $learn anything. It's not code-only: history, music theory, anatomy all work. $review takes 2-4 minutes of free recall when reviews come due (a session-start hook pings you, and stays silent otherwise). $coach shows retention stats and a local HTML dashboard. Everything is plain JSON on your machine, and the engine has zero network code. Set ENGRAM_HOME=~/.engram if you'd rather not host a .claude folder.

Needs python3, no pip installs, MIT licensed. Repo: https://github.com/nagisanzenin/engram

If you try it, tell me where it feels annoying. The failure mode of every learning tool ever made is that you stop showing up, so friction reports are worth more to me than praise.

Summary: It’s slow, uses way too many tokens, has a 99% cache hit rate, and gets the maximum performance out of Deepseek.

Performance: Deepseek v4 flash on harness high gave results similar to GPT 5.6-luna low with the same prompt. It was consistent across all my requests (refactoring a form creation system). It followed the patterns and fixed incorrect ones, with no security issues. However, the changes were more about the visual side than backend logic.

Usability: Very confusing. The skills in .agents don’t load automatically, and the documentation doesn’t explain skills in an intuitive way. By default, it’s in Chinese, and you have to click around everywhere to find the English option. The UI looks nice, but it would be better if the default were a CLI. The documentation isn’t clear on how to run it in CLI mode or if that’s even possible.

Strengths: It got the best possible performance out of Deepseek.

Weaknesses: Very slow and used too many tokens (I had to plan on Pi Harness first and then re-plan on Deepseek Harness, which saved about 20M tokens).

There’s a lot of room for improvement. I’ll test its viability and optimizations during the week. The plugin-based system seems like it could be optimized like Pi Harness, but there are so many plugins with no descriptions that it gets confusing.

What has your experience been like? (My context: Typescript + VueJS + QUASAR + HTML, daily use of Pi Harness)

Note: Message translated with Deepseek v4 flash

dsh-mini: the DeepSeek Harness core as a portable engine, running in Termux

Not a fork. I assembled the official DeepSeek Harness (@deepseek-ai/dsh-*) engine with pi's shell (@earendil-works/pi-tui) and cut everything else away:

• Packages: official tree 188 → 13 engine packages (build-time only)
• Install size: 359MB node_modules → one 7.6MB self-contained file
• Runtime npm deps: 0 — the artifact bundles everything
• Portable engine build: 419KB, zero Node builtins (runs on QuickJS too)

On a OnePlus 15 / Termux:

pkg install nodejs                    # only runtime requirement: Node >= 22.15
curl -fsSL https://github.com/LouisYang841/dsh-mini/raw/main/scripts/install.sh | sh
dsh-mini

You get a full-screen Claude-Code-style TUI (community @openguardrails/dsh-tui, promoted to default after real-terminal testing), DeepSeek by default (official adapter + pi-ai multi-provider route — OpenAI/Anthropic/OpenRouter light up when their env keys exist), fs + bash + todo + skills tools, and zstd-JSONL session persistence with --resume.

The bash tool drives the phone's real filesystem — I had it ls my Termux home and summarize the directory tree from the model's reply.

Architecture is deliberately seam-based (five seams: LLM adapter / filesystem / persistence / Node-API shims / engine polyfills) with a byte-identical conformance gate (Node vs QuickJS traces), an ADR log explaining why assembly instead of forking, and a ~50-entry pitfall skill file. If you want to retrofit the engine into another harness, the retrofit recipe is in ARCHITECTURE.md.

Repo: https://github.com/LouisYang841/dsh-mini Install: curl -fsSL https://github.com/LouisYang841/dsh-mini/raw/main/scripts/install.sh | sh

Solo project, MIT, happy to take feedback or issues.

Welcome to the official subreddit for DeepSeek Harness!

We’re thrilled to launch this community on August 13, 2026, to discuss, share, and build with DeepSeek's groundbreaking new agent framework. Whether you're a developer, researcher, or AI enthusiast, you've come to the right place.

What is DeepSeek Harness?

DeepSeek Harness (dsh) is an open-source agent harness developed by DeepSeek AI. Its goal is to transform DeepSeek's V4 series models into autonomous coding agents capable of complex, multi-step workflows and tool use.

The architecture is based on a powerful premise: everything is a plugin. This "plug-and-play" design, powered by the Cordis framework, allows developers to mix, match, and replace components like models, tools, sandboxes, and UIs with ease.

This framework squarely positions DeepSeek against tools like Anthropic’s Claude Code, offering a developer-friendly, MIT-licensed alternative.

🌟 Key Highlights

· Developer Preview: v0.1 is here and iterating rapidly. Expect frequent updates and some breaking changes as it evolves.
· "Everything is a Plugin": DeepSeek Harness is built with maximum flexibility in mind.
· Open-Source & Free: Released under the MIT License, allowing unrestricted use and modification.
· DeepSeek-V4-Pro Synergy: Officially launched alongside the V4-Pro model, which features massive Agent capability upgrades for production environments.
· Competitive Performance: The V4-Pro model benchmarks close to industry leaders like Claude Fable 5 on agentic tasks.

🔗 Essential Links

Get started with these resources:

· Official GitHub Repository: https://github.com/deepseek-ai/deepseek-harness
· DeepSeek Official Website: https://www.deepseek.com/en/
· API Documentation: Check the official DeepSeek API docs for setup and integration guides.

🚀 Quick Start Guide

Want to try it right now? Here’s how to launch the Web UI. You'll need Node.js installed.

Run instantly via npx:

```bash
npx @deepseek-ai/dsh web
```

This starts the Web UI at http://127.0.0.1:3080.

Run from source:

```bash
git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh web
```

📢 Community & Support

· Feedback & Bugs: Submit issues via GitHub Discussions or create a post here![citation:2]
· Plugin Ecosystem: Tag your plugin repos with dsh-plugin for better discoverability.
· Discord: Join the DeepSeek Harness Discord community (link available on GitHub).

---

Let's build the future of AI agents together!

Drop a comment below to introduce yourself, share your first impressions, or ask any questions. Don't forget to read the rules and enjoy your stay!