DeepSeek Harness Adds Creator Mode, Letting Users Build Live AI Plugins Through Conversation

DeepSeek's open-source agent harness, the fastest-growing developer tool in the company's history with roughly 269,000 GitHub stars gained in under three months, gained a qualitatively new capability on November 2, 2026. The team announced Creator Mode on X, posting seven bilingual demo prompts that show users how to generate functional, installable plugins by describing them in plain English or Chinese. No prior plugin authoring experience is required. The agent reads the description, builds a Cordis plugin in memory, and installs it into the running session through the existing Plugin Manager interface.

The announcement matters for a reason that extends beyond the convenience of natural-language tool creation. Creator Mode is the first working reference implementation in a production-quality agent runtime of a capability that has been theorized for years: a software system that can inspect its own plugin graph and extend it, without pausing execution or requiring a code editor. DeepSeek calls the underlying framework Cordis, and the architecture that makes this possible is not incidental to Harness — it is Harness.

What DeepSeek shipped on November 2 is more precisely a new entry point to an existing capability that arrived in prerelease form on October 3, when Harness version 0.2.1-alpha.1 added a "Let Agent create a plugin" option to the Plugin Manager. Creator Mode formalizes that experimental path into a first-class runtime mode, adds a preset authoring workflow, and publishes demonstration prompts that any user can copy and modify. The timing follows a broader strategic push: DeepSeek published a technical post on October 31 describing a "super-agent" architecture built on the same bi-layer, event-driven, asynchronous multi-channel design that Harness uses. Creator Mode is the user-facing expression of that architecture's self-extension capability.

Creator Mode: What Changed on November 2

Harness previously offered three named runtime modes. Standard mode runs the full coding-agent experience — model, tools, session management, file I/O, and UI all active. Code mode (also called PTC mode, for "prompt, tools, completion") adjusts how the model receives tool call results, trading some interactivity for precision in multi-step coding tasks. Minimal mode strips Harness down to its core for benchmark runs, CI pipelines, and reproducible evaluations where the full plugin stack would introduce noise.

Creator Mode is the fourth mode. It activates three additions that are unavailable in the other modes: runtime inspection tools that let the agent query its own loaded plugin list, in-memory plugin experimentation that allows the agent to build a Cordis plugin object without writing it to disk, and a preset authoring workflow that packages a tested plugin as a shareable configuration file other users can load with a single command.

The runtime inspection capability is what distinguishes Creator Mode architecturally from every other mode. When a user asks the agent to "create a plugin that does X," the agent first calls the inspection API to read the current state of the Cordis plugin graph — which plugins are loaded, what dependencies they declare, what event channels they publish to or subscribe from. It uses that live state to inform the new plugin's design, avoiding name conflicts, reusing existing event infrastructure, and inheriting any authentication or storage plugins already in scope. The result is a new plugin that is structurally aware of the runtime environment it will enter, rather than being written against a static template.

Plugins built in Creator Mode are tested in-memory within the same session. If the plugin fails — wrong output format, missing dependency, event channel conflict — the agent can iterate on the same session without restarting Harness. Once the plugin is working, the user has two paths: install it locally via Plugin Manager with a single click, or export it as a preset configuration that can be shared through the dsh-plugin GitHub topic ecosystem, which had approximately 11,944 repositories tagged dsh-plugin as of August 26, 2026 — a raw GitHub topic count that includes some repositories not containing functional plugins.

The Cordis Micro-Kernel: Why Self-Modification Is Possible Here

Creator Mode is not primarily a natural-language-to-code feature. It is an expression of Cordis, the micro-kernel that runs underneath Harness, and understanding why Creator Mode works requires understanding what Cordis is and what it was designed to solve.

Cordis is described in the research paper "A Programming Paradigm for Spatiotemporal Composability" (arXiv: 2608.25512). The paper introduces a programming model in which services, tools, and application components are treated as independently loadable and unloadable units — plugins — connected by a reversible dependency graph. "Reversible" here has a specific technical meaning: when a plugin is unloaded, Cordis rolls back its side effects. Database connections close. Event subscriptions cancel. File handles release. The runtime state before that plugin loaded is restored as precisely as the design allows.

