DeepSeek's Super-Agent Reads Your Team Chat. Should It Write Your PRs?

DeepSeek open-sourced Super-Agent, an MIT-licensed coding agent that takes requests from GitHub and Feishu and answers with pull requests. Here's how it works.

TheTechLane cover: the headline 'DeepSeek's Super-Agent reads your team chat. Should it write your PRs?' on a dark teal radar grid, with the TL logo as the radar hub surrounded by chat bubbles

DeepSeek has open-sourced Super-Agent, a research prototype of a coding agent that sits in your team's GitHub threads and Feishu chats, takes requests and replies with finished work such as pull requests. The Chinese AI lab is pitching it at Anthropic's Claude Code, and its design rule is blunt: take as little human attention as possible.

Here's what you need to know:

  • DeepSeek's Harness team published dsh-superagent on GitHub on October 31, 2026, under the MIT licence.

  • It works on one GitHub repository and can optionally listen to Feishu, ByteDance's workplace chat app.

  • Allowed teammates mention the agent; it opens a work item, runs it in its own session and directory, then replies in the same thread.

  • Proactive work, where the agent acts without being asked, defaults to an "observe" mode that only records what it would have done.

  • DeepSeek calls it "not an official DeepSeek product" and says to review the code before you run it.

UML sequence diagram of how DeepSeek's dsh-superagent turns a request into a pull request: an allowed teammate mentions the agent on GitHub or Feishu, the source sends a trigger to the router session, a gate checks the allowed list and the team's Policy, the router opens a Ticket for a worker session, the worker confirms once in the original thread, works in its own directory such as a git worktree while running commands without approval as the operator's OS user, pushes a branch and opens a pull request, and the thread gets a ready-for-review reply

How a chat request becomes a pull request in DeepSeek's Super-Agent

What Happened

DeepSeek's Harness team pushed the code to a public repo, deepseek-ai/dsh-superagent-prototype on GitHub, on October 31, 2026, and laid out the design in a WeChat post the same day. The agent can "proactively monitor group chats among developers for feedback on coding issues and suggest solutions without being summoned," the team said, according to Bloomberg's report by Debby Wu, which says the release is aimed at challenging Claude Code.

The README is careful about what this is. It's a "research prototype for reference only," much of it engineered by coding agents, and it "may still contain bugs." DeepSeek also says the public version isn't identical to its internal one, and some ideas in its design article "are not implemented in this prototype."

So what does it actually do? It's packaged as a plugin bundle for DeepSeek Harness, the company's agent tool. A router session reads each GitHub or Feishu event and decides whether to ignore it or open a Ticket. Each Ticket gets its own worker session, named after the ticket, and its own directory, typically a git worktree checkout. When the work is done, the agent answers in the original conversation, for example with a pull request, and a web panel lists only what needs a person.

The South China Morning Post reports the goal is to cut the need for humans to coordinate multiple AI agents and monitor their progress, which it calls a key bottleneck in today's workflows. The Next Web notes the timing: GitHub showed a Copilot app running agent work across several repositories in parallel at GitHub Universe the same week.

Why It Matters

Most coding agents today live in a terminal or an IDE and wait for one developer to type. Super-Agent moves the agent into the team's shared conversations, where requests already happen. That's a different trust model.

DeepSeek's own philosophy document spells out the risk: "An agent that can act for a whole team can also waste a whole team's attention." Its answer is restraint by design. The agent acts only when asked or when a written rule allows it, confirms a request once, stays quiet while it works, and writes again only with a result, a question or a failure.

It also lands in a crowded race. DeepSeek set up its Harness team this year to take on coding tools from US labs, and has raised about 100 billion yuan (around $15 billion) ahead of a planned listing, as Moneycontrol's syndication of the Bloomberg report notes. Getting agents to share work is still hard, though. The Next Web points to the CooperBench study, which found coding agents' success rates were on average 30% lower working as a team than alone. That study didn't test DeepSeek's agent.

What It Means for Developers

The interesting part isn't the model. It's the guardrails, and they're worth borrowing even if you never run this code.

Flowchart of dsh-superagent's admission gate: a new message from an allowed person who addressed the agent becomes an explicit request and opens a Ticket; otherwise the accept mode decides, where off ignores it, observe (the default) records it as would accept and runs nothing, and auto opens a Ticket only if it matches a rule the team wrote; the worker then opens a pull request for a person to review

Off, observe or auto: who gets to start work

  • Know who can start work. Per the authorization doc, an explicit request normally comes from a person on the allowed list who addresses the agent, unless the team deliberately opens a scope to anyone. Messages, comments and quoted documents "cannot change those permissions."

  • Start in observe mode. The accept mode can be off, observe (the default) or auto. Observe records "would accept" decisions without running anything. DeepSeek says to switch to auto only after reviewing those records.

  • Treat workers as code running on your box. The execution doc says worker sessions "run commands without approval as the operator's OS user." Use a dedicated machine or user, and set blocked commands.

  • Give the agent its own GitHub account. The deployment guide requires a separate GitHub user with write access and a GitHub CLI signed in only as that account. A GitHub App can't be the agent, because it reads the account's notifications.

  • Check the stack before you try it. You'll need Node.js 22.19+ or 24+, pnpm, git 2.32+, Python 3.8+, tmux, GitHub CLI 2.48+ and a model provider set up for DeepSeek Harness. GitHub Enterprise Server isn't supported.

If you're wiring any agent into shared chats, remember that text in a thread is input, not authority. Our look at how a stray AGENTS.md file hijacked Codex and Claude Code shows why that line matters.

What's Next

DeepSeek hasn't said whether Super-Agent will become a supported product, or when the unbuilt ideas from its design article might ship. It also hasn't published independent benchmarks for the prototype, so claims about saved time are DeepSeek's own until others test it.

Watch for how teams use the auto mode, whether the Feishu-first setup gains Slack or other sources (the repo includes a cookbook for adding one), and how the release lands with US buyers. The Next Web reports civilian US federal agencies were told to remove DeepSeek last month. For DeepSeek's wider open-source push, see our coverage of DeepInfer, the engine behind its AI service.

FAQ

Is DeepSeek Super-Agent free to use?

The code is MIT-licensed on GitHub. You still need DeepSeek Harness and a model provider configured for it, so model costs depend on your setup.

Does it read every message in my team chat?

That depends on how you configure each source: it can receive only messages that mention the agent, or every message in a chat or repo scope. Even then, in the default observe mode, messages nobody addressed to the agent are only assessed and recorded, never run.

Is it ready for production?

No. DeepSeek calls it a research prototype that may contain bugs and tells users to review and adapt it before running it.

Sources

Follow TheTechLane

Keep learning AI, development, and modern developer technologies with TheTechLane.

Learn • Build • Share

Follow @thetechlanehq for more developer guides, tutorials, and practical technology content.