Awesome DeepSeek Harness Plugin

Runs scheduled coding tasks in isolated DeepSeek Harness sessions, managed from Settings or the agent.

AgentTeams multi-agent teams.

Native conversational image generation for DeepSeek Harness: ask the agent to create an image, and it handles generation and keeps the result directly in the conversation.

Installs four multi-agent math-research presets for DSH: v2 (probability-driven pipeline with multi-verifier debate), v3 (paper-style Markdown knowledge base with a planner agent and a reusable method library), v4 (persistent self-organizing residents that message and meet), and v5 (a research institute with an academician who decomposes and assigns work, voting researchers, temp workers, group chat and a compare-and-set task board); all four support checkpoint resume, human intervention, and an optional Lean formal-verification switch (off/encourage/require) whose passing proof turns the vote into a fidelity check of the Lean statements.

Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.

Preset engineering workflows for DeepSeek Harness: a dev_task tool that gates stage transitions, artifacts, verification, review and commit scope, plus a web workbench for installing project or user skills and rules.

Runs one-time and RFC 5545 recurring Agent tasks in fresh DSH sessions, with visual schedule editing and session-linked history.

Task board for DSH: create tasks with project and model assignment, run them manually or on cron schedules; new sessions in a project automatically pick up its todo tasks and move them to in-review when done.

Pre-visit due diligence and company research in DeepSeek Harness for customer background checks and risk briefs, with Qichacha MCP tool-call budget approval and entity confirmation.

Runs Claude Code as a DSH conversation while preserving its native agent loop, tools, skills, hooks, and MCP integrations.

Long-lived AI companions with isolated memory, WeChat channels, Skills, schedules, heartbeat concerns, and a dependency-aware task board.

Role-based AI swarms for DeepSeek Harness: an architect plans, parallel builders execute, reviewers gate quality, and an integrator ships. Per-role model pinning with fallback chains, review loops, evidence contracts, human-gated reviews, quota-aware pause/resume, and a live kanban + flow chart in the web GUI. 40 tests; installs from GitHub or npm.

Profile-wide DSH governance and routing with a Web Control Center for responsibility and evidence inspection, plus compaction, scoped semantic memory, safety continuity, and verified delivery; compatible with DSH 0.1.5-rc.1.

Skill-driven harness/loop engineering workflow agent plugin.

Role-based multi-agent team for DeepSeek Harness. The /team command assembles up to 12 specialist subagents (product, architect, researcher, UI, backend, frontend, database, security, reviewer, QA, DevOps, docs) and runs a nine-phase gated pipeline (clarify, research, design, spec review, plan approval, implement, review, test, deliver) over a shared workspace of artifacts (SPEC, PLAN, TASKS, STATE, REVIEW, TEST). Quality gates are enforced by plugin code rather than requested in prompts: an unfinished task cannot be marked completed, quality findings must be adjudicated by the reviewer or QA role, and coverage gaps or rework over budget appear live in the overlay and in /team status. Ships a live team overlay (phases, roster with per-role models, task DAG, artifact preview, decision buttons), a persistent-team mode that resumes across sessions, and per-run token and time accounting. Zero runtime dependencies, no build step.

Visual Kanban board for DeepSeek Harness with Gitea-backed tasks, workflow columns and a dedicated agent session per task.

Verifiable research-report engine for DeepSeek Harness with a content-addressed evidence ledger, versioned sealed reports where every claim carries a verification verdict and the manifest hash seals the directory, and retrieval orchestration that reuses the ctx.web and ctx.jobs seams.

Engineering-discipline guard: requirements grill before the first edit, red/green test-evidence gates, forked adversary review, and a delivery report with a per-dimension verification workflow.

Tender search and bid intelligence in DeepSeek Harness with proposed project search, rule screening, human review and Excel/PDF exports using user-authorized Qichacha MCP.

A persistent agent team for long-running collaboration in DeepSeek Harness: durable agent identities, per-project Workspaces, responsibility-bearing Channels, and Task Threads chaining session agents.

Durable background child agents on the official subagent seam: start from any session, watch progress in the Web UI sidebar, message and interrupt any time, with per-child tool scoping, persona and delegation-depth caps.

Trellis-style workflow for DeepSeek Harness: per-turn phase breadcrumbs via agent/pre-step, bundled skill provider, and DSH-native task/phase state with git-cleanliness guardrails.

Scheduled tasks: run a prompt on cron schedules, each run opens a new agent session to do the work, with workspace binding, manual run, session auto-naming, and a fullscreen task management page.

Agent preset bundle for wish and task management: create wishes or tasks from conversation, opportunity-day check-ins, micro-actions, plus a memory store and progress charts in the web UI.

QA project workbench for dsh: manage test projects, requirements, test cases, defects, milestones, reports and approval gates through a browser UI and 18 QA-domain tools.

A shared kanban board that lets people and DSH agents manage workspace tasks through a Board tab and kanban tools.

ICVO coding-standards kit for DeepSeek Harness (formerly dsh-coding-kit): a bundle plugin that registers tools on load and injects the standards only when apply_coding_standards is called, plus a P0 gate CLI (npx spec-wave) with G1-G7 process commands, skills install, host apply, and IDE-block refresh.

Visual multi-agent DAG workflows for DeepSeek Harness with live execution, restart recovery, and Feishu integration.

Pair a second model that passively reviews each turn and injects notes.

Goal lifecycle management for dsh with an interactive kanban board: goals, criteria, attempts and reviews live in the workspace, driven by graph_* tools, with a two-lane board rendered in the conversation view.

Lowtide (as in low tide) runs task batches automatically in off-peak hours — a highly customizable task framework with four execution strategies, L1–L3 semi/full-auto adjudication, in-place task editing and preflight checks, built on the Cordis microkernel, one build for both desktop and web.

Config-driven development-task orchestration for DSH: graph workflows (task/gateway/human nodes) with per-stage persistence, plus an in-editor AI assistant that configures workflows through conversation with live validation. Hand documents to nodes as generic attachments (no declaration needed): files land in the task workspace and ${inputs.附件} gives the newline-joined absolute paths, so a node parses them with its own prompt.

