DeepSeek Harness Reaches 1.54 Million DAU and 35,000 Plugins: Agents Are Moving Toward Platformization

DeepSeek Harness Reaches 1.54 Million DAU and 35,000 Plugins: Agents Are Moving Toward Platformization

Author’s note: After open-sourcing, DeepSeek Harness quickly built up a user base and a third-party plugin ecosystem, and the official team has started work on a plugin marketplace and a developer support system. Agents are moving from standalone tools toward open platforms.

DeepSeek published a product update on Harness on November 5, 2026. As of November 4, counting users of the official DeepSeek API, DeepSeek Harness hit 1.54 million daily active users, consumed roughly 92 trillion tokens per day, and had about 35,000 third-party community plugins. Around 60% of those active users have installed or built at least one third-party plugin. Measured from the developer preview release on August 13, that scale was reached in under three months. Our core takeaway: Harness has outgrown its role as “a runtime for agents” — it’s starting to connect models, tools, plugin developers, and users. The official team owns the general-purpose infrastructure, third-party developers keep producing specialized features, and agents are heading toward platformization.

The rest of this piece runs in three parts. Part one walks through the growth curve and the measurement methodology behind the official numbers, and explains what 1.54 million DAU, 92 trillion tokens, and a 60% plugin participation rate each actually mean. Part two breaks down the “everything is a plugin” architecture and surveys the real plugins the community has already shipped. Part three separates the plugin distribution capabilities that already exist from the marketplace and incentive programs the official team is still preparing, then looks at what has to be solved before the ecosystem matures — and where developers and API service platforms can plug in.

deepseek-harness-1-54m-dau-35k-plugins-agent-platform-en-image-0


To Know: Key Terms for Understanding DeepSeek Harness Platformization

Term Explanation
AI Agent An AI system that can call tools and complete multi-step tasks in sequence
Harness The runtime framework that manages an Agent’s execution process, tools, context, and working environment
DAU Daily Active Users
Plugin An extension component that adds functionality to software and can be installed, enabled, and uninstalled independently
Cordis The composable plugin framework underlying DeepSeek Harness
CLI A way of interacting with a program through the command line; most coding Agents are provided as CLIs
Context All the information the model currently uses to understand and handle a task, including conversations, tool descriptions, and file contents
SDK A software development kit that helps developers call platform capabilities
Token Incentive A mechanism that rewards developers with model invocation credits and similar benefits
Plugin Index A plugin index that provides plugin names, authors, versions, compatibility ranges, and installation sources
Plugin Marketplace The official plugin marketplace currently in planning, used to discover, install, update, and distribute plugins
Indirect prompt injection An attack in which attackers hide malicious instructions in external content such as web pages and files to trick an Agent into executing them

1 How Fast Is DeepSeek Harness Growing

1.1 DeepSeek Harness Publishes Its User Base for the First Time

The facts: DeepSeek Harness v0.1 was released and open-sourced on August 13, 2026, under the MIT License. Within about a day of launch it passed 50,000 GitHub stars, and the desktop version arrived on September 29. As of November 15, the official repository showed roughly 281,100 stars and 34,700 forks, with the latest release being v0.2.2-rc.3, shipped on November 13.

Here are the officially disclosed daily-active numbers — note that the three data points don’t share the same measurement window:

Reporting date Figure Measurement basis
2026-09-30 271,000 DAU 7-day average
2026-10-07 429,000 DAU Figure disclosed by the company for that period
2026-11-04 1.54 million DAU Single-day figure
2026-11-04 ~92 trillion tokens Single-day consumption
Early November 2026 ~35,000 Number of third-party plugins
Early November 2026 ~60% Share of active users who have installed or built at least one third-party plugin

The company explicitly states that the 1.54 million DAU and 92 trillion tokens are scoped to users of the official DeepSeek API. The 271,000 figure is a 7-day average while 1.54 million is a single-day value, so the two are fine for reading a trend but not for calculating an exact growth rate — the basis isn’t consistent. All of these numbers are self-reported by the company; there’s no third-party audit in the public record.

deepseek-harness-1-54m-dau-35k-plugins-agent-platform-en-image-1

1.2 What 1.54 Million DAU and 92 Trillion Tokens Say About Agent Usage

The analysis: Agents and single-turn chat have very different usage structures. An agent task typically involves a loop of planning, calling tools, reading results, and reasoning again — one task triggers multiple model calls, and each call carries tool descriptions, prior steps, and file contents. That’s why the ratio of tokens to daily active users runs far higher than in an ordinary chat product.