This reversibility is the property that makes Creator Mode safe to run in a live session. When the agent builds a new plugin experimentally, Cordis can install it, test it, and unload it without corrupting the state of the other plugins already running. If the experimental plugin crashes, the session does not crash. The dependency graph absorbs the failure, the failing plugin is unloaded, and the agent can retry with a revised implementation. Without this rollback guarantee, in-session plugin creation would be too risky to expose to users who may describe malformed plugins by mistake.

The Cordis architecture also defines what it means for "everything to be a plugin" in Harness. DeepSeek uses that phrase as a design principle, not marketing language. The model itself loads as a Cordis plugin. The tool-calling system loads as a Cordis plugin. Session management, the web UI, storage, the agent loop, and sandboxing all load as Cordis plugins. This means none of them are hardcoded into Harness's core. Users can swap the model plugin — loading Claude, GPT-5.6, or a local quantized model in place of DeepSeek V4.1-Flash — without modifying source code, by editing a configuration file that declares which plugins to load. For users concerned about data jurisdiction, this model-agnostic design means Harness can be run entirely against locally hosted models or providers outside DeepSeek's infrastructure. Creator Mode takes this architecture to its logical conclusion: the user is now also a plugin author, and the agent is their authoring tool.

The dependency graph backing this design is acyclic during normal operation but supports conditional loading. A plugin can declare that it requires another plugin as a dependency, and Cordis will load the dependency first if it is not already present. This is how Creator Mode can offer to install a storage plugin automatically when a user asks for a plugin that needs to persist data — the agent declares the dependency in the new plugin's manifest, and Cordis resolves it.

Seven Demo Prompts: How Text-to-Plugin Works in Practice

DeepSeek published seven example prompts in both English and Chinese alongside the Creator Mode announcement. The prompts span a range of complexity and plugin types, and they reveal important characteristics of the system that are not visible from the headline claim.

The simplest demo creates a Session Statistics Tool — a live panel displaying token use, session count, cost budget, and CPU utilization. The prompt runs under two hundred words. The resulting plugin uses Harness's storage and UI plugins, introduces no new dependencies, and modifies no existing behavior. This prompt can likely be reproduced reliably in a single generation round.

More complex demos cover a wider range of plugin types. A Poster Design Workbench lets users customize titles, body text, and background shader colors within a live Harness panel. An interactive Transformer 3D Visualization walks through each step of a Transformer computation as a rendered 3D model, illustrating how self-attention and feed-forward layers process tokens. A 3D Landmark Exhibition Hall places the Eiffel Tower, the Great Wall of China, and the Forbidden City as interactive 3D landmarks inside the Harness interface. A Pixel-Style App Interface generator cycles the entire Harness UI through five distinct visual styles with a single toggle. A Video Editing Workbench provides multi-video upload, preview, a timeline view, and export controls in a dark-themed layout. And a Paper Reader preserves the original document's layout, fonts, and embedded images while adding annotation tools and a live in-session Q&A panel. These prompts are substantially longer and reference specific Harness APIs, event channels, and rendering capabilities. DeepSeek noted explicitly in its announcement that some plugins required multiple rounds of refinement to match the demo output — a single prompt does not guarantee exact reproduction of the shown results.

This caveat is technically meaningful. Creator Mode is not a one-shot code generator. It is an iterative workflow in which the agent and user collaborate through conversation to refine a plugin until it works as intended. The initial generation provides a scaffold; subsequent rounds add functionality, fix errors, or change behavior in response to user feedback. This interaction model is familiar to users of Claude Code or GitHub Copilot but is new to Harness, which previously expected users to write plugins in JavaScript or TypeScript against the Cordis API.

The bilingual prompt publication is deliberate. Harness has an international user base concentrated in China, Japan, South Korea, and Southeast Asia, and DeepSeek has consistently published documentation in Chinese alongside English. The dsh-plugin GitHub ecosystem reflects this — a substantial fraction of the community plugin repositories have Chinese-language documentation, suggesting that many Harness users work primarily in Chinese. Creator Mode's natural-language path lowers the barrier for those users more than for English-first developers, since they can now describe plugins in their primary language rather than translating their intent into English documentation.

The Four Runtime Modes and Their Architectural Implications

Understanding where Creator Mode sits in Harness requires a clear picture of what each of the four modes does and what it switches off.