Scheduled send: fire a drafted message into the bound conversation as a normal user bubble at a set time. Runs host-side, so the browser can stay closed; per-session isolation and restart-safe redelivery.

Calendar and hierarchical task workbench: AI-assisted intake clarification, consultation, decomposition, execution with user acceptance, and review, plus reminders and per-task AI session workspaces.

Modular frontier execution discipline for DSH: evidence-first routing across 26 skills, Manus-style file planning, verification gates, fail-streak recovery, and an interactive web dashboard.

Personal assistant for DeepSeek Harness that turns conversational commitments into cross-session plans, reminders, and an auditable dashboard.

Match your models and token budgets to each role, then let DSH delegate specialized subagents by task type. Covers architecture analysis, UI/UX, code implementation, codebase exploration, and documentation research, with automatic setup plus per-role reasoning effort and tool permissions.

Process management: brings ntd-style processes (multi-stage, multi-step agent workflow templates) into the dsh web UI — browse, edit, validate, import/export and AI-generate processes; the built-in library is read-only while the personal library is writable with live file sync, and agents read the library through process_* tools and advance work stage by stage.

A governed swarm of six specialist DSH agents — orchestrator, planner, knowledge-base bridge, developer and two reviewers — turns a requirement into a strict phase pipeline where every delivery must prove itself with structured evidence before the next phase may start; reviewers are read-only, code merges only after a review pass, and an append-only event log gives full replay and audit on a live kanban board. Its design draws inspiration from the Hermes Agent kanban.

Deterministic engineering orchestration runtime for DeepSeek Harness: the orbit_controller tool and OrbitService run Commander, Executor and Smart Watchdog children through PLAN, EXECUTE, EVALUATE, bounded correction and runtime recovery, with durable state in <project>/.cx/state.json.

All-in-one combo patch for STARDUSTLC's 18 DSH plugins: one command injects shared default configs across office, media, DevOps and notification presets; each component installs directly via a one-line add command (flat design, no git subdependencies).

"Single-Core Writing" plugin for DeepSeek Harness: Thoroughly tool-streamlined and output-hardened for quantized small models, suitable for running long-novel pipelines locally with on-device models.

Cron job board: schedules local scripts or dsh session tasks (fresh or pinned sessions) by cron expression, with centralized environment-variable management, run logs, and concurrency and timeout control.

Learns what you leave unsaid in your prompts from messy turns and your own corrections, and injects the learned directives into the system prompt of every new conversation; the directives are editable in Settings and a composer button rewrites the current draft with them.

Cron scheduler for agent tasks: create jobs by natural language or a sidebar UI, inject a user message into a new or fixed session on schedule to trigger a full agent turn, with run history, manual trigger, and live SSE sync.

Gitee/GitHub AI employee: @ the bot on an issue (Gitee or GitHub), it clones the repo, implements the fix on the branch you name, opens a PR to that branch, and can auto-merge and auto-close the issue. v1.2 adds security scanning: configure scan repos, audit with built-in/custom prompts, deduplicate, and file new findings as issues.

Orchestration-mode preset generator for DSH: a lead agent delegates to four built-in role helpers that carry only their own tools, and the web panel adds or removes custom helpers with their own tools, skills, and models, per workspace — zero changes to the harness source.

Plan-and-execute orchestration over ReactLoopAgent — turns a goal into reviewable steps with a web UI plan card.

Kanban task board for DeepSeek Harness sessions: the main agent dispatches coding tasks to one-shot worker/verifier subagents, with dependency scheduling, pipeline tiers, escalation handling, and file/notes context injection.

Cron task scheduler for DSH: on schedule, automatically creates a new session and injects your prompt as its first message, with task history and manual run/stop controls. Also runs KNJ workflows: pick files directly (stored as persistent snapshots, re-handed to the workflow on every fire) or reference them by path. Its sidebar entry is provided by dsh-knj-menu; install together: dsh plugin add dsh-scheduler dsh-knj-menu.

Task reliability: auto-retry on model timeouts/failures, auto-continue unfinished tasks, completion verification, thinking-repeat interruption, resume after sleep or restart, autopilot mode and a remote trigger endpoint (npm: `dsh-task-reliability`).

Scheduled tasks panel for managing DSH agent and system crontabs with natural language input and execution logs.

Deep reading & summarization for DSH: books/papers/videos/web into structured Obsidian notes via plugin parsers, MapReduce parallel deep-read subagents, JSON Schema outputs and an idempotent cache.

Coordinates Codex planning and independent review while the original DSH session implements and tests changes.

Minimal prompt x Web PTC capabilities: one-line persona, run_code SDK, subagents, Ralph, web search/fetch, and Windows Git Bash; the general-purpose workflow tool stays hidden.

Named subagent roster: manage role entries (model, persona, tool filter, depth, background mode) from a hot-reloaded settings page; the model picks one with list_subagents and dispatches by id with delegate — foreground, background, or continuable.

Captain-led multi-agent teams that split a goal into tasks and dispatch them along an execution chain to members running in their own sub-sessions, each with its own model.

Dispatch work to DSH agents from Claude Code or Codex: native subagent progress, in-host worker sessions with per-tier presets, and a multimodal bridge for vision and image generation.

Multi-agent team collaboration for DeepSeek Harness with per-assistant models, skills, MCP servers, independent contexts, shared workspaces, task coordination, and conversation management.

Novel-writing workbench for DSH with an authoring preset, outline and character management, manuscript annotations, review workflows, and a managed local Python backend.

An RTS-style orchestration dashboard where commands replace chats: a resident commander agent decomposes each order into task briefs with acceptance criteria, typed subagent troops (recon/engineer/medic/scribe) execute them across isolated workspaces, and every session is indexed by the order that started it.

Your AI learning companion: helping you plan your studies, understand concepts, and build projects to master a subject.