The 92 trillion tokens reflect the overall execution intensity of the Harness user base. The single-day total combines long tasks, short tasks, and every model tier; the materials don’t break down the user distribution or the billing split. So this number is good for describing the scale of usage, but it’s not a basis for estimating platform revenue or the typical cost per user.

1.3 35,000 Plugins and 60% Plugin Participation

The 35,000 third-party plugins show that developers have already extended the product heavily around their own needs. The roughly 60% participation rate shows plugins are now mainstream among active users — people commonly install capabilities beyond what ships by default.

One nuance worth getting right: that 60% combines “installed” and “built.” It measures how deeply plugin capabilities have penetrated, and the users who actually build plugins are only a subset of that — the company hasn’t published the specific share.


2 Everything Is a Plugin: How DeepSeek Harness’s Open Architecture Works

2.1 Models, Tools, Memory, and Interface Are All Replaceable in Harness

Traditional Agent products usually have the vendor predetermine which model to use, which tools to provide, and how to manage memory and context. The core design of DeepSeek Harness is Everything is a Plugin: model adapters, tools, Skills, storage, session management, and other runtime modules are split into composable plugins, while interface and interaction capabilities can also be extended through plugins.

The official plugin development approach uses TypeScript. A basic plugin includes a plugin name, an apply function, a context object ctx, and dependency declarations inject. Developers register tools, event listeners, and other services through ctx; when a plugin is unloaded, the framework automatically cleans up the events, tools, and timers registered through the context. Additional resources can be managed with ctx.effect().

This mechanism is based on Cordis. A related paper was submitted to arXiv on August 26, 2026, and proposes two capabilities:

  • Temporal composability: When a component is removed, its side effects can be undone.
  • Spatial composability: Components declare dependencies and are dynamically activated or deactivated as the context changes.

With reversible side effects, reactive dependencies, and hot module replacement, plugins can be installed, deactivated, and hot-reloaded while Harness is running. This is the engineering prerequisite that makes large-scale third-party extensions possible.

deepseek-harness-1-54m-dau-35k-plugins-agent-platform-en-image-2

2.2 Open Architecture Lets Harness Handle Different Scenarios

Analysis: Pluginization turns “building an Agent platform” into “adding a capability to an existing platform.” Developers don’t need to implement the execution loop, session management, or interface from scratch—they only need to focus on the part of the workflow they know well. Users can then combine plugins based on the task, turning a general-purpose Agent into a dedicated workbench.

Harness also has a built-in creation mode: users can describe their needs in natural language and let the Agent create and configure plugins on its own. In an August hands-on test by The Paper, testers asked Harness to create an article fact-checking Agent. It took about 11 minutes, and the Agent could afterward be invoked as an independent preset. This further lowers the barrier to plugin creation, which also helps explain how the 60% participation rate came about.


3 Real Plugins the DeepSeek Harness Community Has Already Built

The cases below come from the official community progress article and project-author materials, and all are community-maintained projects.

Plugin Author Scenario Core capabilities
dsh-media-desk Community Social media content creation Ideas, scripts, covers, and shot lists unified in one workspace
dsh-guizang-design Community Design and layout Article-to-webpage, image-and-text cards, cover generation, reuse of work and styles
dsh-context Community Context insights Shows which context the Agent used and how it changed
dsh-aio-agent cocofhu Unified entry point for multiple coding Agents Connects Cursor, Claude Code, Codex, OpenCode, CodeBuddy, and Kimi Code
dsh-ltm tr1v3r Long-term memory SQLite local storage, CJK search, per-project recall, deduplication and merging
TheOne YunongDai2005 Cross-topic session management Automatically detects topics and routes to the matching session and project workspace
agentero-dsh Community Research reading Paper reading, highlighting, translation, notes, AI-assisted research

3.1 Content Creation and Design Plugins

dsh-media-desk strings ideas, scripts, covers, and shot lists into a single content production line, so a creator can go from topic selection to finished-asset prep inside the same Agent workspace. dsh-guizang-design bundles design and copy-polishing Skills into a plugin, supporting article-to-webpage conversion, image-and-text cards, and cover generation, and it can save finished work and reuse design styles. What the two share is that they pull steps once scattered across multiple tools into one continuous workflow.

3.2 dsh-aio-agent: Multiple Coding Agents in the Same Harness Workspace

dsh-aio-agent plugs the command-line programs of coding Agents such as Cursor, Claude Code, Codex, OpenCode, CodeBuddy, and Kimi Code into Harness as selectable session modes. The plugin calls the CLIs actually installed on the machine, and each tool keeps its own model and conversation context.

