ADPS Dual-Axis Framework: 7 Cognitive Functions × 6 Execution Topologies for Agent Design

What Is ADPS?

ADPS (Agent Design Patterns) is a design-pattern system for agent engineering, centered on a "Cognitive Function × Execution Topology" dual-axis framework . It was proposed by Huang Jia and refined through seven deep-dive workshops with frontline experts from Tencent, Baidu, Sina Weibo, JD.com, Huawei Cloud, ZTE, Qunar, Dewu, and others. ADPS is not a framework, tool, or standard—it is a map that tells you where your agent design sits, what alternative paths exist, what pitfalls lie on each path, and how others have crossed them.

"Abstraction must be followed by reification—from the field to the framework, then back from the framework to the field. This is a closed loop." — Huang Jia

The Dual-Axis Framework: Cognitive Function × Execution Topology

The matrix crosses 7 cognitive functions (vertical axis, "what the agent does") with 6 execution topologies (horizontal axis, "how execution is organized"), yielding 42 design coordinates that distill into 28 production-verified patterns.

Vertical – Cognitive Functions: Perception, Memory, Reasoning, Action, Reflection, Collaboration, Governance.

Horizontal – Execution Topologies: Chain, Parallel, Routing, Loop, Hierarchy, Orchestration.

Examples of coordinates:

Perception + Chain = single-threaded information-gathering agent.

Reasoning + Parallel = multi-perspective parallel exploration reasoning agent.

Action + Hierarchical Delegation = Supervisor dispatching tasks to multiple Worker agents.

Governance + Routing = risk-level routing to different approval paths.

"Talking only about 'what' without 'how' is a castle in the air; talking only about 'how' without 'what' is aimless. The two dimensions must intersect to cover the full agent-design space."

Seven Cognitive Functions: Deconstructing the Agent "Persona"

1. Perception – Eyes and Ears

Perception is the first step in agent design. Tencent expert engineer Zhang Dong observed: "The perception layer is the root cause of 80% of poor reasoning/decision outcomes in production." In code-scanning scenarios, dumping all code into the model causes context explosion and poor results; using static-analysis tools to extract syntax trees and call graphs compresses context to 30% while providing structure, yielding better results.

Core questions: Where does information come from? How to filter? How to structure? How to avoid garbage-in-garbage-out?

2. Memory – Brain and Notebook

Memory is not just storage; the key is a closed loop of write and access. Yingliu co-founder Zhang Yingfeng introduced "knowledge compilation" —making write and access a single complete operation. Many agents only solve "store" but not "retrieve". Sina Weibo senior director Li Qingfeng noted that not every scenario needs complex memory; Weibo's "Weima" and "VAgent" choose whether to introduce memory per scenario to avoid over-engineering.

Core questions: What to remember? How to record? When to forget? How to ensure retrieved content is correct?

3. Reasoning – Thinking Engine

Reasoning is the core mechanism; perception and memory prepare context, action and reflection act on output. It traces back to Kahneman's System 1 (fast, automatic) and System 2 (slow, deliberate). Zhang Dong summarized three reasoning modes:

Chain-of-thought: linear, step-by-step; most common, recommended first.

Tree-of-thought: multi-branch exploration, unified convergence; used for root-cause analysis, technical selection.

Reflection-iteration: cyclic correction, gradual optimization; used for code refactoring, compliance copy, vulnerability strategy iteration.

Zhang Dong emphasized anti-patterns : "Anti-pattern value may exceed best practices. Most reasoning failures in production are not due to insufficient design but to common pitfalls. Avoiding shared pitfalls gets you to 80% production readiness." Examples: infinite recursive iteration, black-box chain reasoning, unbounded reasoning, reasoning results pushed straight to production.

Core questions: When to think fast vs. slow? How to verify reasoning correctness? How to avoid infinite loops?

4. Action – Hands and Feet

Action separates chatbots from production tools. The core tension is Plan vs. React coexistence : long-horizon tasks need plan-then-execute; short-horizon tasks need perceive-react. No single mode fits all. Zhang Dong proposed deterministic engineering for action boundaries : dev environment open, test with partial traffic, pre-release full test, production fixed code. "Closer to production, more restrictions; closer to personal assistant, more freedom." Alipay's "Abao" demonstrates GUI action with edge-cloud integration; JD's CRI tooling + sandbox + code graph shows enterprise action infrastructure.

Core questions: What can the agent do? What can't it? How to guarantee correctness? How to roll back on error?

5. Reflection – Self-Evolution

Reflection enables cumulative intelligence. ADPS breaks it into four patterns:

Generative Critique: chain review of own output.

Skill Packs: load different skills via routing topology.

Experience Replay: learn from historical trajectories.

Self-Healing Loop: system-level self-repair.

JD retail algorithm architect Zhou Mo gave five necessary conditions for reflection: automatable, terminable, observable, reusable, cost-controlled . Missing any turns reflection into an ineffective loop or resource black hole. He also highlighted meta-reflection (reflecting on the reflection answer, akin to meta-programming) and deliberative reflection (debate/adversarial/game-theoretic reflection, like AlphaGo self-play).

"An agent is like a human yet not like a human." — Huang Jia

Core questions: How to know you're wrong? How to fix? How to remember the fix? How to avoid infinite reflection?

6. Collaboration – Multi-Agent Teamwork

