Someone posts a failed pipeline run in the project group chat and asks, "Could someone help take a look?"
For a Waker that already has the required project access and development tools, investigating this pipeline is straightforward when considered purely as an Agent task. But in the previous collaboration workflow, without an explicit @Waker mention assigning it work, Waker had no way to tell: "Is this request meant for me, or are my coworkers talking to each other? Has someone already taken it on? If I step in now, will I help or get in the way?"
This everyday software development scenario highlights some of the core challenges Digital Workers face when joining real teams:
Before we explore proactive response in QoderWake, it helps to understand the fundamental difference between a Digital Worker and a Personal Agent. A Personal Agent can also read group messages and proactively reply on a user's behalf, but it typically decides whether to get involved based on the individual user's goals and preferences. A Digital Worker, by contrast, has a defined role and responsibilities within an organization. Amid multiple overlapping conversations, it must identify who is making a request, who is being asked to act, and who its actions would affect. Sender identity, mentions, reply relationships, and policies defining its responsibilities all inform that decision.

For a Digital Worker, taking initiative in a group chat means first deciding when to take ownership, not simply spotting work to do. QoderWake's @Waker functionality already lets group members assign work to Digital Workers. Proactive response builds on the same task system, adding event ingestion, an assessment of whether to act, and routing decisions. This lets Digital Workers respond to the right requests at the right time without requiring an explicit @mention every time. Before this capability was introduced, Waker already supported three useful ways to initiate work:
These provide reliable ways for tasks to enter the system, but someone still has to explicitly @mention the Digital Worker, define a rule in advance, or set a time. They cannot easily cover every unplanned request for help, especially when requests are phrased in different ways. Proactive response was designed to help Digital Workers find the right moment to get involved and respond appropriately amid a high volume of group messages.
Proactive response extends the existing @Waker task system with message ingestion, initial screening, and routing decisions. The key is to keep three steps distinct: identify potential work, confirm task ownership, and only then commit resources to execution. The process has four stages:

Figure 1: The Proactive Response Workflow
New group messages drive proactive response. When the system receives a message, it saves the sender, conversation, timestamp, reply relationships, @mentions, and other metadata. Subsequent decisions must stay grounded in the actual messages; the model cannot simply be given a fragment of text stripped of its source.
We also strictly control the context used for proactive response. Only recent events can drive the response decision for a new message. Earlier messages help resolve references and establish business context, but they cannot trigger a new task on their own. This prevents old messages from resurfacing as new requests.
Most group messages are everyday exchanges between coworkers, not requests for Waker to do work. Sending every message to Router for full reasoning would raise ongoing costs and could leave genuine requests for help waiting behind casual conversation. Keywords such as "build failed" alone cannot distinguish a request for help from a retrospective or a discussion between teammates. This brings us back to the question raised at the start: Will the same investigation cost more if Waker takes the initiative?
Compared with the basic @Waker workflow, QoderWake adds preliminary checks before Router to assess whether Waker should act. There are three layers: programmatic checks, rapid initial screening by JEV, and a routing decision by Router. Programmatic checks handle deterministic conditions; JEV decides whether a message warrants further interpretation; Router then confirms configured responsibilities and task ownership.
Even when messages mention "build failed", the appropriate action for Waker can be very different depending on the group conversation:
| Message in the Group Chat | How Waker Should Respond |
|---|---|
| A coworker is explicitly @mentioned and asked to investigate | Do not consider it for proactive response. Respect the direct request to the coworker; Waker does not take over their task. |
| A clear request for help names no one to do the work and falls within Waker's configured responsibilities | Treat it as a potential request: JEV performs initial screening, and Router makes the final decision. A request for help does not automatically trigger execution. |
| A message references a previous failure and discusses the approach used at the time | Old records provide context only. Without a new request to act, a reference alone cannot create a task. |
| Another failure occurs, prompting a new request to investigate | Evaluate the current request. Do not filter it out as a duplicate simply because Waker has answered a similar question before. |
JEV receives the active policies, the new messages being evaluated, and a small amount of background context, and outputs only a single initial screening score. In the current implementation, this score must strictly exceed the threshold for processing to continue; it is not a calibrated probability of task ownership or business success. JEV neither plans execution steps nor generates group replies. Even after initial screening, Router must still identify who is asking whom to do the work: in "Send the results to Waker when the investigation is complete," Waker is the result recipient; that does not make it the executor.
Router must answer two questions: Is this Waker responsible for the task? Should it take it on now? It can retrieve historical messages, tasks, and memories as needed to supplement recent context, but it does not investigate the pipeline itself during routing.
For example, "Send the results to Waker when the investigation is complete" identifies the result recipient. Even if the message closely resembles a work request, that alone does not make Waker the executor. Understanding the intent must be followed by confirming responsibility.
Separating routing from execution has another practical benefit: a lengthy investigation does not block the routing of subsequent messages. Code, logs, and tool operations reside in a separate Work context, while routing retains only the background needed to assess the current request. Unlike the "everything is plugin" approach in DeepSeek Harness, we retain some system-level context management so that the model needs as few tool lookups as possible to obtain essential background information, making semantic understanding more robust.
Once Router accepts a task, the work proceeds in a separate Work context bound to Waker, using its working directory, model, and authorized tools. Router can continue routing subsequent requests without waiting for the work to finish. Execution remains subject to existing queue and concurrency limits; this separation does not imply unlimited parallel execution.
Policies describe in natural language when Waker should participate. For example:
A group member explicitly requests an investigation into a build failure in this project, without assigning the task to anyone else.
A practical way to write policies is to check both positive and negative examples: which requests should be accepted, and which similar discussions should be left alone? This is easier to apply and validate than a broad instruction such as "Actively help group members." Requests directed to colleagues and discussions citing old records can help reveal whether the stated responsibilities are too broad.
Users can manage policies in the console or explicitly instruct Waker in the group chat to add, edit, or delete them. These two options provide flexible ways to configure proactive response policies across interfaces.
Manual policies are well suited to defining responsibilities, but writing them from scratch for every group takes effort. Could work repeatedly assigned to Waker help it recognize the next request of the same kind? Automatic policy learning derives response conditions from these historical task assignments.
For example, repeated explicit assignments to investigate builds in this project can provide evidence for deriving that responsibility. A one-off request to look up a device's IP address, however, does not automatically authorize Waker to inspect every device. Policy learning must preserve the relevant business objects, scope, and exclusions. The meaningful outcome to watch for is whether legitimate requests of the same kind require fewer explicit mentions without drawing in more unrelated work.
QoderWake also strictly controls the evidence used for policy learning: it must relate to Waker's current identity. Historical structured @mentions and stable IDs confirm who the original requests were intended for; nicknames alone are insufficient.
Each day in the early morning, historical messages are processed for policy learning in batches using a sliding window, together with task outcomes and subsequent feedback linked to their source messages. Every proposal to add or revise a policy requires evidence that is currently visible, including at least one request that the host has confirmed was directed to Waker's current identity.

Figure 2: Automatic Learning of Proactive Response Policies with Dreaming
In the learning workflow, Dreaming for proactive response policies and Dreaming for memory are triggered at the same time, but run as independent processes without affecting each other. This avoids cascading task failures under extreme conditions.
Manual adjustments take precedence over automatically derived policies. Automatic policy learning cannot overwrite policies added manually, created through conversation, or pinned after editing. Deleting a policy leaves a suppression record to prevent equivalent content from being learned again. Automatic policy learning can be disabled independently, while existing policies remain active.
These safeguards address "Who is authorized to change responsibilities?" but not yet "Do those changes improve decisions?" QoderWake also supports creating or updating proactive response policies directly in group chats. Explicit task assignments from users provide positive examples for deriving responsibilities, while corrections such as "Leave this one to Zhang; you don't need to get involved for now" and "Only investigate release failures, not routine development builds" are better suited to narrowing the scope.
If we remove the explicit @mention, does the same task cost more? How much longer do group members have to wait? We ran live tests in a DingTalk group, monitoring the full processing chain for the same requests triggered by an explicit @mention and by proactive response to compare cost and duration.
We used three task types for a paired task comparison: analyzing issues in historical materials, editing technical explanations, and performing read-only checks of designated source code. Each pair used identical task text and delivery requirements; the only difference was whether the message explicitly @mentioned the Digital Worker. An explicit @mention goes directly to Router, whereas proactive response first passes through message collection and JEV screening before Router makes its decision.
We kept the responsibility policies, Digital Worker, and model tier the same, disabled automatic policy learning, and alternated the order of the two trigger methods. We then calculated the total Credits used for each request.
First, the overall results:

Figure 3: Average Usage and Duration in the Paired Task Comparison
Looking at resource usage and duration together makes the differences easier to see.

Figure 4: Average Resource Usage Profiles for the Two Trigger Methods
In this test, proactive response had higher average input/output usage and a longer average Work duration, but a shorter average Router duration. This shows that proactive response adds work to identify and assess tasks, while actual resource usage in Router and Waker's eventual response still depends on the context and execution process at the time.
We measured the time until results were sent separately from the time until system finalization was complete. End-to-end duration starts when the original message is sent and ends at the database timestamp when the outbound text is marked as successfully sent.

Figure 5: Breakdown of Average Delivery Time
The breakdown shows that proactive response adds JEV screening, but this stage accounts for only a small share of delivery time in this test. Differences in the time spent waiting for message collection, preparing tasks for dispatch, and executing them in Work are also visible.
Beyond the averages, we also compare each proactively triggered task with its own @mention-triggered counterpart.

Figure 6: Relative Differences for the Same Tasks
Proactively triggered tasks all took longer to deliver, while usage varied above and below the @mention baseline. There was no consistent "proactive surcharge" or uniform pattern of cost variation. Costs therefore still need to be assessed in the context of each run; proactive response itself did not show a substantial increase in per-task usage in this test.
QoderWake power users are already using @Waker and proactive response to coordinate engineering alert investigations. Before Digital Workers joined the workflow, interpreting alerts was a persistent challenge for on-call engineers: a "timeout" alert might indicate a failure, or simply a task exceeding an overly tight duration threshold. The on-call engineer first has to review the context before deciding whether to investigate further. If Waker has the relevant responsibilities and tool permissions, it can assist by taking on this initial investigation and organizing the findings.
The records below show two assessments. Waker classified a repeated alert as noise and suggested ways to reduce the impact of duplicate alerts. For a task timeout alert, it reviewed recent execution times, recommended continued observation, and proposed follow-up checks. These were its assessments at the time; subsequent recovery and the validity of its conclusions still need to be confirmed through monitoring and actual incident-handling results.


Figure 7: Records of Proactive Response in Production
As discussed at the start, foundation models continue to improve, and the ability to execute a specific task is no longer the only challenge for Digital Workers. The need for human intervention is also gradually declining. How can Digital Workers "do the right thing at the right time"? How can proactive response adapt quickly as group membership and tasks evolve? These are the questions we will explore next. QoderWake will continue to develop in this direction, helping Digital Workers work more effectively alongside their human colleagues.
What Is Model Thinking Effort? Should You Choose Low, High, or Maximum?
1,601 posts | 526 followers
FollowAlibaba Cloud Community - July 3, 2026
Alibaba Cloud Community - May 26, 2026
Alibaba Cloud Community - August 28, 2026
Alibaba Cloud Community - October 25, 2024
Alibaba Cloud Native Community - July 14, 2026
Alibaba Clouder - August 25, 2020
1,601 posts | 526 followers
Follow
Qoder
From Assisted to Autonomous — Adapting to Every Programming Need
Learn More
QwenWork
QwenWork is dedicated to helping employees strengthen their professional competitiveness in the AI era and to enabling enterprises to improve organizational effectiveness.
Learn More
Token Plan
Build more, spend less. One plan, every modality.
Learn More
Wan3.0
Unleash Your Creativity Try Wan 3.0 now — longer narratives, greater control, endless creativity.
Learn MoreMore Posts by Alibaba Cloud Community