What matters about this case is that Harness can act as a unified interaction layer for multiple Agents. Users switch between coding tools in a single interface instead of bouncing back and forth between terminals, and Harness’s role shifts from “an Agent” to “a workbench for Agents.”

3.3 Long-Term Memory and Cross-Project Management

dsh-ltm gives long-running Agents local, structured memory. It stores data in SQLite, supports search in Chinese and other CJK languages, recalls by project scope, and provides duplicate detection, editing, merging, staleness review, and migration. Retrieval is based on BM25 and character n-grams with no hard dependency on external embedding services, so deployment costs stay low.

TheOne solves a different problem: when users are pushing forward several long-running projects at once — work, coding, research — sessions easily get mixed together. It provides a single chat entry point where the model judges what a message is about, then routes it to the corresponding standalone session organized as a project workspace, with support for correcting and undoing misrouting. In the official GitHub Discussions, the author notes that TheOne is an independently maintained community plugin.

3.4 agentero-dsh: Research and Specialized Workflows

agentero-dsh combines literature management with an Agent, supporting paper reading, highlighting, translation, notes, and AI-assisted research. Plugins like this show that deep, domain-specific needs are being filled in by developers who know the field — the official platform doesn’t have to cover every one of them itself.

4 DeepSeek Harness: From a Plugin Collection to a Developer Platform

4.1 How Harness plugins are published, discovered, and installed

Implemented capabilities: Plugins can be distributed via npm packages or Git repositories, and the official recommendation is to add the dsh-plugin Topic to GitHub plugin repositories to improve discoverability. Harness already supports a plugin index that provides the name, description, author, version list, category tags, compatible versions, installation source, and update status. Users can search and filter, and the system recommends stable versions compatible with the current Harness by default; when compatibility conditions allow, historical versions can also be selected.

The official documentation also explains the scope of index verification: information such as the title, author, and description is provided by the index maintainer, and Harness only checks the file format. During installation, the package, Git repository, and version source are displayed for the user to confirm. So the plugin index handles discovery and installation, but the source and permissions of third-party plugins still require users to review them on their own.

4.2 Official plugin marketplace and Token incentives

Category Content Status
Plugin distribution npm and Git distribution, plugin index, search and categories Implemented
Version management Compatibility checks, updates, enable/disable, uninstall, hot reload Implemented and continuously iterated
Plugin API Improving stability and compatibility Officially planned
Security mechanisms Improving plugin review and security controls Officially planned
Official plugin marketplace A more complete discovery, distribution, and publishing experience In preparation; rules and launch date not announced
Author support Token incentives, technical exchange, work recommendation and exposure In preparation; intent registration is open
Ecosystem partnership Encouraging startups and enterprises to integrate their products and services through plugins Official direction

The long-term positioning the official team has proposed is to make Harness the operating system of the Agent era: the platform provides general foundational capabilities, while specialized scenarios and personalized needs are handled by developers through plugins. The specific eligibility, allocation mechanism, and standards for Token incentives will be announced later.

Analysis: Token incentives directly address the most tangible cost for plugin authors. Plugin development and testing themselves require a large number of model calls, so supporting authors with invocation quota plus recommendation exposure is a direct way to keep plugins continuously maintained.

4.3 How developers and enterprises can participate in the Harness ecosystem

The following opportunities are derived from the existing plugin mechanism; the official team has not yet published commercial revenue data:

  • Independent developers: Turn the vertical tasks you excel at into plugins, such as financial organization, research management, code review, and content production.
  • Enterprise software teams: Package existing services and APIs as tools that Agents can call, lowering the barrier to use for users; they can also package business capabilities internally for designated teams to use.
  • Professional service providers: Productize industry processes, data processing, or professional knowledge and deliver them to users through Harness.
  • API platforms: Provide model invocation and tool services for different Agents and plugins, sitting at the bottom layer of the entire ecosystem.

5 Key Competition After DeepSeek Harness Platformization

5.1 Plugin Growth Brings Demand for Quality and Compatibility Management

InfoQ’s November 10 report documented community feedback. After installing more than 15 plugins, some users encountered infinite Agent loops, context overflow, and increased token consumption. One reason is that tool descriptions take up a lot of context, which burdens the model when it selects tools. Another Windows user upgraded from v0.2.1-rc.5 to v0.2.2-rc.1 and lost 32 third-party and local plugin entries; localized plugins were incompatible with the new version and caused startup failures. Because there was no automatic backup or rollback before the update, it took about 5 hours to restore the environment.

