
A folkfox special report.
DeepSeek Harness super agent:
who remembers what?
The DeepSeek Harness super agent design pairs a persistent router with isolated workers that can respond while tasks run. What DeepSeek proposed, what its prototype implements and what its synthetic test can tell us.
By the folkfox newsroom. Illustrations are conceptual.

01
One agent, many threads
DeepSeek Harness has proposed a different way to organise an AI agent: a persistent coordinator that talks to people while separate workers handle tasks. The team's design article calls this a Super-agent. Its English text is a machine translation of a Chinese original, and the authors explicitly say it describes architecture ideas rather than a list of current Harness features.
The public dsh-superagent prototype is real code, released under the MIT licence. Its maintainers call it a research prototype, not an official DeepSeek product, and say it differs from both their internal system and the article. Some ideas in the article are not implemented in the public code. That distinction matters more than a dramatic launch headline.
The problem is familiar to anyone watching several coding agents: work can proceed in parallel, but somebody still has to remember which session knows what. DeepSeek's proposed answer is to make session management the system's job. It is an architectural proposal, not evidence that human oversight can be removed.


02
What is the DeepSeek super agent?
In the article, the proposed Super-agent has four intended properties: continuity across conversations, the ability to work on several tasks, action in response to events, and persistence through interruptions. The team describes an internal instance that helps with development, including issue reproduction and code reviews. Those examples are the team's account; folkfox has not observed or independently tested its internal system.
The public repository describes a more specific prototype: one GitHub repository, GitHub events and optional Feishu, with permitted requests converted into work items. Its README warns that the code is not production-ready and should be reviewed and adapted. It is not a general-purpose promise that any person can connect every app and safely leave it running.
A useful mental model is a small editorial desk. One person receives the requests and remembers the broader picture. Different reporters investigate separate stories. The editor sees the results and speaks for the desk. Whether the desk works depends on the quality of its notes and the boundaries around its tools.


03
DeepSeek super agent architecture: router and workers
The design divides responsibility into a long-lived router and isolated worker sessions. The router keeps the conversation coherent, routes tasks and tracks relationships between them. Each worker carries out a task with its own context and tools. In the article's design, the router is not supposed to do the substantive task itself, and workers report back through it.
The trade is between shared understanding and throughput. One session seeing everything can preserve context but interleave unrelated work and queue behind long operations. A fresh session for every event can work concurrently but lose the links between requests. The two-level structure aims to keep the coordination in one place while separating the detailed execution.
This is a design choice, not a newly discovered law of model behaviour. The authors acknowledge that the router itself could eventually be split or made multi-stage, at the cost of a harder shared-memory problem. The public prototype's architecture notes describe the particular code it ships, rather than guaranteeing every feature in the article.


04
Events, subscriptions and pass-through
A trigger can be a chat message, a code-review comment or a CI result. The article proposes filtering routine events with programmatic rules before asking a model whether to act. When a worker already owns a thread, a subscription can send later events directly to that worker rather than requiring a fresh router decision for every update.
The practical appeal is not that every incoming message becomes a job. It is that an existing job can receive relevant new context while irrelevant chatter is filtered. Misrouting remains a serious concern: a follow-up sent to the wrong task can corrupt the context or produce the wrong action.
The authors also describe a reference graph, or Chain of Recall, connecting threads and sessions so an agent can follow a useful lead. This is a retrieval design, not proof that the agent possesses a complete, correct long-term memory. The article itself says long-term memory and context boundaries remain open problems.


05
A conversation that does not wait
A conventional tool call can hold the foreground turn open until a long command returns. The proposed full-duplex design starts long work asynchronously and delivers the result as a later event, so the system can receive a new instruction while that work continues. The article says DeepSeek Harness implements an asynchronous task mechanism but that it is not enabled by default.
That creates an important product question: what happens when a person changes direction while a worker is still acting on the old instruction? A system needs an explicit way to connect the new instruction to the right task, cancel or amend work where appropriate, and show what has already happened. Asynchrony improves responsiveness; it does not remove the need for clear authority.
The underlying pattern is related to ReAct, research that interleaves model reasoning and actions. A scheduling architecture around that loop adds concurrency and state management, but it does not make the model's individual decisions automatically reliable.


