[KongchangAI]
· 3 min read· 1,909 words

DeepSeek Super Agent Prototype Hands-On: The Core Differences Between Personal Agents and Super Agents

DeepSeek Super Agent Prototype Hands-On: The Core Differences Between Personal Agents and Super Agents

DeepSeek's open-source super agent prototype: event triggers replace human instructions to reshape agent collaboration.

The article uses DeepSeek's open-source DSH-superagents-prototype to trace agent evolution from Harness and sub-agents to Deep Research Agents, Swarm, and personal agents. It argues that personal agents are defined by being always on, while super agents are triggered by events rather than human instructions. A Tiny Invoices experiment compares Claude's one-off tag mechanism with the super agent's router + ticket + worker architecture: the former responds directly but has no persistent session, while the latter keeps listening for follow-up comments but suffers from router misjudgments and no streaming feedback. It also covers the two deployment paths and notes that the super agent deliberately focuses on coding as a step toward team collaboration.

In the evolution of AI agents, we've witnessed the journey from simple chatbots to Agent Harnesses capable of using tools and calling on memory, and then to always-on personal agents. Recently, DeepSeek open-sourced a prototype project—DSH-superagents-prototype—that introduces the concept of "Super Agent," attempting to redefine how agents are triggered and how they collaborate. Bilibili creator Sean used a real-world GitHub issue-fixing case to compare how personal agents and super agents operate, and to map out the evolution path of agent architecture.

From Agent Harness to Super Agent: A History of Architectural Evolution

To understand the super agent, we first need to trace how it evolved step by step. In the video, Sean lays out a clear lineage: the most basic form is the Agent Harness—you ask Claude Code or Codex a question, and it calls tools, retrieves memory, and returns results. Then came the sub-agent, which lets a worker handle tasks in parallel alongside the main task without interfering with it. One step further is the Deep Research Agent, where a user query passes through a clarification agent and a research brief agent before finally reaching a supervisor agent, which dispatches tasks to individual researchers. After that comes Swarm: no boss, tasks broadcast to a group of workers operating simultaneously, converging through some mechanism.

The common thread across these forms: the way agents are organized changes, but the triggering logic sees no fundamental breakthrough. That is, until personal agents appeared—Meta, X, Cursor, and Claude all launched similar capabilities, with Muse and Gronkbot bringing them to market first. The core of a personal agent is "always on": an email or a calendar reminder can wake it up, it remembers who you are, and it can keep working on tasks while you pick up your kids or watch a video.

Agent architecture evolution diagram

The super agent goes one step further: it is also always on, but what triggers it is no longer a human instruction or a scheduled task—it's the "event" itself. A GitHub issue being created, a comment being added—either can wake the Router, which decides whether to take the job and then dispatches it to a worker for execution. Sean emphasizes in the video that this project is still only a prototype, not an official release, but the concept itself is worth paying attention to.

Agent Harness is a core term that appears repeatedly in this article. It refers to the "shell" or "scaffolding" that hosts a large model and provides it with runtime capabilities such as tool invocation, memory retrieval, and session management. The model itself is only responsible for reasoning and generation, while the Harness is responsible for wiring user input, tool interfaces, and contextual memory into a complete task loop. Claude Code, Codex CLI, and Waku Agent all belong to this category. Its key value lies in engineering "model capability" into "executable tasks," so the quality of the Harness directly determines how usable an agent is in real workflows. Understanding this is essential to grasping that the super agent described below is essentially an upgrade of the Harness from "passive response" to "always-on listening."

Swarm is a decentralized multi-agent collaboration model: there is no central dispatcher; tasks are broadcast to a group of workers, each processing in parallel and converging on results through mechanisms such as voting, consensus, or a shared blackboard. It contrasts with the hierarchical "supervisor–researcher" Deep Research Agent: the former emphasizes elasticity and parallelism, the latter emphasizes control and division of labor. Swarm's limitations are high consensus costs and blurred accountability boundaries, which is why in real products it is often combined with mechanisms like routers and tickets. This also explains why the super agent chose a "router + ticket" structure rather than a pure Swarm.

Hands-On Comparison: How Two Agents Fix Bugs in the Same Repository

Sean ran a controlled experiment on a GitHub repository called Tiny Invoices. The repo calculates invoice amounts and has several issues, such as a formatting error in the amount (it should display as $1050 USD but shows an incorrect format) and a due date that is one day early.

He first @-mentioned Waku Agent (connected to the DeepSeekAd super agent on his own laptop) in an issue, asking for a fix as soon as possible. He then @-mentioned Claude in another issue—this is Claude's GitHub Action integration approach. Both started work at the same time, and the differences immediately became apparent.

Claude's response was very direct: once @-mentioned, it immediately started a brand-new task on GitHub's machines, went straight to making changes and submitting a Pull Request—no routing, no tickets, and the task ended as soon as it was done.

The DeepSeek super agent's flow was far more complex: after being @-mentioned, it first entered the router, which decided whether to handle the event, then created a Ticket, then dispatched it to a worker for execution, and only finally produced a Pull Request. Sean admitted that the prototype has obvious problems—he had to @-mention the agent three times before it actually started working, and the router's "ignore" behavior was maddening. In addition, the lack of real-time streaming feedback made the whole process a black box, and he had to switch back to localhost to confirm whether the agent was actually doing any work.