These are individual user reports, but they point to the same conclusion: the more plugins there are, the more governance capabilities the platform needs. The dependency management, version checks, hot reload, long conversation compression, token statistics, and install failure diagnostics that later Harness versions keep adding are exactly responses to these problems.

5.2 What It Takes to Build a Stable Harness Plugin Ecosystem

Based on available information, a stable ecosystem needs at least five conditions:

  1. Plugin discovery: Users can quickly find plugins with reliable quality and active maintenance, not just plugins that are numerous.
  2. Version management: Compatibility checks, configuration backup, and rollback protect long-term working environments.
  3. Security controls: Tencent Zhuque Lab conducted an indirect prompt injection evaluation of Harness with 14,560 controlled executions, and some attack methods achieved success rates of 16%–25.5%. The experiment tested only one version and one model backend, and did not enable prompt hardening. The results are meant to illustrate the direction of risk and cannot be directly converted into everyday attack probabilities. This suggests that platforms need to add controls between untrusted content and sensitive tool execution.
  4. Ongoing maintenance: Plugin maintenance status, permission boundaries, and actual user counts need to be transparently displayed.
  5. Incentive mechanisms: Token incentives and exposure recommendations give excellent authors the motivation to iterate long-term.

5.3 Harness’s Next Stage and Where API Platforms Fit

Harness is developing a clear division of labor: the official platform provides the execution framework, plugin specifications, distribution, and security foundation, while the community continues to expand application scenarios. In the next stage, the focus of competition will shift from “how many plugins there are” to “how useful, stable, and affordable the plugins are.”

Model invocation sits at the very bottom of this ecosystem. Harness’s model provider configuration supports custom API keys, Base URLs, and protocols, and can connect to API proxy services, corporate API gateways, or self-hosted model services. APIYI provides a multi-protocol unified gateway that can serve as an independent model provider in Harness. On October 21, APIYI launched DeepSeek’s standalone Search and Fetch tool interfaces (deepseek-search, deepseek-fetch), which agents and plugins can use to orchestrate search and web scraping on their own. It’s important to distinguish that the server-side tools built into the model, which DeepSeek released on November 13, are still on APIYI’s roadmap for compatibility work in Harness and other clients.

Connecting APIYI as a Model Provider in DeepSeek Harness

Harness’s custom model provider settings include the API key, Base URL, model name, API protocol, context window, max output tokens, image input capability, and reasoning level. It supports four protocols: OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, and Gemini API. The matching APIYI endpoints are:

Protocol selected in Harness APIYI Base URL Notes
OpenAI-compatible https://api.apiyi.com/v1 Widest compatibility, recommended as your first choice
Anthropic native https://api.apiyi.com For the Anthropic Messages protocol
Gemini https://api.apiyi.com/v1beta For the Gemini API protocol

Before configuring anything in Harness, you can confirm the key and model ID work with just a few lines of code:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # APIYI OpenAI-compatible endpoint
)

resp = client.chat.completions.create(
    model="your-model-id",  # refer to the model list in the APIYI console
    messages=[{"role": "user", "content": "用一句话说明什么是 Agent Harness"}]
)
print(resp.choices[0].message.content)
View the multi-model connectivity check script
import time
import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # keep this consistent with the Base URL you enter in Harness
)

# model IDs you plan to configure in Harness; use the actual list from the console
MODELS = ["model-id-a", "model-id-b"]

def check(model: str) -> None:
    start = time.time()
    try:
        r = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": "ping"}],
            max_tokens=16,
        )
        cost = time.time() - start
        print(f"[OK] {model} {cost:.2f}s -> {r.choices[0].message.content!r}")
    except Exception as e:
        print(f"[FAIL] {model}: {e}")

for m in MODELS:
    check(m)

🚀 Configuration tip: Start by getting an API key and free trial credits at APIYI apiyi.com, use the script above to confirm the model works, then fill in the Base URL, model name, and protocol in Harness’s model provider settings. If you’re running a lot of plugins, consider lowering the number of tools injected per call to keep context costs down.


FAQ

Q1: How should I read the 1.54 million DAU figure for DeepSeek Harness?

That’s single-day data as of November 4, 2026, covering Harness users who call DeepSeek’s official API. The 271,000 figure from September 30 was a 7-day average — the two use different measurement methods, so they’re best used to spot trends.

Q2: Does that mean 60% of users are building plugins?

That percentage counts active users who have installed or built at least one third-party plugin — two behaviors rolled into one number. It reflects how deeply plugin capabilities have penetrated, not how many people are developers. The official developer share hasn’t been disclosed.