06
DeepSeek super agent benchmark: what was measured
DeepSeek's preliminary test used about 300 synthetic messages per run, roughly 20 of them work requests. Each of four designs ran five times. Coding work was simulated by a tool that consumed time. That means the experiment tests scheduling and coordination under this setup; it does not show that the system wrote better code or solved a larger share of real bugs.
In the team's reported table, the Super-agent took 12.4 minutes at the median and 15.7 minutes at the 95th percentile. A single-session setup with a neutral delegation prompt took 20.4 and 29.5 minutes. With a delegation-first prompt, the single-session median was 13.8 minutes and p95 was 29.0. All figures are the authors' synthetic experiment, not an independent benchmark.
The comparison is informative because the single-session baseline's behaviour depended on its prompt and whether it delegated in those runs. Five runs and simulated work are not enough to generalise the results to a production team. The article itself calls the experiments indicative and says aspects of the setup could be more rigorous.
| Design | Median | 95th percentile | Cache-read tokens |
|---|---|---|---|
| Super-agent | 12.4 min | 15.7 min | 23.2 million |
| Super-agent without pass-through | 12.6 min | 15.5 min | 31.8 million |
| Single session, neutral prompt | 20.4 min | 29.5 min | 6.1 million |
| Single session, delegation prompt | 13.8 min | 29.0 min | 10.8 million |
Source: DeepSeek Harness design article. Work was simulated; results measure this scheduling setup, not coding quality.


07
The cost hidden beside the time
The same table reports 23.2 million cache-read tokens per run for Super-agent, compared with 6.1 million for the neutral single-session setup and 10.8 million for the delegation-first setup. Cache-read tokens are not total token usage and are not a bill. Their price depends on the provider, model and contract, but they show that the concurrency comparison has a resource side.
The variant without pass-through reported 31.8 million cache-read tokens, compared with 23.2 million with it. That is about 27% less when pass-through is used, or about 37% more without it, using the other direction as the baseline. The reported median and p95 completion times for the two variants were close. The authors present pass-through mainly as a way to reduce routing work in this workload, not as a demonstrated improvement in task quality.
The right comparison for a buyer is cost per accepted outcome, including retries and review. A team could value a shorter queue enough to spend more on cached context. Another might prefer a slower, simpler system. Neither conclusion follows from the token count alone.


08
Always online, and connected to what?
The proposed design separates the agent loop, durable session state and the execution environment. A cloud process could continue coordinating while a person's laptop sleeps, and a lightweight endpoint component could reconnect the agent to an existing machine when it is available. The article calls this bring your own machine.
There are familiar precedents. Anthropic's account of managed-agent infrastructure describes separating orchestration and session state from execution environments. The DeepSeek article points to a different use case: connecting machines people already use, including local environments that may be intermittently available. The two descriptions are related design ideas, not proof the products offer identical access or safeguards.
The article also proposes an independent watchdog to check both system health and whether work is making meaningful progress. A watchdog's judgement can itself be wrong. Its interventions need logs, constrained permissions and a way for people to inspect or reverse changes.


09
DeepSeek super agent security and permissions
The authors are unusually direct about the risk. An agent that reads public discussions, connects to machines and can use powerful tools has a larger attack surface. If untrusted text steers the agent into treating instructions as authority, a message or document can become a route to unwanted actions. The authors also flag the danger of credentials entering model context.
The public prototype's authorisation design describes allow lists, rules and mandates enforced by the host, with messages treated as inputs rather than permission changes. That is the documented design, not an independent security certification. Its execution documentation also states that workers run commands as the operator's operating-system user, which makes the account's own permissions consequential.
The AgentDojo research illustrates the wider prompt-injection problem for tool-using agents. It did not test this new prototype, and its results should not be presented as a measurement of it. Practical safeguards include least-privilege accounts, isolated workspaces, secrets kept out of model context, logs and human review before consequential changes.


10
What to do with the idea
For a team evaluating an agent router, start with a small set of real tasks and a narrow tool boundary. Define which events are allowed to start work, where task state lives, how follow-up instructions reach the right worker and when a person must approve an action. Test cancellation and recovery as carefully as successful completion.
Measure completion time, accepted outcomes, human review, failures and cost together. Compare a single-session baseline with a deliberately chosen delegation prompt, not just a weak default. Record which model, harness, permissions and workload were used so another team can understand the result.
DeepSeek's proposal is worth reading because it connects routing, event handling, memory and persistent execution into a coherent design. The public code is a research prototype and the timing data is synthetic. The opportunity is to test the architecture honestly, with safety boundaries that are as explicit as the workflow. For related work, see the folkfox pstack agent verification article, agent workflow test, agentic AI security, AI consultancy and newsroom.

Quick answers
What is the DeepSeek Harness super agent?
It is an architectural proposal for a persistent router and separate workers. A related public repository is a research prototype and does not implement every idea in the article.
Is dsh-superagent a finished product?
No. Its maintainers describe it as research code, not an official DeepSeek product or production-ready software.
Did the system prove it writes better code?
No. The reported preliminary experiment used simulated work and measured scheduling. It did not test real coding quality.
What are the security risks?
Untrusted input, connected devices, powerful execution permissions and credentials in model context all need safeguards. The authors identify these as open problems.
What did the timing experiment report?
For the synthetic workload, the authors reported a 12.4-minute median for the Super-agent and 20.4 minutes for a neutral single-session baseline. Each design ran five times.