The super agent's ticket-handling interface

The differences became even clearer in follow-up comments. Under the issue fixed by Claude, he left a comment asking "how's it going?"—but because Claude uses a tag-triggered mechanism with no persistent process listening for subsequent events, it did not respond automatically. Under the issue handled by the super agent, leaving a comment woke the router again, and a worker picked up the job anew and replied. Sean also ran a "tell me a joke" test, and the super agent's worker dutifully went off to search the entire internet before finally replying, "This is an automated agent, not a human"—completely missing the intent of the joke.

The Core Difference: Who Starts the Work

Sean boils the essential difference down to one question: who starts the work?

A personal agent is started by a human—you ask a question, you set up a cron job (for example, sending a company briefing every Monday at 7 a.m.), and the agent acts only after being triggered. A super agent is started by the event or the task itself—someone comments on GitHub, a ticket is created, and the router starts running automatically.

Personal agent vs. super agent comparison

The implications of this difference are profound. Claude's tag mechanism is essentially a "one-off task": every @-mention is a brand-new job with no persistent session and no tracking of subsequent discussion. The super agent maintains long-lived sessions—as long as the local harness isn't shut down, it can keep listening and responding to new events. Of course, this also means that if the laptop is turned off, the session is gone. To truly achieve "always on," the agent needs to be hosted in the cloud or on an always-on Mac mini.

Sean also acknowledges that, in theory, a personal agent could achieve a similar effect through careful orchestration, connecting to GitHub MCP, and setting rules. But the cleverness of the super agent framework is that it focuses extremely restrainedly on coding tasks. His judgment is this: a great deal of AI innovation today happens first in coding scenarios, and if coding tasks can be solved well, design work and chief-of-staff-type work can follow—coding is at the core of the path to AGI.

The authorization difference between GitHub App and GitHub Action is key to understanding the two deployment paths. A GitHub App is a platform-level installable integration that acts on behalf of the app's identity through fine-grained permissions and short-lived tokens, suitable for multi-repository, auditable automation scenarios. A GitHub Action, by contrast, is an event-driven workflow inside a repository, triggered by events such as issue comments or pushes to run a one-off job. Claude takes the latter approach, so every @-mention starts an independent job that inherently lacks a long-lived session. The super agent adopts a "separate account + local login" model, bypassing the App permission model in exchange for continuous listening capability—but it also ties availability to the online status of the local machine.

Deployment Approaches and Engineering Details

The configuration paths for the two solutions are completely different. Claude uses the GitHub App model: install the app and assign an authorization token, after which every @-mention starts a job. The super agent requires creating a separate GitHub account for the agent, inviting that account to have write access to the repository, then logging in locally to both the DeepSeek harness and the agent's GitHub account so the super agent can take over the new account—everything is done locally.

Sean specifically notes that the project is fully open source, and you can see on GitHub the technical details of each worker's prompt, the ticket directory, context reading, and scope assessment. The project itself is part of Waku Agent, an open-source local agent harness that currently has 2.2k stars. Sean says the team is busy developing the memory layer and hasn't been able to merge all PRs in time, but it is still doing its best to maintain the repository.

From Personal Assistant to Team Collaborator

What excites Sean about the super agent is its collaborative nature. Heavy users of personal agents tend to be business owners, extremely busy people, or people handling complex tasks—and these are exactly the people who need to collaborate with teams. The super agent is designed for team collaboration from the start: GitHub issues, team chats, and messages on Waku Board can all serve as trigger sources.

He summarizes the evolution of agents in four stages: a smart chat agent; an agent that can use tools and retrieve memory; an always-on personal assistant (like a chief of staff or administrative assistant); and a true teammate—one that has already started working before you even realize an event or task has been assigned. Sean describes the productivity gain from this collaborative model as "10x, if not 100x."

Of course, the prototype's problems are real: router misjudgments, a lack of real-time streaming feedback, and zero ability to understand jokes. But as Sean says, the concept itself is very interesting and worth deploying and trying out for yourself—host the super agent in the cloud or on an always-on device, connect it to your daily workflow, and come to understand the boundaries and possibilities of agent collaboration through practice.

One-line Summary

DeepSeek's open-source super agent prototype: replacing human instructions with event triggers to reshape how agents collaborate.

Paragraph Summary

The article takes DeepSeek's open-source DSH-superagents-prototype as its entry point, tracing the evolution of agents from Harness, sub-agents, Deep Research Agents, and Swarm to personal agents. It points out that the core of a personal agent is "always on," while the super agent's breakthrough lies in being triggered by events rather than human instructions. Through a controlled experiment on the Tiny Invoices repository, the author compares Claude's one-off tag mechanism with the super agent's router + ticket + worker architecture: the former responds directly but has no persistent session, while the latter can keep listening for follow-up comments—yet it suffers from router misjudgments and a lack of streaming feedback. The article also explains the differences between the two deployment paths and emphasizes that the super agent deliberately focuses on coding tasks, viewing it as a key step toward team-collaborative agents.

#DeepSeek Super Agent#Agent Harness#personal agent#GitHub issue automation#AI agent architecture#Swarm#Claude GitHub Action
Share:

Related articles