Alibaba Cloud Engineer Zheng Tian: Agent Architecture Is Converging, with the Bottleneck Shifting from Model Capability to Human Attention
In the "Alibaba Cloud AI Agent Handbook," Zheng Tian systematically analyzes the architecture of DeepSeek SuperAgent, pointing out that multiple teams independently converging on similar solutions is not a coincidence but the result of constraints narrowing the solution space: models can already complete single tasks, so the bottleneck has shifted to human attention (a person can typically track only 3 to 5 active conversations at once). This necessitates unified external interfaces, isolated execution units, and persistent task objects. The article also details core engineering principles—specifically that the model is the system's only nondeterministic component, and engineering's role is to wrap it in a deterministic shell—as well as the clear limitations of current prototypes.
Verified
Zheng Tian, an engineer at Alibaba Cloud, proposes a judgment in the "AI Agent Handbook": after DeepSeek released SuperAgent, the prevailing view in the industry was that Agent design had largely converged, and he shares this view. More notably, he points out that his own team arrived at almost the exact same architecture while independently developing Collaboration Space—using the same task objects and the same call-chain organization methods. He argues this is neither coincidence nor mutual borrowing, but rather that constraints have narrowed the solution space.
The causal chain Zheng Tian presents is as follows: models can already complete individual tasks, so the bottleneck has shifted to human attention. The DSH team observed that one person can usually follow only 3 to 5 active conversations at once; therefore, the ceiling for a single task depends on the model, while the ceiling for multiple tasks depends on humans. This observation directly derives three design requirements: a need for a unified external interface (so users feel they are always collaborating with just one Agent), isolated execution units (as tasks grow longer and more numerous), and task objects capable of persisting across sessions. Once a problem is clearly defined, answers tend to converge, much like how databases ultimately moved toward write-ahead logging and operating systems toward processes and schedulers.
At the engineering level, Zheng Tian summarizes this convergence into a core principle: the model is the system's only nondeterministic component, and engineering's job is to wrap it in a deterministic shell. He found five specific manifestations of this in the DeepSeek prototype code. First, the model proposes while the program decides—the Router model saying 'accept work' is essentially just submitting a request; the deterministic core checks permissions, rules, and state before actually writing, meaning that even if the model suffers from prompt injection attacks, the worst-case scenario is merely a rejected request. Second, log first, then execute—external actions and state changes are recorded in the same transaction, allowing unfinished actions to be resumed after a crash restart, which is the Outbox pattern in distributed systems. Third, external text is always just data—content in group chats and comments sits at the lowest priority; when the Router hands off a task, its note is limited to 30 words and must not include an implementation plan, forcing the Worker to read the original messages itself. Fourth, proactivity must support staged rollout—new rules default to a dry run where the model records 'I would accept this work if execution were enabled' without actually starting; execution is only turned on after the team reviews and confirms accuracy. Fifth, people have the highest priority—one concurrency slot is always reserved for humans; even if all Worker slots are busy, human messages can still wake existing work.
Zheng Tian also explicitly points out the limitations of the current solution. DSH's load testing used simulated models, with event rates reaching only 40 per minute, so results cannot be extrapolated to arbitrary scales. He identifies at least four bottlenecks in centralization: context capacity (everything passes through it, so the window will eventually run out), decision quality (judging too many things in one round invites errors with broad impact), cost (large contexts must be reread every time; SuperAgent's cached Token read volume is 3.8 times the baseline), and blast radius (all events and permissions converge at one point, so prompt injection there affects the entire system). DSH itself admits that finer partitioning increases throughput but reduces continuity, a trade-off that will persist until the global memory problem is solved.
In Alibaba Cloud's own practice, Zheng Tian's team chose a slightly different path: using Channel partitioning instead of a single Router, using non-resident Coordinators instead of persistent sessions, and using Quests (assignable, trackable, and verifiable work records) instead of Tickets. They discovered that Agents waking each other up is the most thorny pitfall in production environments—an organizational roll-call task that should have taken 3 executions actually ran more than 10 times. The root cause was that the platform placed 'being mentioned' and 'being assigned a task' into the same flow. The fix was to strictly distinguish semantics: '@' is communication, while creating a task is delegation. This conclusion aligns with DSH's: hard platform constraints are more reliable than prompts.
Finally, Zheng Tian places two trends side by side: architectures are converging, while Agents are returning to traditional engineering. As Agents shift from single conversations to long-running processes, they must face old problems like process crashes, machine offline states, duplicate messages, and side effects that cannot execute twice. In both DSH's code and his own, he increasingly sees classic database and distributed-system technologies—write-ahead logs, Outbox patterns, leases, and replayable event records. His summary is: the model is the CPU, and the Harness is the operating system and database.