Harness Architecture in Practice: A Full Breakdown of Multi-Agent Collaboration and Secure Execution

Harness architecture in practice: A2A is only for cross-platform boundaries, while security isolation and distributed governance are key.
Based on a tech talk on Bilibili, this article systematically breaks down the engineering essentials of the Harness architecture in multi-agent collaboration and secure execution. The author points out that the A2A protocol is inherently cross-network and cross-process, suitable only for task handoffs between agents on different platforms; using it for internal sub-agent collaboration would stretch a one-second response to two seconds, so in-process communication should be used instead. Enterprise interviews have fully shifted to Harness-related questions, covering user isolation, Agent Loop, distributed deployment, and tool-call error prevention. On the security side, Docker sandboxes and user isolation are emphasized; dynamic skills and long-term memory let agents adapt to new scenarios without retraining; high concurrency relies on horizontal scaling, call-chain tracing, maximum hop limits, and timeout circuit breaking to govern circular invocations.
Harness Architecture in Practice: A Full Breakdown of Multi-Agent Collaboration and Secure Execution
As AI Agents move from single-point tools toward engineering deployment, how to organize multiple agents to collaborate efficiently, how to execute scripts securely, and how to manage long-term memory and high concurrency have become problems developers must face. A recent tech talk on Bilibili centered on the Harness architecture, and drawing on real interview questions from companies, broke down key designs such as the A2A protocol, Docker sandboxes, and dynamic skills. Based on that talk and integrating multiple perspectives, this article lays out actionable engineering approaches.
Multi-Agent Collaboration: Where Should the A2A Protocol Be Used?
The A2A (Agent-to-Agent) protocol is often misunderstood as the universal glue for multi-agent systems. But the speaker made it clear that A2A is inherently cross-network and cross-process, making it suitable for handoff and delivery between two agents developed by different platforms and different teams. For example, when your agent cannot handle a user request, it hands the task off to an agent on another platform via A2A—involving network transmission, card discovery, and reading, all of which take time.