A faster, more efficient, and more accurate coding Agent preset. On 100 hard SWE-bench Pro tasks selected using multidimensional difficulty criteria, average elapsed time decreased by 36%, average input tokens per task decreased by 17%, and accuracy increased by 5 percentage points.

TongFlow film-crew studio for image, voice, music and video production: the agent writes per-asset TongFlow workflow files (.tongflow.json) that run through TongFlow plugins, with an embedded workflow canvas, a shot/character/take project layout and a manga-drama template; sessions starting with @tongflow open the Studio view.

Agent governance kingdom for DeepSeek Harness: territories, role bindings (bind/unbind/session with model/agent identity), and a plan→assign→execute→review task loop where Worker claims never auto-complete (Claim ≠ Fact), with a local GUI operations console.

Installs a dedicated AI novel-writing preset and workbench: revisioned local project assets, a compact side drawer, and native approval-gated single-file changes.

Persistent, cross-session multi-agent team rooms for DeepSeek Harness — members, a message bus, a shared task board, and a shared timeline that survive restarts.

Seven agent-preset modes for DeepSeek Harness, each with a fixed tool boundary, per-mode model routing and fast/deep omd_task delegation tiers, plus a plan-to-execute loop (/mode, /start-work, goal-backed /ulw) and a settings page that remaps models per mode and per tier.

Local-first content production and operations workspace for DSH: manage ideas, scripts, media assets, schedules, goals, publishing status, and post-publication reviews.

Spec-Driven Development pipeline for Odoo: 15 tools take a request from an immutable spec through architecture to module code or live configuration, then require a persisted verdict backed by evidence from a real Odoo instance, with fail-closed gates, human-approved batches in a declared environment, Odoo's own CSV/Excel importer, and a journal that reverses the data written through the plugin.

Kimi-Code-style swarm: batch-parallel subagent dispatch with adaptive scheduling, a /swarm command, and in-chat live progress rows.

A novel-writing workbench for DeepSeek Harness: you tap thumbs-up or thumbs-down on candidate passages, and the model distils them into a short preference profile that carries into later drafting calls while the manuscript stays out of the drafting context. Adds a chapter board, per-chapter writing packs, annotation-scoped revision that rewrites only the annotated paragraph and verifies the rest byte-for-byte, a project ledger, and local pacing checks.

Two-level model circuit breaker with failover: trip a model or a whole provider after repeated request failures and route the next request to a configured fallback.

Task Runner mode for DeepSeek Harness: the main agent decomposes large tasks into independent subtasks, dispatches them to subagents (default local model) in fresh short contexts, and synthesizes results; concurrency and worker/orchestrator models are configurable in the settings panel.

Visually configure an agent's prompt, tools, visible skills, subagents and fallback models, and assemble several of them into a team. It never writes or edits any host preset file.

Runs AItelier pipelines from DSH over MCP: 39 tools (22 read, 17 write) to generate, run, inspect, edit, export and import multi-step SkillFlow pipelines. The steps execute in AItelier rather than in the DSH session and are polled by run_id, pause at engine-enforced checkpoints answered with answer_checkpoint, and leave per-step traces and step outputs to read afterwards; add_provider / map_model / edit_role point an individual role at a local or cheaper endpoint. Bundles an aitelier-pipelines skill.

Agent preset plugin for DeepSeek Harness that triages every request, delegates implementation to an expert, and schedules parallel work through a dependency-DAG taskboard and a file-based message bus before an independent review gate. Ships with only 11 core experts out of the box; more expert teams (Agency agents EN/ZH, classic collections) are one-click downloads from the settings page over dual GitHub/CDN channels with sha256 verification.

Verifiable issue-to-PR delivery chain: an 11-stage pipeline (analysis, search, code understanding, hypothesis, planning, implementation, patch ledger, tests, review, failure classification, PR build) with 4 human review gates, GitHub/GitLab/CodeArts credential connections, a 5-page workbench and a draggable AI assistant panel.

Claude Science-style research workbench: ReAct research-loop engine (research_* tools), versioned artifacts with provenance (artifact_* tools), and 10 science skills for genomics/pathogens/bioinformatics.

Long-form novel writing plugin: each book is a git repository of frontmatter files, with 39 DSH domain tools and a web writing UI. Deep import drafts candidates, AI adoption into canonical assets requires DSH approval, and deterministic continuity checks ship with a report-only benchmark. Independent open source (MIT), not an official DeepSeek product; requires Node >= 24.11.0 and currently targets DSH 0.1.2-rc.1.

Shared multi-agent task board (create/claim/transition/query) over a Cordis service key.

Programming Mode agent preset bundle: the standard coding agent with its persona mandating the Superpowers discipline (skills first, brainstorming before building, plans before code, TDD, systematic debugging, verification before completion) plus an always-on Ponytail code-volume discipline (7-rung minimal-code ladder, default full); ships all twenty skills bundled (14 superpowers + 6 ponytail) and mechanically injects the full using-superpowers skill into every new session's first request.

Captures every plan the agent presents through exit_plan_mode as markdown under <workspace>/.dsh/plans, opens a review window, and keeps a Plans history tab recording the outcome of each plan.

Capture selected DSH, local MCP, or native WebMCP calls as reviewed, parameterized routines, expose typed tools, and replay with fresh approval.

Schedules workspace Agent runs in fresh Result Sessions with persistent audit history, using a stock DSH Conversation tab or a global Shell page when its slots are available.

Dispatch subagents with named profiles (model, reasoning effort, and tool scope per task), safety checks, cost estimation with savings comparison, and a full dispatch decision ledger.

Runs work as a crew of role agents: a product manager writes the PRD or DoD, waits for your confirmation, then starts architect, engineer, QA and reviewers whose tool sets are locked per role, and shares work through files on disk.

Multi-agent orchestration layer for DeepSeek Harness — autopilot/ralph/team execution modes, 19 role cards, 40 bilingual skills, and a bundled MCP state server, ported from oh-my-claudecode.

