Preface¶

In DeepSeek Harness (DSH), the common approach for math tasks is to let the model derive directly in a single session. When the derivation chain becomes lengthy, intermediate steps are difficult to review; once a conclusion is recorded in notes, it’s also hard to distinguish between “verified” and “to be discussed.” If you want to separate exploration, solving, and review into a resumable workflow, you often have to orchestrate sub-agents, persist state, and manage verification processes yourself.

Below, we introduce the community plugin Vibe Mathematics (chongcyrus/vibe-mathematics). It encapsulates multi-agent collaboration, cross-validation, and knowledge accumulation into a set of agent presets. Once installed, you can select it directly in the DSH preset selector, using natural language to drive the entire process.

What It Is¶

Vibe Mathematics is a DSH workflow plugin released by maintainer ChongCyrus, with the npm package name dsh-vibe-math, current version 1.4.1, licensed under MIT. The project has 9 stars on GitHub.

The plugin is positioned as a “multi-agent mathematical problem-solving and formal verification framework.” A single installation writes four agent presets—vibe-math-v1, vibe-math-v2, vibe-math-v3, and vibe-math-v4. The four generations share foundational capabilities like resumable execution, mid-process human intervention, progress reporting, and natural language driving, but differ in their solving and scheduling methods.

• vibe-math-v1 (classic pipeline): Deprecated; not recommended for new projects.
• vibe-math-v2 (probability-driven · JSON data layer): Recommended for scenarios preferring structured JSON and deterministic scheduling.
• vibe-math-v3 (paper-style Markdown + planning agent + method repository): Recommended for scenarios requiring a readable knowledge base, planning-based scheduling, and method accumulation.
• vibe-math-v4 (persistent self-organizing collaborative research): Experimental; autonomous division of labor and verification by persistent resident sub-agents.

Core Features¶

Multi-Agent Automatic Solving and Cross-Validation¶

In v1/v2/v3, the main agent receives natural language requests, and a code scheduler dispatches sub-agents like explorer, solver, and verifier to collaborate; v3 additionally introduces a planning agent (Planner) and a method-keeping agent (Method Keeper). Each conclusion to be verified is assigned to at least 3 independent verifiers: independent review → debate → adjudication. v3 defaults to near-consensus adjudication (taking the average when votes are on the same side and the average score ≥0.85 or ≤0.15) to reduce misclassification of high-confidence disagreements as uncertainty.

Data and Scheduling Differences Across Four Generations¶

v2 centers on a qs.json question list and a Propos/ proposition library, using priority and probability for heuristic scheduling; after verification passes, the probability is set to 1, and the conclusion moves to Verified/.

v3 stores all knowledge in paper/research-report-style Markdown: Problems/ (question list and dependencies), Progress/ (research logs), Propos/ (proposition library), Methods/ (general theoretical invention repository), and Verified/ (absolutely trustworthy). Before scheduling, the planning agent arranges the next N actions in one go; if planning fails, it automatically falls back to v2-style heuristics. During solving, reported methods_used / new_inventions are accumulated by the Method Keeper into reusable method cards.

v4 removes the central planner and fixed roles, replacing them with N persistent resident sub-agents that communicate via messages and meetings to autonomously decide task arrangements. Verification is only written to Verified/ when all resident agents reach a unanimous verdict (all 1 or all 0); otherwise, it is retained in the library with a probability attached. When context usage reaches a threshold (default 66%), /compact is triggered; the process stops only when all agents unanimously agree the original problem is solved.

Engineering Capabilities¶

• Resumable Execution: Scheduling state, task stack, agent registry, etc., are persisted to disk. After restart, resume via vibe_math_resume or vibe_v4_resume.
• Mid-Process Human Intervention: Supports switching between auto / manual modes. In manual mode, it suspends at key checkpoints for approve/reject/override; v3 also has a plan approval gate and a method promotion gate.
• Project Isolation: Each math problem corresponds to an independent project folder, allowing easy switching.
• Multi-Session Parallel Isolation: The plugin isolates runtime state by root session ID, enabling different sessions to run different projects concurrently (v3 uses a project lock for the same project).
• Configurable: Parameters can be configured via vibe_math_setting.json or interactively with /vibe setup; v4 parameters are persisted in State/settings.json.

Installation and Activation¶

The plugin can be installed via npm or from GitHub source. Replace <your profile> with your actual DSH profile name (e.g., web):

