DeepSeek Harness Did Not Stop Updating. It Just Shipped a Breaking Rewrite. The premise is already outdated. DeepSeek Harness released v0.1.2-alpha.1 ( on August 27, followed by v0.1.2-alpha.2 ( on August 30. The apparent silence came from a release-channel gap: the new code reached GitHub, but the npm package had not yet moved to the same version. Zhihu contributor Kitt在进化 explains why. Alpha.1 was not a routine feature update. It rewrote several foundational contracts and could break much of the existing plugin ecosystem. 1️⃣ Why the update stayed on GitHub According to the author, the amount of low-level refactoring in v0.1.2-alpha.1 exceeded that of several previous releases combined. Publishing it immediately through npm would have pushed breaking changes to ordinary users before plugin developers had time to adapt. Keeping it as a GitHub pre-release creates a migration window: 🔹 Core developers can test the new architecture. 🔹 Plugin authors can identify incompatibilities. 🔹 The ecosystem can stabilize before the release candidate reaches npm. The delay therefore signals caution, not abandonment. 2️⃣ The old communication layer was removed The legacy APIProxy interface is gone. Plugins that called APIProxy directly or manually constructed RPC requests must now communicate through the standardized Remote gateway and Remote Controller. This gives Harness a cleaner and more consistent communication layer. It also immediately breaks plugins built around the old API. The subsequent alpha.2 release added unified RemoteError wrapping, suggesting that DeepSeek is still stabilizing this new gateway contract. 3️⃣ The Web client was structurally rewritten The frontend was split into independent client modules and layered services. That is a healthy architectural change for the core project, but the DOM structure also changed substantially. Many community plugins had implemented UI features by targeting internal DOM selectors. They added sidebar panels, floating buttons, or controls beside the prompt box. After the rewrite, those selectors no longer exist. Plugins based on DOM injection may therefore require extensive retesting or a complete rewrite. The lesson is familiar: integrating with internal page structure is fast, but fragile. 4️⃣ Sessions now behave like strict event logs Older plugins often treated the conversation session as a convenient local database. They inserted custom state by writing their own event types into the session log. Harness now treats that log as a replayable event stream with strict semantics. The reader follows a fail-closed policy. If it encounters an unknown event type, it refuses to restore the session rather than risk corrupting state. This protects session integrity, but it also means that plugins with unregistered custom events can make earlier conversations unreadable after an upgrade. Alpha.2 restored SessionEvent.ignorable, which had been removed in alpha.1. That change may ease some compatibility problems, but plugin authors still need to respect the new persistence model. 5️⃣ Models and subagents received a deeper upgrade Harness is also moving beyond a simple single-model configuration. Subagents can now receive their own: 🔹 Model provider 🔹 Model selection 🔹 Reasoning effort 🔹 Maximum output length Claude Code and Codex subagents can also use configured models. This required changes to the Models settings interface, provider authentication, and the surrounding API chain. Plugins that customize model settings are therefore among the most heavily affected. By contrast, plugins that only add tools or provide configuration-based Agent Presets should require fewer changes. ⚠ Which plugins are most exposed? The highest-risk categories are: 🔹 Plugins using the removed APIProxy 🔹 Web plugins that depend on DOM selectors 🔹 Plugins writing custom SessionEvent types 🔹 Extensions modifying model or provider settings The author points to several concrete failures. One plugin imported an internal CallId symbol. When that implementation detail changed, the plugin crashed during loading. Other plugins inserted custom events into sessions. After upgrading, the stricter reader rejected those events and could no longer restore previous conversations. Some UI plugins still loaded but effectively disappeared because their target DOM elements had been removed. 🔍 The broader takeaway DeepSeek Harness remains a developer preview built around the idea that everything is a plugin. That makes extensibility central to the product. It also means that changes to plugin contracts can affect almost every layer of the system. The current release sequence shows a project moving quickly while its public extension boundaries are still being defined. For plugin developers, the safest approach is to pin versions, avoid undocumented internal symbols, stop relying on page DOM structure, and migrate communication to the official Remote layer. Harness is not slowing down. Its core is changing faster than the surrounding ecosystem can currently absorb. 🔗 Full analysis: #DeepSeek# #DeepSeekHarness# #AIAgents# #AgentInfrastructure# #OpenSourceAI# #DeveloperTools# #PluginArchitecture#