WeChat official account AI writing pipeline: six-step article runs (topic, outline, draft, gates, render, images) with a launch brief contract, a hot-topic board with per-item AI digests, RRULE scheduling to the draft box, a workbench UI plus chat tools and a /wewrite command, and fail-closed host approval before any draft-box push.

DeepSeek-Harness plugin for multi-model orchestration with recursive task decomposition, dynamic routing, quality gates, failure recovery, and KPI reporting.

Claude Code style /init command and tool that writes a minimal CLAUDE.md and symlinks AGENTS.md to it.

A self-evolving plugin for DeepSeek Harness: it observes how the agent runs, proposes improvements to its own assets via the LLM, validates each proposal inside a sandboxed trial agent, and applies only verified mutations — with a versioned ledger and automatic rollback on regression.

Engine-enforced guardrails for DeepSeek Harness agent swarms: quality gates reject half-done work, crash-safe checkpoints resume in place — keeps AI teams from breaking, not just running.

Runtime requirement drift guard that keeps long-running DSH agents aligned with the user's approved goal, constraints, and decisions.

Run RunningHub cloud ComfyUI workflows from chat — settings card, sha256 media upload cache, concurrency gate, and background task ledger.

Turns DSH conversations into reviewable community feedback and, after confirmation, submits it to the official DeepSeek Harness Discussions.

Model high-availability failover (quarantine, circuit breaking, probe recovery) and subagent orchestration (fanout/pipeline/supervisor) with bilingual settings UI.

Session-local scheduled tasks: inject a prompt into the current session after a delay, at a fixed time, or on a repeating interval, so the model wakes up and runs it on time. Manage them from a panel above the composer, the /schedule command, or seven model-facing tools. Timers freeze while DSH is closed and never auto-resume; pause keeps the remaining time, so resuming continues from where it stopped.

Host-neutral durable DAG workflows for Agents with CLI, MCP, on-demand Skills, triggers, replay, and a visual Canvas.

Declarative task-DAG orchestration for DSH: validates dependency graphs, runs topological task layers in parallel through workflow-backed subagents, and propagates failures deterministically.

Interactive canvas for visualizing Agent, Subagent, Workflow, Phase, and tool relationships in DSH Web.

Adds specification artifacts, skills, commands, goal-backed implementation, and task-progress context.

Work reports for DeepSeek Harness: gathers Git commits and local agent conversations (DeepSeek/Claude/Codex) and renders daily, weekly or monthly reports from your own templates; the agent tool is injected on demand.

Durable multi-agent collaboration for DeepSeek Harness with channels, threads, tasks, and resumable agent sessions.

A DeepSeek Harness plugin that periodically detects added, modified, and deleted files in a workspace and reports the changes.

Agent-driven kanban board: one board per workspace, per-task agent sessions, and a guarded human/agent workflow (Backlog → To Do → In Progress → Review → Done).

Interval heartbeat that wakes each root agent itself (followup injection) to proactively report progress, risks or blockers: busy-safe queuing, no stacking, auto-pauses when no human replies, re-arms on the next user message.

Creates and inspects RecoWork local-agent-project workspaces through two bounded DSH tools and a web workspace card.

Schedule a message into a dsh chat for later: a Schedule button in the message box with a date and time picker, a sidebar panel of pending messages across chats, delivery as a normal user message even with the browser closed, and schedule_message, list_scheduled_messages and cancel_scheduled_message tools so the model can come back to a chat on its own.

Per-workspace project kanban board: nine kanban_* model tools for agent-driven planning plus a browser board UI, with disk persistence, undo, templates, and archiving.

Review-first batch automation for DeepSeek Harness: three reviewed samples, a full preview, one approval, then a safe apply across many files.

A DeepSeek Harness Web plugin that runs a user-defined command after the web profile has started successfully.

Automatically sends "continue" to recover from RATE_LIMIT (429) and QUOTA (insufficient_quota) errors. Per-session consecutive-failure counter (default 20, configurable 1-100), a toolbar on/off switch, and a settings-page card.

Per-project scheduled prompts run as fresh headless agent sessions, with one-time, interval, and cron schedules plus durable run history.

Reusable subagent definitions managed from a Settings page and dispatched through a single delegate_agent tool; ships with a built-in read-only Explorer preset and a nested-delegation policy toggle.

When a dsh turn gets interrupted — by a web restart or an upstream hiccup (rate limit, 5xx, quota error) — this plugin auto-injects a "continue" so your session picks up where it left off, with a dead-loop guard that hands back control if the retry produces nothing.

PPT stage — presentation generation (Beamer/Quarto) from the paper for asset pricing and machine learning research. Ships one skill.

Model training stage — end-to-end analysis, model training, and estimation for asset pricing and machine learning research. Ships one skill.

Ships a skill about handing work to subagents instead of doing it inline - which tasks are worth fanning out, how many to run at once, how to send them in parallel, and how to check what they returned instead of trusting the summary.

Shut down Windows automatically after DeepSeek Harness tasks complete — a floating arm button plus a cancellable countdown banner (shutdown /a), zero runtime dependencies.

Opens the official Plannotator app (plannotator.ai) so you can review the agent's plan — annotate, approve, or send it back.

Loopback-first multi-agent message relay: HMAC-authenticated broker plus dsh plugin (relay_send/recv/peers/history), zero-dependency CLI and Python clients, wire protocol v1.0.

Model-facing `generate_image` tool for text-only models: the model asks for a picture in natural language, Gemini draws it via the Antigravity CLI, the image is saved to a configurable output directory, and the tool returns the file paths for the model to use in its work.

Claude-Code-style lifecycle hooks: configured shell commands run before/after model tool calls with a JSON payload on stdin; a non-zero pre-tool exit blocks the call.

Policy-driven Git sync for DSH settings and profile configuration, with secret-aware projections, conflict review, and per-line apply controls.

Recurring loops: `/loop` command + loop tool + activity status bar.

Deep research as an agent mode: one reviewed loop that plans, researches in adaptive parallel rounds driven by the gaps the researchers themselves declare, synthesises a cited report and then reviews it adversarially, instead of a script the model rewrites per call. Questions the round budget never reached are named in the report rather than dropped.

