This article is summarized from the sharing session by Zhou Qi, Head of Cloud-Native Application Platform at Alibaba Cloud Intelligence Group, and Li Guoqiang, Product Manager of AgentCore, at the Apsara Conference.
While the investment in Agents has become a consensus, production-grade adoption remains the minority.
Over the past year, various approaches have developed rapidly: building custom Harnesses based on high-code Agent Frameworks, reusing productized Harnesses, constructing Agents based on models, and quickly building Agents on top of the preset capabilities of cloud products. Agents have already become an interface for personal productivity, and enterprises are beginning to design Agents into business processes such as customer service, marketing, R&D, operations, and manufacturing. However, true production-grade deployment remains rare.
The reason is not complex. When building an Agent for personal use, occasional fluctuations in performance are acceptable; one can simply re-execute the task or adjust the context. However, handing over real work to an Agent imposes entirely different requirements. It may need to run for extended periods, call multiple enterprise systems, access sensitive data, collaborate with other Agents and humans, and ultimately be accountable for business outcomes.
This means that deploying Agents in enterprise production environments faces four major shifts:
Alibaba Cloud's newly released AgentCore is an enterprise-grade Agent construction and governance platform launched specifically for this stage.
Model outputs are probabilistic. The same question asked at different times may yield slightly different answers. Once inside an Agent, this uncertainty expands further.
An Agent does more than generate text. It understands goals, breaks down tasks, selects tools, reads knowledge, calls external systems, and decides the next step based on intermediate results. A single task may involve multiple steps, and a deviation in any step can affect the final outcome.
For personal use, this uncertainty is usually acceptable. If the result is unsatisfactory, one can modify the prompt or rerun the task. However, in an enterprise production environment, an Agent might be handling a fault incident, modifying a customer record, or executing a cross-system business operation. Enterprises cannot treat "trying multiple times" as a stability solution.
While model outputs can be probabilistic, production processes must have boundaries, and business results must be verifiable.
Therefore, deploying Agents in production requires answering a set of questions rarely faced by traditional demos:
• How is state preserved during long-running tasks?
• Can execution resume from the point of failure after an interruption?
• How is context isolated when multiple tasks run simultaneously?
• Can we fully trace which tools an Agent called and what resources it modified?
• Can humans take over in time when the Agent prepares to execute high-risk operations?
AgentCore integrates these issues into a unified runtime and governance system.
• Runtime and Sandbox provide isolation, elastic scheduling, and the environment required for long-running tasks.
• Harness manages sessions, states, and task recovery.
• Agent Identity, AI Gateway, and Audit capabilities constrain the action boundaries of Agents.
• Observability and Evaluation capabilities record the execution process and determine whether task results meet requirements.
This system focuses not just on whether the Agent returns a result, but on whether the task is completed continuously, correctly, and controllably.
AgentCore is a one-stop Agent construction and governance platform launched by Alibaba Cloud for enterprises.
It does not require enterprises to adopt a single Agent form. Enterprises can build Agents using high-code or managed Harnesses, or integrate existing cloud-based and desktop Agents into a unified observability and governance system. Users can quickly create and register Agents on AgentCore, which provides capabilities for construction, runtime, governance, and tuning, including Runtime, Sandbox, Memory, Knowledge Base, Model Services, AI Gateway, Observability, and Evaluation.
However, viewing AgentCore merely as an Agent development platform underestimates the problems it aims to solve.
The object managed by AgentCore is the complete lifecycle of a task—from construction and execution to acceptance and improvement. This includes building and integration, runtime and governance, human-Agent collaboration, and how to use knowledge and tools to accept output results, accumulate experience, and continuously improve Agent performance.
In the experimental phase, teams typically look at one result: Can the Agent complete the task?
In production, this question is broken down further. Accuracy of the answer is just one aspect. Enterprises also need to know:
• Was the Agent's planning reasonable?
• Were the correct tools selected?
• Were parameters correct?
• Was knowledge retrieval relevant?
• Did invalid loops occur during execution?
• How much time and Token consumption did the task require?
This requires expanding the object of observation from a single model request to the complete execution trajectory of the Agent.
A trajectory records what task the user proposed, what judgments the Agent made, which models, tools, and knowledge bases were called, what results were obtained at each step, and how these results influenced subsequent actions. Engineers can review the execution process at different levels (user, session, single-turn request) to pinpoint exactly where a problem occurred.
After seeing the process, one must judge whether the process and result are correct.
AgentCore deeply integrates with Alibaba Cloud AgentLoop:
• Code Judge: For deterministic issues such as format, numerical thresholds, and API parameters.
• LLM Judge: For single-turn Q&A, text quality, and semantic matching.
• Agent Judge: For multi-turn conversations, tool calls, RAG, Skills, or cross-system tasks. It reads the complete trajectory, calls tools to verify facts, and makes judgments based on the enterprise’s own business rules.
Evaluation cannot stop at a single score. Low-scoring samples and failure cases generated during online operation must enter a Dataset. New versions after modification must undergo regression testing using evaluation sets. Only after confirming no degradation should they be gradually released to the production environment. In this way, Agent improvement is not based on "feeling this version is better," but is data-driven, comparative, and verified.
Costs also require similar refined management. AgentLoop can analyze Tokens, costs, latency, and success rates per caller, Agent, and model. Quotas can be set for different personnel, teams, and models. If abnormal spikes or limits are exceeded, the system can alert, throttle, degrade, or block requests.
Extensive usage cares about whether it runs; refined usage cares about why it runs this way and whether the result is worth it.
Only when quality, process, and cost can be measured does an Agent truly have the foundation for continuous optimization.
When enterprises first start using Agents, small teams usually choose frameworks, connect models, configure tools, and deploy environments independently. This approach is suitable for validating ideas but struggles to support scaled operations.
As the number of Agents increases, enterprises quickly face redundant construction: each team maintains its own runtime environment, reconnects to models and knowledge bases, and handles identity, credentials, logs, evaluation, and costs separately. There are no unified standards for versioning, permissions, or quality across different Agents, making it difficult to quickly identify responsible parties when issues arise.
If Agent usage scales to millions of daily active users, the platform needs to manage not just a few applications, but a new Intelligent Infrastructure.
AgentCore's approach is not to transform all Agents into the same form, but to provide a common runtime and governance foundation.
(Zhou Qi sharing on AgentCore’s platform governance capabilities)
• Construction Level: High-code Agents, different types of Harnesses, and existing enterprise Agents can choose the appropriate method based on their scenarios.
• Runtime Level: The platform provides isolation, elasticity, and session management.
• Connection Level: Models, Skills, MCP (Model Context Protocol), Knowledge Bases, and enterprise systems can be integrated uniformly.
• Governance Level: Agents of different forms enter the same system for identity, permissions, observability, evaluation, audit, and cost management.
Workflows will not disappear. In highly deterministic and strictly compliant stages, workflows remain suitable for expressing clear steps. In tasks requiring autonomous planning and dynamic decision-making, Agents can take on more work. Enterprises do not need to choose a single technical route but rather allow them to play their respective roles on a unified infrastructure.
The value of intelligent infrastructure is not to unify the Agent construction paradigm, but to allow different Agents to operate under the same set of rules.
Only by forming this common foundation can enterprises move from individual employees using Agents effectively to the entire organization using Agents stably and reliably.
Complex businesses are rarely completed by a single Agent independently.
For example, a fault investigation may require analyzing exception logs, checking call chains, correlating recent changes, and verifying recovery plans. If all work is assigned to one Agent, its context becomes increasingly long, and task boundaries become increasingly blurred.
AgentCore adopts a more reasonable approach by selecting different collaboration structures based on the nature of the task.
(Li Guoqiang sharing on AgentCore's collaboration capabilities)
In Team Mode, the Leader Agent is responsible for understanding intent, breaking down tasks, and monitoring progress, while Worker Agents handle professional work in different domains. The team shares the context necessary to complete the task, while maintaining isolation between different tasks. Humans can directly view communications and deductions between Agents, supplement information, interrupt execution, or approve at key nodes.
This collaboration method changes not only system architecture but also organizational division of labor.
• Business Owners: Define goals, accept results, and handle exceptions.
• Domain Experts: Maintain knowledge, Skills, and evaluation sets, and review failure cases.
• Platform Teams: Provide common capabilities such as runtime, permissions, observability, budgeting, and release.
Agents perform the execution work, but there must still be clear accountability for the results.
An intelligent organization is not about having more Agents work simultaneously, but about humans and Agents collaborating around the same result. Without common goals, context boundaries, and acceptance responsibility, multi-Agent systems will only bring more calls, not better delivery.
Every time an Agent completes a task, it generates new information: which knowledge was truly useful, which tool call methods were effective, which reasoning paths were more stable, and which failures need to be avoided.
If this information remains only within a single session, the experience disappears once the task ends. The next Agent must still start from scratch.
Therefore, what enterprises need to consolidate is not just chat logs, but a set of intelligent assets that can be reassembled, verified, and managed.
• Knowledge and Memory answer "What basis was used to execute the task?"
• Skills answer "How should this type of task be done?"
• MCP and Tools are responsible for connecting to real business systems.
• Agent Templates combine roles, Skills, tools, and configurations into reusable solutions.
• Evaluation Sets and Evaluators preserve the enterprise’s definition of "what constitutes good performance."
Among these, Skills are gradually becoming an important carrier of enterprise experience. A Skill goes through writing, generation, and packaging, followed by version management, security scanning, distribution, permission management, evaluation, and tuning. Only in this way can methods summarized by individuals transform from a single file into enterprise capabilities that can be installed, traced, and continuously maintained.
AgentCore manages these assets through a multi-layer Catalog consisting of personal, enterprise, and external markets. Capabilities created by individuals can be used and tested privately first, entering the enterprise directory after quality verification. Agents, Skills, and MCPs introduced from external sources must undergo security and compliance reviews. Assets in the enterprise directory must register responsible persons, versions, permissions, quality standards, and usage feedback.
This mechanism solves two problems: how good capabilities are discovered by more people, and who is responsible when problems occur.
More importantly, assets do not remain static after release. Trajectories, evaluation results, and user feedback from production continue to flow back, driving the iteration of Skills, knowledge, tool configurations, and Agent versions. Verified new versions then re-enter the production environment.
What enterprises truly need to consolidate is not more Agents, but verified, reusable capabilities.
When successful methods for a task can be reused, and a failure can become a new evaluation sample, the Agent’s operation process will continuously increase the enterprise’s own capabilities, rather than just increasing model call volumes.
The value of Agents must ultimately return to business results.
• Did it meet quality standards?
• Was end-to-end time shortened?
• How much human intervention and rework were required?
• What was the total cost of completing the task?
These questions are more important than how many Agents an enterprise has created.
The direction represented by AgentCore is to connect construction, runtime, collaboration, assets, evaluation, and governance, remaining open to all Agents and their construction methods. The platform bears task execution, allows knowledge and experience to enter tasks, enables humans and multiple Agents to collaborate around goals, and uses production data for evaluation and improvement.
This process will not eliminate model uncertainty, nor will it make all business operations automatic. What it does is make uncertainty visible, constrain actions, make results verifiable, and allow effective experience to be retained.
(Zhou Qi sharing the team's "dogfooding" practice)
The AgentCore team is also "eating its own dog food," reshaping collaboration practices across front-end, middle-end, and back-end based on AgentCore, and productizing and servicing consolidated capabilities. For example, in front-end operations, DataAgent Mamba handles operational business analysis, connecting the collection, classification, evaluation, repair, and merging of open-source requirements through multiple Agents as a middle-end collaboration. At the back-end infrastructure level, it intelligently improves efficiency across the entire software delivery process—from SPEC, coding, code review, testing, and release to repair—creating a "10x efficiency benchmark." (We will share some excellent practice cases in subsequent updates.)
Construction determines whether an Agent can appear; productionization determines whether it can enter business processes, bear results, and ultimately stay.
When enterprises are no longer satisfied with merely possessing some Agents, but begin to build an operating mode that allows Agents to deliver continuously, Agents truly transform from a technical experiment into part of enterprise productivity.
From Reading Bills to Managing Cloud Spend: How STAROps Closes the FinOps Loop
780 posts | 60 followers
FollowJustin See - September 29, 2026
Alibaba Cloud Community - September 22, 2026
Alibaba Cloud Native Community - July 20, 2026
Alibaba Cloud Community - September 25, 2026
Alibaba Developer - January 9, 2020
Alibaba Cloud Community - May 9, 2024
780 posts | 60 followers
Follow
CloudMonitor
Automate performance monitoring of all your web resources and applications in real-time
Learn More
AgentLoop
An Agent self-evolution platform designed to make your Agents progressively smarter and more attuned to users.
Learn More
Simple Log Service
An all-in-one service for log-type data
Learn More
AgentCore
AgentCore unifies agent construction, governance, and execution capabilities so enterprises can deploy diverse agents with confidence.
Learn MoreMore Posts by Alibaba Cloud Native Community