Standard mode is the default. All plugins load: the model, tools, session management, the web interface (served locally at 127.0.0.1:3080 by default after npx @deepseek-ai/dsh web), storage, and the agent loop. This is the mode most users encounter. It is also the mode in which Harness performs agentic coding tasks — writing code, running tests, editing files, browsing documentation, and managing long multi-step workflows.

Code mode adjusts the communication path between model and tools. In Standard mode, tool call results are returned to the model directly in the conversation context. Code mode batches them differently, optimizing for tasks where the model needs to process many tool outputs before generating a user-visible response. It is primarily relevant for users running Harness against complex multi-file codebases where intermediate tool results would otherwise inflate context usage.

Minimal mode disables the UI plugin, the full agent loop, and optional diagnostic tools. It exposes a minimal surface suitable for benchmark runners, CI/CD pipelines, and integration tests. This is the mode used when running Harness against DeepSWE v1.1, the agentic coding benchmark on which DeepSeek V4.1-Flash-1017 currently scores 77.0 — higher than Claude Opus 5 at 74.0 and GPT-5.6 Solution at 73.0 according to DeepSeek's self-reported figures. It is worth noting that the Claude Opus 5 and GPT-5.6 Solution scores come from the Datacurve standardized evaluation board, while DeepSeek's 77.0 uses a different evaluation configuration called Mini-SWE-V2; DeepSeek V4.1-Flash-1017 does not appear on the Datacurve board, making direct cross-methodology comparison imprecise. Independent verification of DeepSeek's figure has not been published.

Creator Mode adds the inspection, experimentation, and preset authoring tools described in the previous sections. It runs on top of Standard mode — all Standard-mode plugins remain active, and Creator Mode overlays the self-modification capability on top of the full agent environment. This layering means Creator Mode is the only mode in which users can build, test, and install a new plugin without leaving their working session.

DeepSeek V4.1-Flash-1017: The Model Built for Harness

The model that powers Harness by default underwent a significant update on October 17, 2026. DeepSeek released what it calls DeepSeek V4.1-Flash-1017, a checkpoint of its V4.1 Flash model optimized specifically for the Harness environment. The company recommends Harness version 0.2.1-rc.1 or later to use the updated checkpoint, noting that earlier versions may show degraded tool-use performance with the new model.

The V4.1-Flash architecture is a mixture-of-experts design. In a mixture-of-experts model, the full model contains a large number of parameter blocks — experts — but only a subset of those experts activates for each token during inference. This means the model's total parameter count can be very high while the per-token inference computation remains bounded by the size of the activated subset. For Harness specifically, this design matters because tool-calling workloads involve many short, structured generation steps — parsing tool call syntax, formatting arguments, processing results — rather than the long free-form generation common in conversational models. A mixture-of-experts model can maintain a large overall knowledge capacity while remaining fast on these structured short-sequence tasks.

The October 17 release appears to have specifically optimized the model's tool-call reliability and its ability to interact with the Cordis plugin API. DeepSeek has not published a technical report on the checkpoint, so the precise nature of the post-training changes is not publicly known. What is documented is the benchmark result: DeepSeek's self-reported DeepSWE v1.1 score of 77.0, which the company reports represents a lead over both Claude Opus 5 and GPT-5.6 Solution on agentic coding. Because DeepSeek ran this benchmark using its own harness and has not released its testing configuration, the score should be treated as a company-reported figure pending independent evaluation.

Harness version 0.2.1-rc.1 is also the first release candidate that explicitly includes Creator Mode as a stable (rather than experimental) feature, suggesting that the V4.1-Flash-1017 update and Creator Mode were developed in coordination. The model update may include fine-tuning on Cordis API usage patterns that makes it better at generating valid plugin code from natural-language descriptions.

Competitive Landscape: Claude Code, Codex, and Open Alternatives

DeepSeek Harness competes in a market that did not exist eighteen months ago. The category — purpose-built open-source agentic coding environments with model-agnostic plugin systems — has three significant competitors and several smaller ones, and Creator Mode shifts Harness's competitive position in a specific direction.