Task kanban where agents claim and hand off work through taskboard_* tools, which cannot move a task to done or canceled — acceptance stays with a human.

Installs a multi-agent novel-writing preset for DeepSeek Harness: one conductor agent dispatches five specialized subagents — world-building, plotting, character management, prose writing, and QA review.

Automatically continues a native continuable DSH subagent once when it ends with explicit max-tokens termination, then stops.

Session-aware local notes for DeepSeek Harness: capture notes and page selections in a floating Apple Notes style panel, let the LLM classify topics, auto-inject convention notes into the system prompt, and dispatch todos with recall context to active sessions.

OMC-style multi-agent orchestration for DeepSeek Harness: 29 omd-* skills and 12 /omd-* slash commands over the plan-execute-review-verify pipeline and team/autopilot/ralph modes.

Scheduled reminders and delayed send for DSH: /later delivers what you type as yourself at the time you pick, while the timer panel (or /schedule) posts a reminder row — even with the page closed. (scheduled send / reminders / delayed send)

Registers a SpecWorkflow skill pack for requirement clarification, implementation specs, execution, delivery review, repair planning, bug diagnosis, and source-backed research.

Drives the GME Test Agent from inside Harness: three tools list interface catalogs, start and repair autonomous test generation in a local Python backend, poll the task until review, and keep PR, skip and cleanup actions behind explicit user consent.

Main-brain orchestration preset: delegation-first persona, root-session execution gate, and portable AI-LAW rule skill.

Multi-candidate mode for DeepSeek Harness (test-time scaling): floating panel config, the agent auto-runs parallel candidates plus verifier selection, scoped to the current session.

Cross-device workspace backup, restore, and ecosystem update via the uagent-sync CLI.

Evidence-first self-evolution controller: bounded Cordis candidate generation, one-shot real-Loader admission, Harbor evaluation, and a crash-resumable journaled lineage.

Multi-role parallel argumentation for DeepSeek Harness: runs the real Codex and Claude CLIs in parallel, has the DSH model (Judge) write a third-party verdict back into the conversation, plus Obsidian-style single-agent direct chat and per-role model config.

Superself's self CLI as model-facing tools (project context, work units, reports, decisions) plus a /self command — cross-session, cross-project project state kept outside the code repo.

Config-driven lifecycle hooks, including context injection: declare event, handler and outcome in YAML, where the handler is an in-harness tool (MCP included), a shell command or an HTTP endpoint, and the outcome is model-visible context, a denied tool call, or fire-and-forget.

Literature review stage — search, synthesis, and citation-chain tracking for asset pricing and machine learning research. Ships one skill.

Streams DeepSeek Harness sessions, messages, tool activity, and turn outcomes to a JARVIS Mission Control board with task status and human review.

Folio (兰亭) @nyantused/folio-dsh-tools: 15 schema-validated tools (memory + quality gates) plus an L0 guard of the consulting document-generation engine; pair with @nyantused/folio-dsh-events for the full session protocol.

Adds subagent_route and subagent_fork_route delegation tools where the model itself picks the provider/model route for each child; the deployment only sets the spawn/fork backend, background policy and allowedProviders allowlist, while continuable children and background jobs reuse the official send_message / job_output tools.

One repository that installs as both a Claude Code plugin and a DSH plugin: six engineering skills (research, architecture scouting, implementation orchestration, three-axis diff review, complexity audit, mutation testing) plus one agentforge tool dispatching five subagents.

Folio (兰亭) @nyantused/folio-dsh-events: session-protocol events — auto session-start reminder + auto-save on session close; pair with @nyantused/folio-dsh-tools.

Self-evolution actuator: consumes problem tickets mined from session logs, synthesizes skill candidates (zero-code tiers by default) behind an eval gate with hold-out canaries, then promotes to project .dsh/skills with human confirm and deterministic rollback.

Report stage — academic paper writing for asset pricing and machine learning research. Ships one skill.

Data stage — data discovery and quality assessment for asset pricing and machine learning research. Ships one skill.

Config-only bundle that mounts Ouroboros through the DSH MCP client, exposing 36 interview, Seed, execution, evaluation, and evolution workflow tools in DSH.

LoopX, a provider-neutral, local-first state kernel and control plane for long-horizon agents: keeps Goal, Todo, gate, evidence, quota, recovery, and handoff state above DeepSeek Harness, while the plugin bootstraps the CLI and skills, admits bounded same-session continuation, and adds a loopback GoalBar for the exact bound loop.

Embeds the active installed Codex Taskboard runtime in the DeepSeek Harness sidebar, using its launcher runtime descriptor instead of a fixed port.

Connects dsh to a local SandBase Harness runtime over stdio MCP for managing agents and sessions, streaming turns, inspecting artifacts and cancelling work.

Local SQLite taskboard as a native overlay page: projects, tasks, comments, relations, attachments and workflow automation, with backlog → todo → in_progress → in_review → done statuses, `taskboard_*` Agent tools that can only submit work to in_review, a headless JSON CLI and a packaged skill.

Persistent multi-model squads configured in Settings and selected in the Composer, with per-member model and tool policies. By default the lead Agent completes simple work itself and delegates only when the saved squad is needed; delegated work runs as a bounded DAG with optional review and repair. Run Center tracks retries and per-member tokens from official Harness usage events.

UltraCode-style multi-agent orchestration: a generatable, savable, governable, observable, resumable workflow layer.

Scheduled coding runs in fresh agent sessions with auditable history.

Two-phase agent preset for DeepSeek V4 Pro: the first request sees only bash+read (Minimal-aligned bootstrap), then the full Standard tool catalog after the first tool call or reply; ships as an installer bundle plus a manual preset directory.

Adaptive deep-research orchestrator built on the official workflow engine.

Synchronizes DSH profiles and local plugin source archives through WebDAV and S3-compatible storage, with encrypted snapshots, conflict-aware recovery, and explicit self-updates.