Q3: Has the official DeepSeek Harness plugin marketplace launched?

What’s live today is the plugin index, npm and Git distribution, compatibility checks, and similar capabilities. The official plugin marketplace and Token incentives are still in the works — the full rules, revenue split, and launch date haven’t been announced yet.

Q4: Can DeepSeek Harness connect to third-party model APIs?

Yes. Harness supports a custom API key, Base URL, and four protocols, so you can set up an API proxy service or enterprise gateway as an independent provider. With APIYI apiyi.com, you can call several mainstream models with a single key — handy for comparing how different models handle plugin tasks inside Harness.

Q5: Does APIYI support all the application tools DeepSeek released on November 13?

APIYI brought DeepSeek’s standalone Search and Fetch interfaces online on October 21, billed by successful calls without consuming model tokens. As for the server-side tools built into model conversations, such as deepseek_web_search and deepseek_read_url, compatibility support in clients like Harness and Claude Code is still planned for a later stage.

Q6: What risks come with installing lots of plugins?

Three main ones: tool descriptions eat into your context window and push up token consumption; version upgrades can break plugin compatibility; and third-party plugin index listings aren’t checked for authenticity. A few habits help — keep plugins trimmed to the task at hand, back up your config before upgrading, and verify each plugin’s source and permissions.


DeepSeek Harness Platformization: Key Takeaways

  • User scale: On the official API user basis, daily active users hit 1.54 million on November 4, with roughly 92 trillion tokens per day.
  • Plugin ecosystem: About 35,000 third-party plugins, and roughly 60% of active users have installed or built one.
  • Architectural foundation: Everything is a plugin, with dynamic composition and hot reload built on Cordis.
  • Community applications: Spanning content creation, design, a unified entry point for multiple coding agents, long-term memory, and research reading.
  • Official plans: A plugin marketplace, security mechanisms, and token incentives are in preparation.
  • Competitive focus: Shifting from plugin count to quality, compatibility, security, and context cost management.
  • Model access: Harness supports custom providers, so you can configure the APIYI multi-protocol gateway as a model source.

Summary

DeepSeek Harness went from an open-source tool to a developer ecosystem in under three months:

  1. Growth: On the official API user basis, daily active users rose from 271,000 at the end of September (7-day average) to 1.54 million on November 4.
  2. Ecosystem: 35,000 third-party plugins and a 60% participation rate show that users now routinely extend their agents to fit their needs.
  3. Platformization: The plugin index is already available, the official marketplace and token incentives are in the works, and a clear division of labor has taken shape — the official team provides the infrastructure, while the community fills in specialized scenarios.

For developers, now is a good time to turn familiar vertical workflows into plugins, while keeping an eye on plugin API stability and the eventual release of official marketplace rules. If you need model invocation capability for Harness or for your plugins, you can use APIYI (apiyi.com) to quickly connect to multiple models and compare their results.

📚 References

  1. DeepSeek Harness GitHub Repository: source code, Releases, and community discussions
  2. Link: github.com/deepseek-ai/deepseek-harness
  3. Note: version updates, plugin developer discussions, and project licensing

  4. DeepSeek Harness Plugin Index Documentation: plugin discovery, installation, and verification scope

  5. Link: deepseek-harness.github.io/deepseek-harness/guide/plugin-market
  6. Note: understand the index fields, compatible versions, and source confirmation mechanism

  7. DeepSeek Harness Model Provider Configuration: custom API integration methods

  8. Link: deepseek-harness.github.io/deepseek-harness/guide/providers
  9. Note: the four protocols and descriptions of each configuration item

  10. Cordis Technical Paper: the spatiotemporal composability programming paradigm

  11. Link: arxiv.org/abs/2608.25512
  12. Note: understanding the theoretical foundation of the “everything is a plugin” architecture

  13. InfoQ: Harness’s 1.54 Million DAU and Plugin Ecosystem Feedback

  14. Link: infoq.cn/news/Y7lTO7Q1M8oN5JhxhirK
  15. Note: community feedback on plugin context costs and upgrade compatibility issues

  16. APIYI DeepSeek Search & Fetch Documentation

  17. Link: docs.apiyi.com/api-capabilities/deepseek-search-fetch/overview
  18. Note: how to call the standalone search and web scraping interfaces, plus grouping and billing

Author: APIYI Technical Team
Technical Exchange: Feel free to reach us through the homepage of the APIYI apiyi.com website; more integration materials are available in the APIYI documentation center.

Related Articles

Similar Posts