Claude Code, Anthropic's agentic coding tool, is Harness's most direct peer in terms of user mindshare among developers. Claude Code is not open-source; it runs as a closed CLI tool backed by Anthropic's model API. Its plugin system exists but is not user-extensible in the same way Harness's is — the hooks mechanism (hooks.json, which Harness supports as a compatibility bridge) allows users to run scripts triggered by specific agent events, but users cannot add new first-class plugins to Claude Code's runtime. Claude Code's model is fixed to Claude; Harness is model-agnostic by design, and its model plugin can be swapped to any OpenAI-compatible API endpoint. Creator Mode widens this gap: Harness users can now extend the tool's capabilities in ways Claude Code users cannot, without filing a feature request or waiting for an Anthropic release.

The competitive dynamic also has an enterprise dimension. Organizations evaluating agentic coding tools for internal deployment typically face a build-versus-buy decision: adopt a commercially supported tool like Claude Code or Codex, or invest in customizing an open-source alternative. Creator Mode shifts that calculus. Because Harness plugins can now be authored through conversation, internal tooling teams can build company-specific integrations — connecting Harness to internal code review systems, documentation platforms, or deployment pipelines — without deep Cordis expertise. The preset file format makes those integrations portable across team members and deployable via configuration rather than code. For enterprises that want agent behavior customized to their specific workflows but lack the engineering capacity to write production Cordis plugins from scratch, Creator Mode offers a middle path. This addresses one of the most common objections to open-source agent tooling in enterprise settings: that the customization capability exists in theory but requires specialist knowledge to access in practice.

OpenAI Codex (the agent, not the original code model) is similarly closed-source and OpenAI-model-exclusive. Its tool system is tightly coupled to OpenAI's function-calling interface and does not expose a runtime extension mechanism analogous to Creator Mode.

Pi, the open-source agent harness developed independently of DeepSeek, is the closest architectural peer. Pi also treats its core components as loadable modules, but its extension system requires manual plugin authoring — users write plugins by implementing a defined TypeScript interface, not by describing them in natural language. Pi's plugin ecosystem is smaller (a few hundred community contributions versus Harness's nearly 12,000 repositories), and Pi does not have an equivalent to Harness's inspection API.

OpenHands (formerly OpenDevin) and opencode are the other significant open-source entrants. OpenHands focuses on autonomous software development agents with strong multi-file editing capabilities; it does not have a first-class runtime plugin system. opencode prioritizes local execution and privacy, running against local LLM inference, but its extension model is based on configuration files rather than runtime-modifiable plugin graphs.

The competitive summary: Harness is the only open-source agent runtime in which the agent can describe, build, and install a new tool without pausing execution, without editing source code, and without requiring the developer to write any code at all. That is Creator Mode's defining technical differentiator.

The Platform Flywheel: Creator Mode as Land-Grab Strategy

The largest implication of Creator Mode is not technical. It is strategic.

Before Creator Mode, DeepSeek and the small team of contributors who shipped Harness were the primary authors of Harness's plugin ecosystem — the team built the initial suite of model, tool, storage, and UI plugins. The community built extensions on top of that foundation. Barrier to entry was real: writing a Cordis plugin required understanding the Cordis API, the TypeScript plugin interface, Harness's event system, and how dependencies were declared and resolved.

Creator Mode collapses that barrier. Any Harness user can now describe a tool, have the agent build it, and publish the resulting preset as a dsh-plugin repository. The approximately 11,944 community repositories that existed as of August 26, 2026, were written by developers. The next wave may be authored — initially at least — by the agent itself, with users functioning as specifiers and testers rather than coders.

This creates a platform flywheel. More users means more Creator Mode sessions. More Creator Mode sessions means more community plugins in the dsh-plugin ecosystem. More ecosystem plugins attract more developers. More developer adoption drives more GitHub stars — Harness was growing at roughly 3,300 stars per day as of November 2, 2026, faster than Claude Code and OpenAI Codex combined at comparable points in their lifecycles.

The flywheel also captures an economically important shift in who performs labor for the platform. Plugin development for a software ecosystem normally requires paid engineering time — either from the platform company or from companies with strong financial incentive to integrate. Creator Mode turns plugin development into a user behavior, distributing the labor across millions of people who build plugins for their own use and then share them. DeepSeek benefits from every published preset without having written it.