Oh My DSH (OMD) adds context summaries with original-source recall, task-linked verification, prompt optimization, CodeGraph code navigation, OpenCU computer control, and four themes covering layout, sidebars, and settings.

Research agent suite: long-horizon goal control with auditable evidence chains, cron scheduling, multi-agent expert teams, self-evolving research memory (FTS5 + RRF recall), project workspaces, and a custom workspace UI.

Condition-driven wakeup: durable file/command/http/process/webhook watches that wake the agent.

Novel-writing guardrails: 20 novel_* tools enforce fact-ledger consistency, phase and chapter gates, machine audit with deterministic metrics, and proposal-only revisions; a right-panel workbench covers reading, TTS playback, polish, proofread, continuity checks and batch drafting, and a bypass engine runs internal steps off the main conversation.

Agent teams: spawn named long-lived teammates, coordinate them with a shared task list, member mailbox, and virtual workspaces, and watch the team live in a team-room tab.

Host-resident cron engine with a web jobs board and a timer_agent tool: fires real agent sessions on schedule, continuing a pinned session for context or starting fresh ones in a chosen project workspace.

Unified anchored agent preset for DeepSeek V4 Pro/Flash on the official API and opencode-go: Minimal-exact two-tool first-request bootstrap, model-aware Pro/Flash paths, and epoch-aware catalog management for long-session stability.

Projection-driven live DAG for a Session's subagents and durable workflows: status and navigation, deterministic deep-chain layout, fit/pan canvas controls, and current-session node rearrangement.

Plan review with anchored annotations and structured feedback back to the agent.

Visual round-table meetings for DeepSeek Harness — expert nodes on a ring with directed edges, an aggregation gateway, proxy thinking for black-box worker models, and adversarial review (red-team) of settled plans with per-viewpoint endorse/reject.

On-demand second opinions through ask_advisor, with editable requests, per-call human approval, and text advice from a model configured in DSH.

Cron scheduler with a sidebar UI: run shell, Python or Node scripts, skills, or agent tasks on a schedule, with push notifications and session archiving.

AI Company Framework: turn one sentence into a multi-agent company — 15 flat Skills (boss/pipeline/role-template/11 roles/generic customer-memory), 7 workflow templates, AgentTeams runtime + activity panel, employee sidebar with per-session isolation, Feishu bot bridge (boss and per-employee bots, group routing, autonomous push, human decision gate, external-contact guide), per-customer SQLite memory with three-layer memory (cross-group merge), /company mode switch; no RAG.

Peer-to-peer colleague-agent consultation for DSH: ask one or several configured peers, queue asynchronous questions, discover peers through signed friend cards, and review inbound requests in the Web UI.

Question-Driven Discovery research workflow for DeepSeek Harness with a QDD Agent Preset, durable Human and Auto runs, and an auditable research panel.

Visual node-based workflow canvas for DSH with sub-agent calls, code execution, branching, loops, scheduling, and workflow import/export.

Dispatch self-contained tasks from DSH to 11 external agent CLIs (Codex, Claude Code, TraeCode, OpenCode, Gemini, Cursor, Kimi, Qwen, Copilot, WorkBuddy, Grok): a host-only bundle registering the conductor_dispatch tool plus an auto-triggered conductor skill.

Adversarial checkup → fix → review loop toolset.

AI can write resume text, but templates may still look wrong, pages may overflow, whitespace may remain, and small edits can destabilize the layout. dsh-resume provides an end-to-end DSH workflow for truthful content refinement, template selection, A4 layout tuning, visual review, and tailored resume versions for different job-search scenarios.

Host-side unattended job scheduler: runs one-shot agent tasks or shell commands on cron, interval, or one-time schedules, with persisted at-most-once dispatch state, overlap/misfire policies, and bounded run history.

Engineering workflow agent preset for dsh: five gated phases (requirements clarification, plan approval, TDD, parallel subagents, verified finishing) with six workflow skills adapted from obra/superpowers.

Kanban board for DSH: task state machine with git branch isolation, agent auto-execution, and review-driven merge.

Embedded task management engine: decision-point protocol, idea capture wall, Linear-style issue store.

Coordinate independent DSH Sessions and provider-backed members without merging their histories, using persistent native Rooms with identity-bound leading `@` mentions, direct delivery, broadcasts, and leader-scoped controls.

Lifecycle orchestration engine for AI agent teams with task-scoped Git worktree isolation, state-gated delivery transitions, and off-context memory.

Adds persistent execution contracts, recursive work graphs, critical clarification, and evidence gates for long or underspecified Harness tasks.

Six-stage WeChat Official Account content-publishing workflow with quality-gate tools and a bundled skill.

DSH port of TaskPlane: dependency-ordered waves run in parallel git-worktree lanes, with task packets, cross-model review, and crash recovery.

Agent preset that turns multi-stage objectives into resumable flows: refereed stages, SHA-256 lock identity, an HMAC-signed terminal review gate and event-sourced run logs; ships 15 agent tools.

GPT plans dependency DAGs, DeepSeek workers execute tasks with adaptive parallelism, and an optional GPT reviewer audits incremental Git diffs and drives repair rounds.

Proactive scheduling: an adaptive heartbeat plus a value network (urgency, relevance, interruption cost) decides when the agent should speak unprompted.

Advisor reviews that converge over rounds, an engineering mode whose writes require a design token, escalation of a task to a stronger model, and parallel multi-model consultation; a settings page edits the model routes, timeouts and budgets.

Full local-first issue board embedded in the DSH web GUI: Kanban / list / Gantt / workflow / dashboard views, AI chat per task, attachments and labels, auto-claim of todo tasks driven by dsh-routines — data lives in local SQLite (dsh plugin add @ttmouse/dsh-taskboard).

Publish articles to CSDN / Juejin / CNBlog directly from the session, no external server.

Google Antigravity CLI (agy) as a DSH product subagent: delegate tasks to a Gemini coding agent with your Antigravity login (no API key), with conversation follow-ups, background streaming progress, image analysis by path, and a pop-up login window.