The problem is that if your system contains seven or eight sub-agents, all developed in-house, using A2A will actually slow down responses. The speaker described this as "using a cannon to shoot a mosquito"—the extra overhead of cross-network processes can stretch a response that should complete in one second to at least two seconds, directly hurting user experience. Therefore, internal agent collaboration should prioritize in-process communication or lightweight messaging mechanisms, while A2A is only suitable for boundary scenarios across organizations and technology stacks. This view aligns with the practice of most architects in the community: protocol choice must match the boundary, rather than blindly pursuing standardization.
The A2A protocol was proposed by Google in 2025 and donated to the Linux Foundation. Its core is to define standard interfaces for agents to discover capabilities, negotiate tasks, and exchange results. It relies on Agent Card (a metadata file describing an agent's capabilities and endpoints) to accomplish cross-network service discovery, and the interaction process typically involves HTTPS requests, streaming responses, and task status polling. Precisely because this mechanism targets heterogeneous agents that "don't trust and don't know each other," its protocol stack is relatively heavyweight. By contrast, in-process direct function calls, shared memory, or lightweight message queues typically have millisecond-level latency, whereas a single cross-network A2A round trip—even within the same data center—often takes tens to hundreds of milliseconds, plus serialization and authentication overhead; accumulated over multiple rounds of collaboration, this noticeably slows end-to-end responses.
Enterprise Interview Trends: Harness Becomes a Must-Test Item
The talk showed multiple screenshots of interview feedback from companies, where interviewers' questions almost all revolved around Harness: user isolation and security isolation, multi-agent architecture, Agent Loop, distributed deployment, tool-call error prevention, circular invocation issues, and more.

According to the speaker's observations, in the second half of 2026, interviewers will particularly focus on Harness-related experience—there's even a saying that "without Harness in your project, you'll barely get any interview calls after submitting your resume." Behind this is the release of the DeepSeekAd Harness public beta, after which developers found its plugin flexibility and features on par with Claude Code and Codex—even more flexible because plugins can be installed freely.

The speaker believes that Harness's popularity marks agent development moving from "hand-rolling" to "frameworkization," with companies beginning to require candidates to have practical Harness Engineer capabilities. Although the claim that "you can't find a job without Harness" is a slight exaggeration, the trend is clear: mastering the Harness architecture has become a plus for AI Agent engineering.
In this context, Harness does not refer to the CI/CD company of the same name, but to the agent runtime framework wrapped around the large model: it is responsible for organizing the Agent Loop (the cycle of perception—planning—tool invocation—observation of results), managing tool and plugin registration, handling context and memory, and enforcing permission and sandbox constraints. You can think of it as "the operating system layer for agents"—the model itself only provides reasoning capability, while the Harness determines whether it can execute real tasks safely, stably, and scalably. The attention drawn by DeepSeek's public beta of Harness is essentially because, for the first time, the open-source community has a general-purpose runtime framework with a relatively open plugin ecosystem that lets you extend tools yourself. This contrasts with more closed product forms like Claude Code and Codex, and also explains why enterprise recruiting has begun to use it as a capability benchmark.
Secure Execution and Isolation: Docker Sandboxes and User Isolation
Interview questions repeatedly feature "security isolation," "user isolation," and "tool-call error prevention," indicating that security requirements in production environments have risen to the architectural level. In the Harness architecture, script execution is typically implemented through Docker sandboxes, ensuring that code generated by the agent cannot affect the host machine or user data.

User isolation requires each session or tenant to have an independent runtime environment, memory space, and tool permissions. The speaker mentioned that interviewers will follow up with "how do you prevent tool-call errors when there are many tools," which requires designing tool routing, parameter validation, and failure retry mechanisms. Combined with Docker sandboxes, tool calls can be pre-executed in an isolated environment and only released after validation passes. Multi-source analysis shows that the industry has reached consensus on the necessity of sandbox isolation, but there is still discussion about the granularity of isolation (process-level vs. container-level), requiring trade-offs between performance and security.
The core difference between container-level sandboxes and process-level isolation lies in boundary strength and overhead. Process-level isolation (such as seccomp, namespaces, or subprocess privilege reduction) starts quickly and uses fewer resources, but shares the kernel, so an escape can have a large impact; container-level isolation leverages independent file systems, cgroup resource limits, and network namespaces to limit CPU, memory, and outbound network behavior, with startup typically in the hundreds of milliseconds to seconds. A common compromise in production practice is "pooled pre-warmed containers + short-lived execution": pre-launch a batch of idle sandboxes, inject code directly for execution when tasks arrive, and destroy and rebuild afterward—controlling cold-start latency while ensuring each execution environment is clean. For high-risk scripts, you can also layer on read-only mounts, blocking external network access, and forced termination on timeout.
Dynamic Skills and Long-Term Memory: Letting Agents Continuously Evolve
The Harness architecture supports dynamic skill loading, allowing agents to install or invoke plugins as needed—similar to giving the agent an "extensible toolbox." Long-term memory is implemented through vector databases or structured storage, enabling the agent to maintain contextual continuity across multiple sessions. The speaker emphasized that combining dynamic skills with long-term memory allows agents to adapt to new scenarios without retraining—one of the reasons Harness is more flexible than traditional frameworks.
High-Concurrency Design for Production: Distributed Deployment and Circular Invocation Governance
Interview questions like "How do Agents achieve distributed deployment" and "How do you solve the multi-agent circular invocation problem" point to real challenges in production environments. Under high concurrency, agents need horizontal scaling, making task queues, load balancing, and state management critical. The circular invocation problem must be governed through call-chain tracing, maximum hop limits, and timeout circuit breaking. The speaker recommends that in the Harness architecture, each Agent Loop should have explicit termination conditions, and cross-agent calls should be recorded via distributed tracing to avoid infinite loops consuming resources.
Conclusion
The practical key points of the Harness architecture are: the A2A protocol is only for cross-platform boundaries, while internal collaboration pursues low latency; security isolation relies on Docker sandboxes and user isolation; dynamic skills and long-term memory improve adaptability; high concurrency depends on distributed deployment and circular invocation governance. As enterprise interviews shift comprehensively toward Harness, mastering these design principles will become the core competitiveness of AI Agent engineers.
Related articles
Tech FrontiersEdge AI on Microcontrollers: When Is It Actually Worth Deploying?
Drawing on Reddit discussions and Arm case studies, this article analyzes the real-world use cases for edge AI on microcontrollers: when each device needs independent inference, when a gateway or cloud is more reasonable, and the costs and boundaries of specialized hardware.
Tech FrontiersPushing the Limits of Extreme Sudoku on a 16GB GPU: Insights from Depth and Flow Matching
A researcher trained a 16.54M-parameter model on a 16GB GPU to solve extreme Sudoku, finding effective depth breaks the 60% plateau and flow matching with improved sampling pushes accuracy past 99% with ~50× lower layer-evaluation budget.
Tech FrontiersAI Agent Approval Workflows: Why Human Confirmations Always Get Mindlessly Clicked
Why do AI agent approval workflows always get mindlessly clicked? A Reddit discussion shows that separating rules from keys, low-frequency high-risk approvals, and GitHub Environments-style gates are the keys to effective approvals.