This model has precedent. WordPress grew its market dominance partly through user-generated plugins that now number in the tens of thousands. The App Store scaled through third-party developers. Creator Mode positions Harness to run a version of that same playbook, except that the initial barrier to contribution is now natural language rather than programming experience. The question is whether the quality of AI-generated Cordis plugins will be reliable enough that community presets become a genuine resource rather than an accumulation of half-working experiments. That remains to be tested at scale.

Limitations, Failure Modes, and What Won't Work Yet

DeepSeek's announcement materials are promotional in tone, and several significant limitations deserve attention.

The iterative refinement requirement is the most practical constraint. DeepSeek acknowledged that some demo plugins required multiple conversation rounds to work correctly. For simple plugins — a statistics widget, a note-taking panel — one or two rounds is likely sufficient. For complex plugins involving custom rendering, external API calls, or intricate event wiring, the number of rounds is not predictable and the user may need to understand Cordis internals to diagnose failures the agent cannot fix autonomously.

Plugin quality in AI-generated code is also a known concern. Research on LLM-generated code consistently finds that models produce code that appears to work but contains subtle security vulnerabilities, incorrect error handling, or brittle assumptions about external service behavior. A Cordis plugin that calls an external API, handles user authentication, or stores persistent data could contain such issues without the user being aware. The preset sharing ecosystem has no built-in review process analogous to a code review or security audit.

The runtime inspection capability also has scope limits. The agent can read which plugins are loaded and query their declared interfaces, but it cannot inspect the internal implementation of an existing plugin to understand why it behaves a particular way. If a user asks Creator Mode to extend an existing plugin — adding a feature to the storage plugin, for example — the agent is working from the declared API alone, not from source code. This means Creator Mode can compose and configure existing plugins effectively but cannot safely modify them.

The DeepSWE v1.1 benchmark scores (77.0 for DeepSeek V4.1-Flash-1017, 74.0 for Claude Opus 5, 73.0 for GPT-5.6 Sol) have not been independently reproduced. DeepSeek conducted and reported its own evaluation using the Mini-SWE-V2 harness; the competing figures for Claude Opus 5 and GPT-5.6 Solution come from the Datacurve standardized board using a different harness configuration. These are not directly comparable measurements. DeepSWE v1.1 is a relatively new benchmark with limited replication history. Until third-party evaluators publish results using the same harness configuration and identical test conditions, treating these scores as definitive performance rankings is premature.

Three Milestones That Will Determine Whether Creator Mode Delivers

Three developments will determine whether Creator Mode becomes a durable competitive advantage or a compelling demo that struggles at scale.

First, the community plugin quality signal. The dsh-plugin GitHub topic provides a natural experiment: as Creator Mode-generated presets accumulate in community repositories over the next sixty to ninety days, developers will form views on whether AI-authored Cordis plugins are production-reliable or proof-of-concept quality. A wave of broken or insecure presets would slow adoption among professional users even if usage counts grow.

Second, independent benchmark replication. DeepSeek's DeepSWE v1.1 score of 77.0 is the company's central argument that V4.1-Flash-1017 is the strongest model for agentic coding tasks. If third-party evaluators reproduce scores in that range, it substantially strengthens Harness's position relative to Claude Code and Codex. If independent evaluation shows the gap narrower than reported, the narrative around Harness shifts from "best-in-class model" to "best open-source alternative."

Third, Anthropic and OpenAI responses. Claude Code and Codex have both declined to build open, user-extensible plugin systems, opting instead for proprietary extension mechanisms tightly coupled to their own models. Creator Mode makes the trade-off in that decision more visible: Anthropic and OpenAI users cannot extend their coding tools through conversation. If Creator Mode drives measurable Harness adoption among professional developers, it will increase pressure on the closed-source competitors to open their extension APIs or build equivalent natural-language authoring tools themselves.

Harness was launched on August 13, 2026. Creator Mode arrived eighty-one days later. The architectural foundation — Cordis's reversible plugin graph, the runtime inspection API, the model-agnostic design — was present from the beginning. What took eighty-one days was building the user-facing workflow that makes the architecture accessible without requiring its users to understand it. The pattern is familiar in platform histories: infrastructure first, then the tool that democratizes access to it. How far that democratization extends will depend on whether the generated plugins are good enough to build on, and on whether the broader developer community treats Harness as a foundation or as a convenience.