Task planning with experience muscle-memory: condition-reflex recall of past solutions, LLM capability matching, and auto-persisted lessons.

Verification gate for DSH agents: every acceptance criterion must be backed by server-stamped real tool evidence before the completion gate lets a goal through (advisory audit, enforce gate, durable permits).

Turns each DSH workspace into a project: every new session auto-injects a project-workspace convention (read code before acting, empty folder means a brand-new project); a per-session Project toggle in the composer downgrades the session to a plain workspace with an explicit notice, with the state kept in the session log.

Canvas task board ported from CodexFF: hierarchical parent/child tasks with boundaries, snap-aligned draggable panels in a conversation view tab, plus `board_*` / `task_*` agent tools and a sync skill.

Runs a thesis-antithesis-seal debate whose verdict is computed from real command exit codes and case counts, never from agent prose.

Council of High Intelligence: assemble an 18-member think tank of historical figures for multi-perspective structured debate, with a live DAG side panel, SQLite run history, and per-project defaults via .council.yaml.

Whole-report verification for scientific reports: per-claim checks against Crossref, PubMed (retraction scan), ClinicalTrials.gov, UniProtKB, GEO/SRA and PatentsView, URL accessibility and title agreement, claim-vs-source meaning at temperature 0, and a durable restartable audit ledger with an annotated report.

Explicit cross-session work state for DeepSeek Harness: goals, decisions and next steps captured automatically from host events or via a model-visible work_state tool, inspectable with /checkpoint.

Turns the iterate skill into an autonomous closed-loop harness — plan, parallel review, atomic fixes, validate, loop, auto-stop — plus a dry-run review-only mode and a meta-review that audits the report and emits a final review report.

Supervisor-style workflow orchestration over top-level sessions: confirmation-gated batch dispatch, team workstreams, steering running tasks, idle-wait collection and live model-route discovery across 11 task_* tools plus a /tasks slash command.

Evidence-first operating kit: six read-only tools (capability catalog, staged workflow plans, packaged skill reader, bounded local memory search, repository release audit, release checklist) and five packaged skills - plans and audits, never remote writes.

A structured multi-panelist review workflow for the DeepSeek Harness: N panelists score in isolated subagents, blind to each other; a chair reconciles disagreement by anchor match then Δ-level adjudication; an independent critic audits the process. Works for design, code, paper or project review.

Extends dsh-subagent-tools with a per-call cwd for subagents, shipped with the two in-process provider patches it requires.

Per-call model, provider, persona, and toolFilter overrides for subagent delegation, with @preset: references and provider/model composite ids.

Visual drag-and-drop workflow builder for DSH — orchestrate tool calls, sub-agents, and conditional branches on a React Flow canvas.

More agent presets for DSH, derived from other coding agents such as Qwen Code and iFlow.

Long-task orchestration loop: Codex plans/scores/reviews, DeepSeek executes, Kimi supplements (vision acceptance, summarization, cross-check).

Settings-based scheduled tasks that run on time or during DeepSeek off-peak hours, with one-time and daily schedules backed by durable task state.

One-click launcher for DeepSeek Harness: detects whether the backend is running, starts dsh web if needed, waits until ready, then opens the main page in a new Chrome window. Ships a cross-platform CLI (dsh-launcher start / open / status / make-shortcut) and the harness_launch agent tool.

Surveys local code and GitHub/npm for reusable implementations before development, evaluates reuse versus rewrite, and checks architecture coupling.

Keeps a local task-outcome ledger for DSH, verifies acceptance criteria from deterministic evidence, records user disposition and token usage, and supports digest-bound export.

Convert Office documents and PDFs (including scanned ones) to structurally formatted Markdown via a CPU-first routing OCR pipeline (RapidOCR/SLANet/FormulaNet).

Export and import DeepSeek Harness configuration across machines as same-OS .dshmig archives, with credential redaction, verification and rollback.

Bot Mode for DeepSeek Harness: a roster of named bots with avatars, personas and per-bot chats, each backed by one durable continuable subagent session that keeps memory across turns.

21 read-only lifecycle governance tools in one self-contained DSH plugin: task tiering, state/plan/evidence validation, gate precheck and aggregation, release/install audits, context and progress analysis, critical path, resume reconciliation, and a mutation preview that always denies execution. Installs from npm as @240xu/dsh-tech-lead.

Appends ambiguity-handling rules to the dsh system prompt so the agent asks clarifying options before guessing.

Independent read-only acceptance layer: spawns a read-only verifier before each top-level turn closes and steers non-pass gaps back into the agent.

Generates a standard motor-repair procedure from the diagnosis and motor rating, with labour time, staffing and a quality-check point for each step.

Cordis-native, evidence-driven full-stack engineering workflow: inspect-first planning, explicit verification evidence, and approval-aware gating for sensitive operations.

Group-chat multi-agent orchestration console for DSH: autonomous decision-making, task dispatch, verification and iterative optimization for long tasks; bundles its own backend, installs with `dsh plugin add`.

Ultra-lean daily coding agent preset for DeepSeek Harness (dsh) that strips heavy orchestration for fast, direct tool execution.

Clusters arXiv, first-party lab, official artifact, hardware-vendor, and opt-in X signals into versioned release evidence bundles, then gates claim-level reproduction on commands, artifacts, metrics, and verifiers.

Product Design workflow suite for DeepSeek Harness - a router plus nine pd-* skills carrying ideas from a minimum design brief through visual directions, evidence-grounded research and audits, URL cloning, frontend builds and a blocking design-QA gate.

A project-agnostic multi-agent collaboration protocol for the DeepSeek Harness: loop guards that stop runaway agent loops, a six-field handoff format, risk-tiered review routing, and a fixed verify→commit→push→review→close sequence. One skill instead of the same rules copy-pasted into every agent's instructions.

Meeting rooms for DSH sessions: joining a room grants the right to convene and the duty to attend, and a session belongs to at most one room. Convening forks each participant in with its own completed-turn context and with its tools stripped, a moderator that carries no context chooses the speakers, and every turn is appended to disk as it is spoken. After adjournment each participant receives its own minutes as a user turn and resumes work.