dsh plugin --profile <your profile> add dsh-vibe-math

Or install directly from GitHub:

dsh plugin --profile <your profile> add github:ChongCyrus/Vibe-Mathematics

After installation, the presets will be written to ~/.dsh/.agent-presets/, and four Vibe Math presets will appear in the DSH preset selector. To upgrade the package version, use:

dsh plugin update dsh-vibe-math

After upgrading, DSH needs to be restarted; preset files that have not been manually modified will automatically update to the new version.

Version Dependency: The project has been thoroughly tested on dsh-v0.1.1-rc.2 (minVersion is 0.1.0-rc.7). v3 requires the fs API shape from DSH 0.1.1 onward. The installer performs a capability self-check at startup and logs a warning if requirements are not met.

Typical Usage¶

Natural Language Driving (v2/v3)¶

The main agent has built-in usage instructions and can accept natural language descriptions of goals. For example, to prove that √2 is irrational:

Help me use Vibe Math to prove that √2 is irrational.

The main agent will sequentially call vibe_math_add_problem to add the problem and vibe_math_start to start scheduling. You can then query progress at any time:

How's it going now?

The main agent will call vibe_math_status / vibe_math_report and report in plain language.

For precise control, you can also directly call tools or use slash commands /vibe start|resume|pause|abort|status|report|mode (v3 has additional methods|index|plan|lock).

v4 Configuration and Startup¶

v4 separates project configuration from startup. First, use vibe_v4_configure to create the project and set parameters (without waking up resident agents), then use vibe_v4_start to start:

vibe_v4_configure {"project":"sqrt2","problem":"Prove: √2 is irrational."}
vibe_v4_start

For daily adjustments, use the /v4 command and vibe_v4_* toolset (e.g., vibe_v4_message, vibe_v4_resume, vibe_v4_set).

Parameter and Mode Switching¶

Interactive configuration example:

Help me configure the parameters.

The main agent will call vibe_math_setup to retrieve the parameter schema, ask for each item, and then apply it via vibe_math_set_params. You can also directly say:

Switch to manual mode; I want to oversee every key checkpoint.

The main agent will execute vibe_math_set_mode {"mode":"manual"}, after which it will list pending decisions via vibe_math_list_decisions at key checkpoints for you to approve / reject / override.

Choosing a Preset¶

v2 and v3 share the same set of vibe_math_* tools and /vibe commands, with low switching costs. v4 uses independent vibe_v4_* tools and /v4 commands.

Applicable Scenarios and Notes¶

Who It’s For

• Those who need to turn mathematical exploration in DSH into a resumable, reviewable multi-step workflow.
• Those who want to use multi-agent cross-validation to reduce error rates in single-model derivations.
• Those who prefer to accumulate intermediate artifacts (propositions, research logs, method cards) into an in-project knowledge base rather than having one-off conversation outputs.

Pre-Use Notes

1. The plugin runs with the permissions of the current DSH process. Sub-agents can read/write workspace files and invoke authorized tools. Before installation, read the GitHub source code and the MIT license to confirm they meet your security requirements.
2. In v3, only Verified/ and objects verified as true/false by verifiers are absolutely trustworthy; other Markdown (including unverified assertions in the method repository) is only for experiential reference.
3. v4 is an experimental architecture with stricter verification criteria (requires unanimity) and more conservative stopping conditions (requires all agents to agree the problem is solved).
4. Multi-agent parallelism consumes significant tokens and API quotas. You can control concurrency and verification intensity via parameters like maxParallelThreshold and verifierCount.
5. SkillHub (Directory page) is an independent DSH plugin community site, with no official affiliation to DeepSeek or High-Flyer. Installation and version information are based on the project README and npm page.

Conclusion¶

Vibe Mathematics encapsulates “exploration → solving → cross-validation → knowledge accumulation” into an installable DSH workflow, providing two mature mainlines (v2/v3) and an experimental line (v4), with support for resumable execution and human intervention. If you are handling mathematical problems in DSH that require traceability and reviewability, you can try the corresponding preset based on your scenario.

• Directory page: https://www.skillhub.cn/plugins/ChongCyrus/Vibe-Mathematics
• GitHub: https://github.com/ChongCyrus/Vibe-Mathematics
• npm: https://www.npmjs.com/package/dsh-vibe-math