When one agent isn't enough, multiple agents collaborate. ADPS defines six collaboration patterns:

C1 Hierarchical Delegation: Supervisor assigns tasks to Workers (classic master-worker).

C2 Fan-out/Fan-in: parallel dispatch, unified aggregation; suits shardable tasks.

C3 Adversarial Review: independent reviewer agent audits generator output, eliminating same-family model bias.

C4 Handoff: peer-level agents pass tasks sequentially; typical in customer service.

C5 Sub-Agent Isolation: async sub-agents, service-oriented, independently queryable state.

C6 Choreography: dynamic workflow generation; core is JS interpreter + Prompt-to-Code.

LangChain ambassador Zhang Haili mapped LangChain's multi-agent primitives: Subagent (Supervisor), Handoff, Skill (lightweight collaboration), Router, and envisioned an Agent OS with compute-unit layer (delegation/sub-agents), storage layer (virtual filesystem), and human-governance layer (human-in-the-loop).

Core questions: How to divide labor? How to hand off? How to avoid conflict? How to ensure multi-agent whole > single agent?

7. Governance – Rules for the Agent

Governance is a cross-cutting core module—it doesn't do tasks but decides what agents may/may not do and what happens when they err. Essence: "Constraints bring more freedom." Three pillars:

Authorization: which DB, read/write, which APIs.

Accountability: trace root cause, assign responsibility.

Containment: limit blast radius of errors.

Four governance patterns:

G1 Approval Gate: high-risk actions gated, human approval when needed.

G2 Blast Radius Control: allow mistakes but bound their amplification.

G3 Progressive Commitment: sandbox success → expand permissions; trust built incrementally.

G4 Observability: cross-cutting; every agent must be seriously observed.

Li Qingfeng: "The challenge of production-grade agents is not being smarter, but being more controllable." Zendure senior agent infra engineer Xu Yibo posed a key engineering problem for approval gates: "After human approval, how does the system prove the executed action is exactly what was approved?" His solution: Durable Intent freeze —immutable object capturing identity, tool, parameters, policy; even if auth token expires, approval holds a verified historical fact.

Core questions: Who authorizes? What permissions? How to audit? How to contain errors? How to build trust incrementally?

Execution Topologies: How Agents Organize Execution

Zhang Dong reduced all multi-agent collaboration to three basic topologies:

Serial: tasks flow in fixed order; next agent starts after prior passes validation. Core: chain conduction control.

Parallel: multiple agents compute independently on shards; aggregation node collects results. Core: isolation and aggregation.

Routing: conditional branching to different paths. Core: rule transparency and layered adaptation.

These three nest and combine into higher-level patterns:

Chain-of-thought = Serial + Reasoning

Tree-of-thought = Parallel + Routing + Unified Convergence

Supervisor = Hierarchical Delegation + Fan-out/Fan-in

Handoff = Serial Handoff + Peer Switch

Dynamic Choreography = Routing + Code Generation + Real-time Execution

"The vast majority of enterprise agent collaborations decompose into nesting of serial, parallel, and routing. Skills are treated as capability embeddings, not counted at the conceptual abstraction level."

Beyond the Dual Axis: Cross-Cutting Layer and Time Dimension

Dewu R&D efficiency expert Ma Yangyang proposed adding a cross-cutting layer : "The matrix describes how agents do things; the cross-cutting layer describes capabilities/constraints every agent must have regardless of what it does." This layer includes observability, security, quality, resource cost, reliability, scalability—universal capabilities above all patterns.

The time dimension covers the full lifecycle: evaluation, version management, regression, canary release, operations. Extending from spatial structure to space+time gives end-to-end macro understanding. Huang Jia called this a "must-merge evolution PR." ZTE R&D coach Long Bo 's three-layer observability (observation/attribution/evolution) and Zhang Dong's four-layer agent control plane (registration/policy/observation/execution) validate the necessity.

Why ADPS Matters

Agent engineering is moving from "craft workshop" to "industrialization":

2023: a prompt = demo.

2024: need RAG, tool calling.

2025: need multi-agent, memory, observability.

2026: need governance, security, production stability.

Complexity grows exponentially; beyond individual grasp, we need patterns, frameworks, engineering methods. ADPS value:

Common language: terms like "hierarchical delegation", "fan-out/fan-in", "blast radius control" boost communication efficiency 10×.

Avoid repeated pitfalls: seven workshops distilled dozens of anti-patterns, each backed by real production incidents.

Decision map: for a design problem, know optional paths, applicability, and cost.

Connect theory and practice: abstract framework → concrete landing → feedback to framework, forming a closed loop.

"Simplifying the complex is a remarkable ability; keeping complex problems in their original production shape and using tools to solve real-world complexity is equally remarkable." — Huang Jia

Series Roadmap

This is the first of a 13-week ADPS workshop series. Upcoming deep dives:

Perception: Why 80% of reasoning/decision failures root in perception.

Memory: Knowledge compilation—making write and access one complete act.

Reasoning: From fast/slow to three modes and five anti-patterns.

Action: From Plan to execution—deterministic engineering of action boundaries.

Reflection: Core mechanism of cumulative agent intelligence.

Collaboration: From Supervisor to dynamic choreography—multi-agent teamwork.

Governance: Production challenge is not smarter but more controllable.

Each article draws on frontline enterprise expert practice—no empty theory, only how to land, what pits exist, how to avoid them.