An approval-gated OME engineering delivery preset with session-isolated lifecycle evidence.

Installs two selectable Agent Presets: a shell-restricted general-purpose agent and a repository-focused coding agent.

AI self-discipline companion for DSH with one-time and recurring tasks, desktop evidence, native reminders, and window, tab or process intervention on Windows and GNOME Wayland.

Cron/one-shot scheduled tasks: run shell commands or fire webhooks on a schedule, with optional ServerChan/DingTalk/Feishu/webhook delivery of results.

Antigravity-style run_command for DSH: short commands return inline within a configurable wait window (default 10s) while longer ones auto-promote into ctx.jobs for later collection and completion notices — executed via ctx.shell under the session sandbox and approval pipeline.

Preset workflow template library: 12 reusable orchestration script templates with wf_template_list / wf_template_search / wf_template_run / wf_template_validate tools and static template validation.

Workflow tools for the local aflare binary: generate, validate and run local-first deterministic YAML workflow DAGs (WAL crash recovery, Saga compensation) through the local aflare binary, with 300+ templates built in.

Parse PRDs and PDFs, ask clarifying questions in batches, consolidate a BRIEF.md system brief, and package deliverables for upload.

Auto Mode for DSH: a flash-model router that auto-picks the best agent preset (standard/code/minimal/cordis) for each new session and executes immediately, no confirmation.

Automatically orchestrates complex DeepSeek Harness requests. It detects when delegation is useful, builds a dependency-aware plan, assigns bounded researcher, architect, backend, frontend, tester, and documentation workers, collects structured evidence, and sends the results to a final reviewer. The bundle atomically enables the workflow engine and model-facing subagent tools; disabling the plugin disables its complete tool group as well.

Mind-map project planning with blocking drift protection: plans, modules and tasks as a dependency DAG with topological execution order, an agent position marker, a human approval gate on every board edit, git cross-checks, and evidence-gated task completion.

Scheduled agents on a cron: run a prompt on a schedule and get the digest where you already are, with overlap/missed-run/timeout safety defaults.

Disk-persisted execution planning for DSH: milestone/step state machines, dependency gating, an audit event stream, and a deterministic completion gate via dsh tools, CLI, or skill.

Recurring task scheduler with an append-only delivery ledger: window-aligned dedup execution, failure/abandoned rows, and same-window retry redelivery.

Multi-agent isolated debate for DeepSeek Harness: debaters of different temperaments research independently (no herding), then cross-examine, then judges converge to a conclusion. Runs as a background job with per-agent progress, token accounting, wave-parallel execution, and session-referenced resume.

An agent preset that turns a one-line idea into requirements, tech plan and maintenance baseline — every step is restated and confirmed by you before proceeding. No scenario presets: 73 atomic skills (6 master skills + a verify dispatcher + 66 sub-skills) load by context.

Records scoped workflow rules and correction reminders with bounded evidence, local settings, and optional Brain Hub integration.

Discover and run project tasks through Harness Jobs, inspect run receipts, and check project configuration with an Agent tool.

Orchestrates durable multi-agent teams from one DSH session: a captain spawns member subagents, drives a dependency-aware task DAG with quality gates, and coordinates through persistent mailboxes, with a live activity panel.

External Agent control plane for Codex, Claude Code, Cursor Agent, and Antigravity adapters with settings and background job visibility.

Optimized fork of dsh-image-gen with batch generation (count), gallery pagination, lazy loading, fetch retry/timeout, and 7 providers: Gemini/OpenAI/Seedream/DashScope/Agnes/GLM-Image/Stability AI.

Turns a product or UI request into an implementation-ready design spec with /ui-workflow and /ui-rerun. Analysts run through a read-only ui_analyst tool, and the lead agent writes docs/ui-workflow reports.

✨ One-click prompt polisher for the DSH composer — an agent refines your rough draft in a side chat over multiple turns, and you copy the result back when you're happy.

Jimu (积木): domain-based orchestration plugin for DeepSeek Harness — domain_plan confirmation, per-domain sub-agents with hand-off, and automatic LLM audit.

Self-media workbench plugin: 8-tab dashboard (daily brief, narrative lines, topics, drafts, knowledge-card distill review, sources, publish, advice) with hard guards (48h window, event dedup, card/line existence, read-only advice) and a read-only intel module following the four red lines.

Scheduled DeepSeek Harness Agent tasks with mandatory end-to-end tests, run history, and bidirectional delivery through nine messaging channels.

Auto-send every DSH turn result to WeChat: listens for task completion, extracts the final assistant message and pushes it raw via the WeChat iLink bot (real delivery check, never fake success). Requires the wechat-acp daemon, a separately installed process you log into WeChat with.

Maintains reusable named subagent profiles for DeepSeek Harness and runs them with per-profile model, reasoning effort, and agent-preset settings.

Whole-book translation production line for DeepSeek Harness: deterministic chapter detection and segmentation, per-chapter subagent translation, glossary control, full-book review, targeted revision, and auditable meta.json evidence.

AlphaRSI — three-role self-improvement loop that evolves the training recipe of alpha sequence models. Operator runs walk-forward, Evaluator grades with OOS RankIC, Refiner proposes hyperparameters via TPE Bayesian search; only strictly-better recipes are kept. Offline one-command run, data bundle shipped with sha1 reconciliation, GPU auto-detect. Ships one skill.

Training attestation — reproducible, attributable, auditable off-site standardized training for asset pricing. Hard-gates four failure modes (half-refresh, hash mismatch, unknown-read-as-pass, master pollution). Ships one skill.

Persistent personal todos shared across DeepSeek Harness sessions and projects: SQLite storage, Agent tools, a native sidebar and turn-tail cards, with user-managed workflows or optional dispatch of individual todos to Agent sessions.

Execution flow chart: renders the current session's execution as a vertical node flow (turns, user, assistant, tools, approvals, retries, compaction), appended in real time over SSE with auto-follow scrolling — the chart draws wherever the session executes.