Preface¶

DeepSeek Harness (hereinafter referred to as DSH) is an open-source agent runtime developed by DeepSeek, with the slogan “Everything is a plugin”: models, tools, skills, and interfaces can all be loaded into the same process as plugins. The official repository is currently in developer preview, and its interfaces are subject to change. The community also maintains a plugin directory site for retrieving third-party plugins; this site has no official affiliation with DeepSeek / Fangfang (Huifang) and should not be treated as an official app store.

It is already common for agents to write code and look up information, but when it comes to delivering a complete lecture—complete with slides, simulators, and interactive sessions—users often have to switch to other products. The dsh-openmaic maintained by the THU-MAIC team at Tsinghua University was developed to fill this gap: it integrates OpenMAIC into DSH, allowing agents to generate lecture-ready links during conversations and render slides, interactive components, and teaching cards in-place.

This article is cross-verified based on the plugin directory page, the GitHub repository’s README, package.json, source code, and the official DeepSeek Harness repository. The installation commands are based on the original text from the directory page, and the web profile installation method recommended by the repository will be noted separately.

What is This¶

dsh-openmaic is a plugin for DeepSeek Harness, maintained by THU-MAIC, licensed under MIT, and primarily written in JavaScript. Its npm package name is @openmaic/dsh-openmaic, and the current version in the repository’s package.json is 0.4.0. The community directory categorizes it under “Models and Providers”. As of the GitHub API query on 2026-08-17, the repository had 13 stars; the directory page still shows 8 stars, which is more like a snapshot taken at the time of inclusion. The GitHub repository was created on 2026-08-13, which matches the latest push time shown on the directory page.

OpenMAIC stands for Open Multi-Agent Interactive Classroom. According to openmaic.io and THU-MAIC/OpenMAIC, it is an open-source teaching platform developed by the THU-MAIC team at Tsinghua University: given a topic or document, it can generate an interactive classroom complete with slides, quizzes, and simulators. dsh-openmaic does not embed the full OpenMAIC suite into DSH; instead, it does two things: first, it submits generation requests to https://open.maic.chat, waits for the asynchronous task to complete, and returns a playable classroom link; second, it allows agents to generate slide JSON, interactive components, and HTML snippets according to the OpenMAIC SDK conventions, and renders them in-place in DSH conversations using the official renderer.

Core Features¶

The repository’s README states that the plugin registers four tools and one Socratic teaching skill. This matches the dsh.plugin.json and dshx.contributes field in package.json.

1. openmaic_generate: Generate a lecture-ready link in one sentence

When a user says “Help me create a lecture on XX”, the agent submits the teaching requirements to open.maic.chat, polls the asynchronous task, and returns the Classroom ID and playable classroom URL once successful. The optional parameters in the source code include:
- language: zh-CN or en-US
- enableWebSearch / enableImageGeneration / enableVideoGeneration / enableTTS
- agentMode: default or generate

The system prompt requires that these optional switches are only passed when explicitly requested by the user, and the classroom URL should be returned to the user as a bare link upon success.

2. openmaic_slide: Render a single OpenMAIC slide

The agent first loads the openmaic-slide skill, writes a PPTist-style Slide JSON (viewportSize, viewportRatio, and elements such as text, image, shape, chart, code, latex, table, etc.), then calls the tool. The plugin uses the official OpenMAIC renderer to draw the slide, supporting rendering of text, shapes, images, tables, charts, formulas, and code. This is for a single slide, not an entire courseware export.

3. openmaic_widget: Stream interactive components and render them as inline cards

Designed for simulators, games, or runnable code challenges. The agent writes a complete HTML document according to the bundled contract, with the code displayed in real-time during writing, and rendered as a sandbox card in the conversation once completed. Currently supported widgetType values are simulation, game, and code. The README’s roadmap also mentions diagram, visualization3d, and procedural-skill, which are not yet implemented and should not be treated as delivered features.

4. openmaic_render: Render teaching HTML snippets as sandbox cards

Used for concept cards, quizzes, and step-by-step explanations. The input is an inline HTML snippet (markup + style + optional script) without a full document skeleton. The source code sets a maximum single-snippet size of 256 KB. The return value for the model is just a confirmation line to avoid re-injecting the snippet into the context; the browser side replays the same card using persisted meta data.

5. openmaic-teach skill: Socratic teaching

Turns the current conversation into an OpenMAIC lesson focused on question-guided learning, and calls the aforementioned slides, components, and cards as teaching aids as needed. package.json also contributes three writing contract skills: openmaic-render, openmaic-widget, and openmaic-slide, for the model to load before first calling the corresponding tools.

One important boundary to clarify: openmaic_generate calls a remote (or self-hosted) OpenMAIC service; openmaic_slide / openmaic_widget / openmaic_render do not perform server-side generation, they only render content written by the agent according to the @openmaic/dsl, @openmaic/generation, and @openmaic/renderer specifications.

Installation and Activation¶

The installation command given on the directory page is:

dsh plugin add github:THU-MAIC/dsh-openmaic

For reproducible installations, the directory page recommends pinning the commit hash:

dsh plugin add github:THU-MAIC/dsh-openmaic#commit

Replace #commit with the actual commit SHA. The repository’s README provides the following command for the Web UI profile:

dsh plugin --profile web add git+https://github.com/THU-MAIC/dsh-openmaic.git

Then restart dsh web and refresh the page. The README notes that the repository already includes the compiled lib/ directory, so no build steps are required when installing via Git. The dsh.client.platform field in package.json is web, meaning the client side is intended for the web interface.

The configuration items match the defaults in the README and source code:

dsh-openmaic:
  baseUrl: https://open.maic.chat
  accessCode: ""     # Invitation code; not enforced on the public instance yet, leave empty for now
  pollIntervalMs: 5000
  maxWaitMs: 600000

The timeout for openmaic_generate aligns with maxWaitMs. If a timeout occurs, the error returned by the source code will prompt that the classroom may still be generating in the background and can be checked later.

Typical Usage¶

The following two examples are from the repository’s README, and can be tested in DSH conversations in the same way.

Generate a lecture

User: Help me create an introductory course on quantum physics
Model → openmaic_generate(requirement="Introductory quantum physics course", language="zh-CN")
     ← "Classroom ID: class-abc123
        Classroom URL:
        https://open.maic.chat/classroom/class-abc123"
Model: The classroom has been generated, you can open it to start the lecture:
     https://open.maic.chat/classroom/class-abc123

The actual ID and URL will be based on the service’s response. The generation flow is the same chain described in the README and src/client.ts:
1. If an accessCode is configured, first send a POST /api/access-code/verify request, then include the openmaic_access cookie in subsequent requests.
2. Send a POST /api/generate-classroom request with the requirement and any optional switches you pass in the body, and get back a jobId and pollUrl.
3. Send a GET {pollUrl} request repeatedly until the task succeeds (succeeded), fails (failed), or the maxWaitMs timeout is reached.
4. On success, return {baseUrl}/classroom/{classroomId} or the result.url provided by the service.

Create an interactive simulator

User: Create a projectile motion simulator
Model → Write the complete HTML following the openmaic-widget template (streaming output)
     → openmaic_widget(html="<!doctype html>…", widgetType="simulation", title="Projectile Motion")
     ← "Rendered the simulation widget …"
     An interactive OpenMAIC simulator appears in-place in the conversation

The same logic applies to slides and teaching cards: first have the agent load the corresponding skill, then call openmaic_slide or openmaic_render respectively. For a complete playable lecture, use openmaic_generate; for an immediate slide or sandbox component in the conversation, use the latter three tools.

Applicable Scenarios and Notes¶

This plugin is suitable for the following situations:
- Preparing and rehearsing lessons in DSH, needing one-click generation of playable OpenMAIC classrooms.
- Wanting slides, formulas, and charts to appear directly in the conversation when explaining concepts, instead of just outputting Markdown.
- Needing embedded simulators or mini-games for physics, algorithms, and similar content.
- Wanting to use Socratic questioning to guide learning, and easily pulling up cards or slides for assistance.

There are several points to keep in mind before using:
The plugin runs with the permissions of the current DSH process, and may execute code during installation. Please inspect the source code repository and license before installing; for reproducible installations, pin the commit hash.

openmaic_generate depends on the availability of the service pointed to by baseUrl and queue length. The default points to the public site open.maic.chat, and classroom content is not generated locally in the DSH process. When self-hosting OpenMAIC, point baseUrl to your local machine; the main OpenMAIC repository uses AGPL-3.0, which is a different license from this plugin’s MIT, so review it separately before self-hosting.

As per the README, accessCode is “not enforced on the public instance” for now. Once the server enables validation, an empty string will not work, and you will need to fill in the invitation code.

Client-side rendering is for the Web UI. Slides, components, and cards appearing in the conversation depend on the browser side; do not expect “sandbox cards appearing in-place” in a pure terminal environment. The openmaic_widget renders the complete HTML written by the agent, and although it is in a sandbox card, it should still be treated as untrusted content.

The repository roadmap also plans to: complete the remaining widget types, and pass teaching actions (highlighting, annotations, revealing component elements) back to the model. These are future directions and are not available in the current version.

DSH itself is still undergoing rapid iteration, and the official README notes that breaking compatibility changes may occur. The plugin declares an engine requirement of dsh >= 0.0.1, but whether it can actually be loaded depends on your current Harness version.

Summary¶

dsh-openmaic integrates Tsinghua University THU-MAIC’s OpenMAIC into DeepSeek Harness: a single request can return a playable lecture link, and slides, simulators, and teaching cards written by agents can be rendered directly in conversations. It solves the gap of “agents can explain concepts, but cannot deliver a complete lecture”, rather than replacing the OpenMAIC platform itself.

Plugin Directory: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-openmaic/

GitHub: https://github.com/THU-MAIC/dsh-openmaic