AI Can Now Autonomously Discover Bugs and Submit PRs
Mengyao, reporting from the office
DeepSeek is making moves again!
This time, the team has publicly revealed the underlying architecture behind their Personal Agent.
While many developers were still anticipating the rumored “dsh dot”, DeepSeek surprised everyone by publishing an engineering-focused exploration of system architecture:
Super-agent: Towards a More Autonomous Agent System.
What does this mean? AI can now autonomously detect bugs, locate root causes, and proactively submit PRs—without needing to be @mentioned or given explicit instructions by humans.

Beyond that, it can continuously monitor work group chats, collaborate across platforms, handle multiple complex tasks in parallel, and run 24/7 around the clock.
The DeepSeek team also shared preliminary benchmark results: in a simulated multi-task collaborative environment, Super-agent achieved a median task completion time of 12.4 minutes and a 95th percentile (p95) time of 15.7 minutes, significantly outperforming traditional single-session approaches tested.
This marks a shift away from the passive paradigm where AI “waits for humans to issue instructions step by step” toward a new phase of “proactively discovering issues and driving progress autonomously.”
No @Mentions Needed: AI Autonomously Locates Bugs and Submits PRs
In everyday software development, engineers frequently juggle multiple platforms: discussing technical designs in instant messaging (IM) group chats, switching to GitHub to submit code, and iterating on implementations based on PR review feedback.
For traditional coding agents, these workflows are often fragmented across disparate sessions. Users not only have to track progress across each session, but also manually sync context back and forth with the AI.
In their technical report, the DeepSeek team noted that, based on their observations, an individual human can typically juggle no more than 3 to 5 active sessions simultaneously.
This exposes a fundamental tension: even as models become increasingly capable of tackling individual tasks, overall multi-task collaboration efficiency is becoming bottlenecked by human attention.

Super-agent was built specifically to address this pain point.
In instances deployed internally at DeepSeek, a single development task can seamlessly span the entire workflow from IM group chats to GitHub PR reviews.
For example, a user might first agree on Approach A in a group chat, but later request a switch to Approach B in a GitHub PR comment. Super-agent accurately recognizes that both instructions belong to the same work item and adjusts its subsequent execution strategy accordingly.
To the user, they are always interacting with the same single agent. Under the hood, multiple session states are automatically coordinated and orchestrated by the system, while the agent proactively intervenes in the workflow.

This capability relies on a critical mechanism: Speculative Execution.
When the AI perceives that a task might need handling, it proactively attempts to execute it in the background ahead of time.
For instance, when a bug discussion pops up in a work group chat, Super-agent preemptively tries to reproduce it and isolate the root cause in the background. If it finds a clean, viable fix, it proactively presents the solution to the user; if it yields no actionable conclusion, it remains silent to avoid disturbing the team.
This mechanism works similarly in personal assistant scenarios: upon receiving a meeting invite, the AI can check for schedule conflicts, retrieve relevant background materials, and draft a response ahead of time—leaving only final user confirmation before sending.
This directly aligns with the four core characteristics DeepSeek defined for Super-agent:
- Continuous: Preserves task context across sessions and platforms without requiring users to re-explain background details.
- Efficient: Supports parallel execution of multiple complex tasks so long-running jobs never block new user interactions.
- Proactive: Continuously perceives changes in the runtime environment and takes autonomous action when necessary.
- Persistent: Operates 24/7 with long-term availability and the ability to self-heal from anomalies.

To achieve this, DeepSeek engineered a two-tier architecture:
- Top-layer Router: Acts as the master orchestrator, responsible for receiving external messages, coordinating task dispatching, and maintaining global context.
- Bottom-layer Workers: Serve as concrete execution units composed of independent agent sessions. Multiple workers can execute concurrently without interfering with one another.
Notably, DeepSeek also introduced an event subscription and passthrough mechanism:
For instance, once a Worker takes on a GitHub PR task, it can directly subscribe to subsequent comments on that PR. When new review comments arrive, messages bypass the Router and flow straight to that Worker for processing, eliminating repetitive multi-hop routing and parsing.
This design ensures that in-flight tasks have dedicated agents following through, while incoming tasks are swiftly routed and dispatched, drastically improving overall collaborative throughput.
24/7 Availability and Self-Healing: Benchmarks Show Greater Stability in Task Completion Times
To support Super-agent’s long-term autonomous operation, beyond multi-task concurrency, several challenging engineering hurdles had to be overcome: message flood filtering, task thread blocking, and system fault recovery.
First is the message filtering mechanism.
When an agent connects simultaneously to multiple message streams like group chats, GitHub, and email, a flood of messages arrives continuously—yet only a fraction actually requires a response.
DeepSeek adopted a two-tier event filtering design:
- A lightweight rule engine first filters out irrelevant messages upfront;
- An LLM then evaluates whether the remaining events warrant action. This design drastically reduces wasteful token consumption.
Second, to address task blocking, Super-agent introduces an Async ReAct Loop.
While executing long-running, heavyweight tasks, the agent can still respond to new user commands in real time without queuing behind preceding tasks. This mechanism has already been implemented in DeepSeek Harness (though not yet enabled by default).

To meet the requirements of 24/7 continuous availability, DeepSeek designed a decoupled architecture separating compute logic, session state, and execution environments:
Agent decision-making compute runs in the cloud, state data is persisted independently, and local machines retain the raw execution environment. Even if a local machine goes offline due to a shutdown or network interruption, the cloud agent maintains task context and immediately resumes execution once the device reconnects.
In addition, the system introduces an independent Watchdog mechanism.
In essence, the Watchdog is a guardian model that independently monitors other agents. It can catch low-level program crashes as well as detect whether an agent is stuck in an infinite logical loop or drifting away from its objective, intervening to rectify the situation when needed.
The DeepSeek team conducted a series of benchmark tests on this system:
The benchmark simulated a collaborative environment containing approximately 300 messages and 20 compound work requests, comparing Super-agent against a traditional “Single Session + Subagent” architecture (each configuration evaluated across 5 runs).
The results demonstrated:
- Super-agent: Achieved a median task completion time of 12.4 minutes and a p95 completion time of 15.7 minutes.
- Traditional Single-Session approach: Under neutral prompt settings, the p95 completion time stretched to 29.5 minutes.

Naturally, gains in execution efficiency must be weighed against token consumption costs.
DeepSeek’s ablation studies showed that removing the “event passthrough mechanism” increases Router scheduling decision frequency by approximately 30% and cache token read overhead by about 37%. This confirms that fine-grained event routing is critical for driving down agent operational costs.
This technical disclosure makes clear that DeepSeek is exploring ways to move agents entirely beyond the confines of single-turn, linear conversations, shifting toward an engineered system characterized by persistent residency, multi-task concurrency, proactive response, and self-healing.
As LLM capabilities for handling isolated, complex tasks mature, ensuring they can reliably, steadily, and autonomously drive system-level workflows is becoming the central frontier in next-generation agent architecture.
GitHub Link:
https://github.com/deepseek-ai/dsh-superagent-prototype