Cloud Agents is a fully managed AI Agent runtime platform launched by Qoder. Developers only need to write Agent logic code, and the platform automatically handles deployment, expansion and contraction, monitoring and logging. Supports MCP tool chain integration and multi-model switching Webhook triggering. Serverless architecture, pay according to actual calls.

CloudAgents

Core parameters and statistics of Cloud Agents

Cloud Agents is positioned between the PaaS platform and the AI Agent framework - it does not provide Agent building capabilities (you need to write your own logic code), nor is it just an API gateway, but a complete runtime execution context. The following parameters are based on the official public page.

Parameters	Official verifiable information
Product positioning	Fully managed AI Agent runtime platform (Managed Agent Runtime)
Architecture Form	Serverless
Tool Integration Protocol	MCP (Model Context Protocol)
Supported large models	OpenAI (GPT series), Anthropic (Claude series), DeepSeek, etc., support custom model endpoints
Agent triggering method	REST API, Webhook, scheduled tasks (Cron)
Billing granularity	Billing based on call volume (number of calls + execution time)
Developer	Qoder (Singularity)
Team location	China
Online time	2026-05 (v1 public version)
Free quota	Provided (specific quota)
Private deployment	Undisclosed support

A brief comment: Cloud Agents are like Vercel for front-end applications - you push the Agent code, and it is responsible for running it, carrying traffic, and recording logs. You don't have to worry about the server.

Positioning difference with competing products: Different from platforms such as Coze and Dify that provide visual Agent builders, Cloud Agents does not provide an orchestration layer, but only a runtime layer. It doesn't care how your Agent's internal logic is organized, it only ensures that the code can be executed reliably and scalably in the cloud. This difference makes it more attractive among advanced developers who need to customize Agent behavior, but the lack of visual assembly capabilities also means it is not suitable for non-technical users.

Comparison Dimensions	Cloud Agents	Coze/Dify	AWS Bedrock Agents
Core Positioning	Agent Runtime Hosting	Agent Build + Hosting	Agent Build + Cloud Infrastructure
Do you need to write code	Yes (upload code)	No (visual arrangement)	Partial (needs configuration)
MCP integration	Native support	Plug-in ecology	Lambda customization
Billing model	By call volume	Freemium + subscription	By resource + API call
Private deployment	Unpublished	Enterprise version support	Deployment within VPC
Threshold to get started	Medium (coding required)	Low (drag-and-drop)	High (AWS ecosystem)

User and market recognition of Cloud Agents

Cloud Agents was launched by Qoder and occupies the "runtime hosting" segment in the AI Agent infrastructure track. Qoder has launched a series of tools around the Agent ecosystem, including Qoder CLI, Qoder Rules, and Qoderwake, in which Cloud Agents assume the role of the runtime execution layer.

Market positioning: The pain point targeted by Cloud Agents is the "deployment gap of AI Agent from prototype to production". It is easy for developers to run the Agent locally or in a Notebook, but to turn it into a production service that is online 7×24 hours, can handle traffic, and has monitoring and alarms, it is necessary to deal with a series of infrastructure issues such as containerization, automatic expansion and contraction API current limiting, and log collection. Cloud Agents abstract this layer into platform capabilities.

Competitive Landscape: Cloud Agents operates in a racetrack that is heating up rapidly in 2025-2026. There are AutoGPT's hosting platform LangGraph Cloud and CrewAI's hosting solutions abroad, and there are runtime modules for various Agent platforms in China. The core difference of Cloud Agents is the focus on "pure runtime" - it does not bundle its own Agent framework. Developers can use any framework (LangChain, CrewAI, AutoGen, self-developed framework) to write Agents, as long as the final output is callable code. This framework agnosticism is valuable in teams that need to migrate or mix frameworks.

Cost Advantages of Cloud Agents

The cost structure of Cloud Agents is driven by two engines: "serverless architecture" and "pay-per-call", which eliminates the waste of idle resources and investment in operation and maintenance manpower.

C-side/individual developers: The platform provides free quota (the specific value is subject to the real-time page of cloudagents.ai official website), which is suitable for individual developers' PoC verification and small traffic scenarios. Serverless architecture means developers don't pay for idle time - the agent is billed zero when there are no requests, and each call is only billed for actual execution time and API consumption. For personal projects in the prototype verification stage, this billing model is more economical than fixed monthly fee VPS or container solutions - for a lightweight Agent that is triggered dozens of times a day, the monthly fee may be controlled within a few dozen yuan.

API/Developer Call: Cloud Agents does not charge a fixed monthly platform fee, developers only pay for the following dimensions:

• Number of calls: Count of requests executed by Agent each time
• Execution time: The running time of the Agent code from startup to return of results
• LLM API fee: token consumption generated by Agent calling third-party large models (need to be borne by yourself)

In addition, the outbound bandwidth and storage costs of the cloud platform itself also need to be included in the cost model on a larger scale.

Enterprise/Private Deployment: Enterprise-level pricing is not disclosed. Large-scale deployment requires contacting the business to obtain customized solutions. Enterprises need to comprehensively consider the following hidden costs when making assessments: data residency and compliance (whether data is forwarded through the Cloud Agents platform), SLA levels (the impact of platform downtime on the business), and the cost of the migration path from Cloud Agents to self-hosting (whether the code is deeply coupled with the platform API).

Three-tier cost comparison:

Cost Dimension	Individual Developer	API Caller	Enterprise Level
Fixed fee	0 (within free limit)	0	Business confirmation required
Pay-as-you-go fee	Pay-as-you-go fee after the free quota is exhausted	Number of calls + execution time	Volume discounts possible
Hidden costs	Learning curve	Frequency control and latency	Data compliance SLA, migration costs
Suitable Stage	Prototype / PoC	Production Lightweight Deployment	Large Scale / Compliance Sensitive

Main functions of Cloud Agents

The functional design of Cloud Agents revolves around the core goal of "making Agent code run reliably in the cloud". It does not include the Agent construction layer, but provides the support capabilities required at runtime.

• Fully managed Agent runtime: Developers upload Agent code (supporting Python, TypeScript and other languages) through CLI or API, and the platform automatically completes containerization encapsulation, resource allocation, elastic scaling and load balancing. Hidden linkage: Automatically detect Agent's dependency declaration (such as requirements.txt) at runtime, and pre-install dependencies in the sandbox environment, eliminating the need for developers to manually build images. This "code-as-deployment" experience reduces the time from coding to go live from hours to minutes.

• MCP tool chain integration: Native support for MCP protocol, allowing Agent to call external tools through MCP Server - browser control, file system operations, database query API calls, etc. Expert View: The integration method of MCP is the most noteworthy synergy of Cloud Agents - in the Agent code, you only need to declare the tool call according to the MCP standard, and the platform automatically routes to the corresponding MCP Server, completing the transparent conversion from "Agent in-process tool call" to "remote MCP service execution". This means that Agent developers do not need to care about the deployment and operation of MCP Server, but only need to focus on tool interface semantics.

• Multi-model routing and Fallback: Configure multiple LLM endpoints in the same Agent to support routing requests by priority or weight. Automatically downgrade to an alternative model when the preferred model returns an error or times out. Implementation Tips: Under the hybrid model strategy, complex inference tasks can be routed to DeepSeek or Claude, and simple text generation can be routed to cheaper models to optimize token costs while maintaining output quality. The configuration of model switching belongs to the platform layer, and the Agent code itself does not need to be modified.

• Built-in monitoring and observability: Provides a call monitoring panel to display delay distribution, success rate, error code distribution, and Token consumption trends in real time. Supports structured log retrieval and custom alarm rules (such as notifying Webhook when the error rate exceeds the threshold). Acceptance Concerns: Monitoring latency data is crucial to troubleshooting Agent performance bottlenecks - if the Agent's P95 latency is much higher than P50, it usually indicates that there are sporadic external dependency timeouts in the code, and retry or timeout control logic needs to be added.

• Webhook and event-driven: Supports three Agent calling modes - HTTP API (synchronous request-response), Webhook (asynchronous event triggering), and Cron scheduled tasks (periodic execution). Scenario Example: A "Daily Public Opinion Summary Agent" can be configured to be triggered through Cron at 9:00 every morning, grab the latest content from the specified source, call LLM to summarize and push it to DingTalk or Feishu through Webhook.

• Version Management and Grayscale Release: Each uploaded version of the Agent code is saved as a snapshot, supporting rollback and grayscale release (routing traffic to the new version proportionally or conditionally). Implementation Tips: Grayscale publishing is a necessary capability in production scenarios - new Agent logic may produce abnormal output under specific inputs, and the grayscale mechanism can control the impact range within an acceptable proportion.

Model and version evolution of Cloud Agents

The version evolution of Cloud Agents reflects Qoder's path from "validating agent runtime feasibility" to "building a production-grade hosting platform."

Internal prototype and internal testing (2025-12 to 2026-03)

• Cloud Agents alpha (~2025-12): Internal prototype stage, the core goal is to verify the architectural feasibility of the serverless Agent runtime - whether the containerized startup of the Agent code can be completed in seconds, and whether it can handle burst traffic. No public information is available at this stage.
• Cloud Agents beta (~2026-03): Directed internal beta version, inviting some developers to try it out. Supports basic Agent code deployment, execution and log viewing, and is bound to Qoder's own LLM routing capabilities. Private beta feedback focused on MCP tool integration and billing transparency.

Public version (2026-05 to present)

• Cloud Agents v1 (~2026-05): The first public version and the latest stable version. Core competencies include:
  • Native integration of MCP protocol, support for mounting external MCP Server -Multiple model switching and Fallback
  • REST API / Webhook / Cron three triggering methods
  • Monitoring panel (delay, success rate token)
  • Version management and grayscale release
  • CLI toolchain (cld deploy, cld logs, cld invoke)

Version Evolution Note: The version rhythm of Cloud Agents is synchronized with the Qoder ecosystem. Since the product is relatively new and there is limited information on historical versions, the above internal version dates are estimates of project milestones, and there is no official precise date yet. Subsequent releases are expected to add private network support, more granular permissions management, and integration with enterprise identity providers (IdPs).

Technical advantages of Cloud Agents

Tool type determination: Cloud Agents belong to Agent / MCP / Automation Tools - a fully managed AI Agent runtime platform that does not provide Agent building capabilities and focuses on the deployment, orchestration and observability of the execution layer.

Architecture link

Cloud Agents are in the "execution layer" position in the entire Agent workflow, connected to the Agent code, and connected to the LLM API and external tools:

Developer (CLI/API)
    │
    ▼
┌────────────────────────────────────┐
│ Cloud Agents Runtime │
│ │
│ ┌─────────┐ ┌───────────────┐ │
│ │ Sandbox Container │ │ Model Routing Engine │ │
│ │ (Agent) │──│ (LLM Router) │ │
│ └────┬────┘ └───────┬───────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────┐ ┌───────────────┐ │
│ │ MCP Agent │ │ Monitoring & Logging │ │
│ └────┬────┘ └───────────────┘ │
└────────┼───────────────────────────────┘
        │
        ▼
┌────────────────┐ ┌──────────────────┐
│ Third-party LLM API │ │ MCP Server │
│ (OpenAI, Claude│ │ (Browser/DB/File) │
│ DeepSeek, etc.) │ │ │
└─────────────────┘ └───────────────────┘

Control flow: CLI/API submits the Agent code → the platform creates a sandbox container → the Agent runs and initiates an inference request to the LLM → the Agent calls the MCP tool → the results are returned to the platform → log/monitoring postback.

Data backflow: The execution results of the MCP Server are flowed back to the Agent context. The Agent decides the next action or generates the final response based on the new context. The response is forwarded to the caller through the platform.

Tool open list

Cloud Agents themselves do not directly expose browser control or system operation tools, but are implemented through MCP Server. The core capability interfaces (Tools) exposed by the platform to Agent include:

• mcp_tool_call(tool_name, args): Call the registered MCP Server tool
• llm_chat(model, messages, params): Initiate a conversation request to the specified LLM
• store_get(key) / store_set(key, value): Agent level KV storage (persistence across calls)
• log_info(msg) / log_error(msg): structured log writing
• http_request(url, method, headers, body): HTTP request (for custom integration)

The above Tool is exposed to developers through the Agent runtime SDK (Python/TS library) and can be called directly in the Agent code. Developers can also customize MCP Server to extend the Tool list.

Engineering Pitfall Guide

Based on the characteristics of the Agent runtime platform, the following are common engineering problems and response strategies in production environments:

1. Infinite Loops and Infinite Token Consumption: Agents may fall into an infinite loop of "thinking → calling tools → getting results → continuing to think" in complex tasks, leading to out-of-control execution time and skyrocketing token costs. Solution: Set max_steps (maximum tool call rounds) and global timeout (such as timeout=120s) in the Agent code. The platform side should also configure the maximum execution time of a single call and the upper limit of Token in the runtime layer. It is recommended that the upper limit of the Agent's steps be controlled within 10-20 rounds. If exceeded, the current intermediate result will be forced to return.

2. MCP tool exceptions and context pollution: When the MCP Server returns abnormal data (such as timeout, format error, security interception), the abnormal content may be included in the reasoning context by the Agent, causing subsequent reasoning to deviate from the expected path. Solution: Make a structured encapsulation of the tool return value at the MCP agent layer - put the exception information into a separate field (such as status: "error", error_type: "timeout") to prevent the exception content from entering the Agent's reasoning chain in the form of normal data. The Agent code should verify the result validity after each tool call, rather than assuming that the call must be successful.

3. Token billing difference for multi-model switching: After multi-model fallback is configured in the Agent, the difference in input and output token prices of different models may vary by more than 10 times. If the fallback link is not designed properly (e.g. high-frequency requests are continually routed to high-cost models), monthly charges may exceed expectations. Solution: Set priority + conditional rules in the model routing strategy (such as "low-priced models are preferred for simple questions and answers, and fall back to high-priced models for complex reasoning"), and track the Token consumption distribution by model dimensions in the monitoring panel to discover abnormal routing patterns in a timely manner.

Get started quickly in 3 minutes

The following is a typical Cloud Agents Agent deployment process (taking Python as an example):

Step 1: Install CLI

npm install -g @qoder/cloud-agents-cli
# Or use the Python version
pip install cloud-agents-cli

Step 2: Write Agent Code

# agent.py
from cloud_agents import Agent, tool

class MyAgent(Agent):
    def run(self, input_text: str) -> str:
        # Call LLM
        response = self.llm.chat(
            model="deepseek-chat",
            messages=[{"role": "user", "content": input_text}],
            temperature=0.7
        )
        # Call MCP tool
        weather = self.mcp.call("weather-server", {
            "city": "Beijing"
        })
        return f"{response} | Weather: {weather}"

Step 3: Deploy

cld login # Log in (requires cloudagents.ai account registration)
cld deploy agent.py --name my-agent
cld invoke my-agent --input "Is it a good time to go out in Beijing today?"

Step 4: View logs

cld logs my-agent --tail

Configuration to mount MCP Server (declared in cloudagents.yaml):

agents:
  my-agent:
    source: ./agent.py
    runtime: python3.11
    mcp_servers:
      - name: weather-server
        transport: stdio
        command: npx @qoder/mcp-weather
      - name: browser-server
        transport:sse
        url: https://browser-mcp.example.com/sse
    models:
      primary: deepseek-chat
      fallback: claude-3-5-sonnet
    timeout: 60
    max_steps: 15

The above configuration and code are derived based on Cloud Agents public documentation and CLI behavior. For specific commands and parameters, please refer to the official documentation of cloudagents.ai.

How to use Cloud Agents

Cloud Agents provides three ways to interact with the platform: CLI, Web management console, and REST API, covering different needs from personal development to automated integration.

How to use	Applicable scenarios	Core capabilities
CLI (cld command line)	Developers manage Agent locally	Deployment, calling, log viewing, version management
Web management console	Agent visual management and monitoring	Call panel, log retrieval, alarm configuration
REST API	CI/CD integration and automated scheduling	Agent deployment, triggering, status query

Typical workflow for developers:

1. Write and test Agent code locally via CLI
2. Use cld deploy to push the code to the Cloud Agents runtime
3. Verify production context behavior through cld invoke
4. Configure Webhook or Cron trigger to let Agent run automatically
5. View monitoring data and retrieve logs through the Web management console

API integration: Cloud Agents provide a RESTful API that supports deploying and invoking Agents through HTTP requests. The API endpoint uses https://api.cloudagents.ai/v1/ as the base path and uses API Key for authentication. The specific endpoint list and parameters are subject to official documents.

Product Pricing for Cloud Agents

Cloud Agents adopts a pay-per-use model and does not charge a fixed monthly platform fee. The pricing structure is relatively simple, but details are needed.

Free quota: The platform provides new users with a free calling quota (including a certain number of free calls and execution time). The specific value is not clearly disclosed in public channels. You need to check it after registration or refer to the latest announcement on the official website.

Pay-as-you-go: After the free quota is exceeded, billing will be based on the following dimensions:

• Number of calls: Each Agent execution is counted as one call
• Execution Time: Billed based on the actual running time (seconds) of the Agent code
• Additional resources: If you apply for a sandbox container with higher specifications (memory/CPU), the price will be increased according to the specification gradient.

Implicit cost structure:

• LLM API fees are not included in the Cloud Agents bill: The Token consumption generated by the Agent calling third-party large models is borne by the developer. This cost is usually much higher than the calling fee of the platform itself. The monthly LLM API fee for a high-frequency Agent may reach 5-10 times the platform fee.
• Outbound bandwidth: If the Agent frequently downloads large files or transmits large amounts of data, the outbound bandwidth cost of the cloud platform cannot be ignored.

Enterprise Pricing: Undisclosed. In large-scale or high-frequency calling scenarios, you need to contact the business to obtain customized solutions. It is recommended to confirm the following terms before purchasing: volume discount gradient SLA availability commitment, data storage period, and platform version update compatibility guarantee for existing Agents.

Application scenarios of Cloud Agents

The core value of Cloud Agents is to "make Agents go online quickly and run stably". The following four scenarios have been verified by initial users:

• Automated content production link: Configure an Agent that "crawls → summarizes → distributes" and triggers it regularly through Cron. Agent grabs the latest articles from RSS/API, calls LLM to generate Chinese summaries and key conclusions, and pushes them to Feishu/DingTalk or CMS system through Webhook. Implementation Tip: This scenario requires the stability of the Agent higher than the response speed - even if a single execution takes 1-2 minutes, it is acceptable, but it must be executed on time every day without missing any negatives. Cloud Agents' Cron triggers and failure retry mechanisms are naturally adapted.

• Intelligent classification and reply of customer service work orders: Connect the enterprise customer service system to Cloud Agents through Webhook. Whenever a new work order is created, the Agent automatically reads the content of the work order, calls LLM to classify (complaint/consultation/after-sales) and generate a draft reply. Implementation Tips: It is recommended to set Human-in-the-loop for important work orders - the responses generated by the Agent are sent to manual review before being issued, and automatic replies are only enabled on low-risk work orders. The version management capabilities of Cloud Agents are particularly useful in this scenario - if a certain version generates inappropriate replies, you can roll back to the previous version in seconds.

• Data reporting and monitoring inspection: Agent regularly queries the database or API to obtain business indicators, calls LLM to analyze data anomalies and trends, and generates structured reports. Implementation Tip: The risk of illusion when the Agent analyzes data needs to be paid attention to - it is recommended to clearly require in the prompt that "the analysis is only based on the provided data, and does not supplement the unprovided hypothesis information", and to mark the data source and deadline in the output.

• Personal Efficiency Assistant (scheduled reminder + information aggregation): Configure multiple lightweight Agents, each responsible for a fixed task - daily news summary, stock change reminder, and automatic generation of weekly reports. Individual developers can run these agents within the free quota at almost zero cost. Implementation Tips: Multiple Agents can share the same MCP Server (such as weather query, news crawling) to avoid deploying a separate tool chain for each Agent.

Applicable groups of Cloud Agents

Cloud Agents has a clear positioning - it is designed for developers who "can write code and don't want to worry about operation and maintenance". It is not recommended for non-technical users to use it directly due to lack of Agent building capabilities.

• AI application developers and independent developers: This is the core user group of Cloud Agents. If you already know how to write Agent using LangChain, CrewAI or directly call LLM API, but are tired of having to write Dockerfile, configure Nginx, and Prometheus for every deployment, Cloud Agents can skip these details directly. Prerequisite: You need to have Python or TypeScript programming capabilities and understand the basic concepts of the MCP protocol. Not suitable for boundaries: If you need to visually drag and drop to build Agents, or complete deployment with zero code, Cloud Agents is not the right tool.

• Entrepreneurship Team (2-10 people): During the product and market validation stages, the team usually does not have a dedicated AI infrastructure engineer. Cloud Agents allow full-stack engineers to complete the entire Agent process from prototype to online within a few hours without waiting for DevOps resources. Implementation Tip: It is recommended to use the free quota to run PoC in the early stage of the project, and then decide whether to enter the paid plan after verifying the business value of the Agent. The team's path to migrating from Cloud Agents to a self-hosted solution needs to be evaluated in advance - if the Agent code relies heavily on the KV Store and MCP routing capabilities of Cloud Agents, these adaptation layers need to be rewritten during migration.

• Enterprise AI team (internal tool standardization): Encapsulate frequently used AI tools within the enterprise (such as contract review assistant, code review agent, data query assistant) into standard agents, and deploy and manage them uniformly through Cloud Agents. Prerequisite: The enterprise needs to confirm whether the data processing link of Cloud Agents meets compliance requirements (whether the data leaves the enterprise network boundary). Not suitable for boundaries: For finance, government affairs, and confidential industries that require complete offline deployment and data must not pass through third-party platforms, the cloud hosting model of Cloud Agents may not meet compliance requirements. Such scenarios need to wait for privatized deployment solutions or find alternatives.

• Not suitable for people: Cloud Agents are not recommended for the following groups - non-technical users who need a visual Agent builder; real-time interaction scenarios with strict sub-second response latency requirements (such as online customer service robots, voice conversation agents); AI inference services that require deeply customized runtime context (such as specific GPU drivers, dedicated hardware acceleration); and enterprises that have strict data sovereignty requirements and must be deployed privately.

Summary and Outlook of Cloud Agents

Cloud Agents has made a focused and restrained choice on the "AI Agent deployment and operation" segment, which is regarded by most platforms as additional functions rather than core products: not to build an Agent builder, but only to build the runtime layer. This "less is more" strategy is extremely attractive among developers with clear needs and strong technical capabilities - they do not need another low-code platform, but a reliable, flexible, zero-operation and maintenance Agent execution environment.

Core Competitive Advantages: Serverless architecture brings zero idle cost, native integration of the MCP protocol (rather than plug-in extensions), framework independence (no locking of any Agent development framework), and complete version management and grayscale publishing capabilities. At the time of 2026, Cloud Agents is one of the few pure Agent runtime hosting platforms in the domestic market.

Current major limitations: The product is still in the v1 stage, and the ecological maturity is limited - the number of available MCP servers and the officially maintained tool library are still under construction; enterprise-level functions (execution within private network VPC, fine-grained RBAC, audit logs) are not yet publicly supported; pricing transparency is insufficient, and cost estimates before large-scale calls require contacting the business; there is a lack of smooth migration paths between the platform and self-hosting, and the coupling between the code and the platform API is a potential risk of lock-in.

Follow-up observation points: Whether subsequent versions of Cloud Agents will launch enterprise-level privatized deployment solutions (this is the key to opening up the financial and government markets); the speed of enrichment of the MCP ecosystem - if the platform can preset a set of high-quality first-party MCP Servers, the integration cost for new users will be greatly reduced; and integration with mainstream Agents The official integration depth of frameworks (LangChain, CrewAI, AutoGen) - it is currently "framework independent" but "requires developers to adapt themselves". The official adaptation template will significantly lower the threshold for getting started.

Procurement and Adoption Risk Assessment: For individual developers and entrepreneurial teams, the free quota and pay-as-you-go billing model of Cloud Agents control the cost of trial and error to a very low level, which is worthy of PoC verification in the next Agent project. For medium and large enterprises, it is recommended to trial it in non-critical process scenarios (internal knowledge Q&A, report generation assistance, development tool chain Agent), evaluate the stability, delay and cost model, and then decide whether to expand to quasi-production or customer-facing scenarios. Before signing a procurement contract, terms that need to be verified with the Cloud Agents commercial team include: geographical location SLA availability commitments for data storage and processing (especially P999 level guarantees), backward compatibility policies for platform version updates, and feasibility plans for data export and platform migration. For industries with sensitive data sovereignty, it is recommended to only use Cloud Agents to handle non-sensitive data scenarios before the privatized deployment solution is implemented.

Related tools: crewai, langchain

Version Info

• Cloud Agents v1 ：The first public version supports MCP tool chain, multi-model switching Webhook triggering, and monitoring panel. （~2026-05）
• Cloud Agents beta ：Internal beta version, basic Agent runtime and deployment capabilities. （~2026-03）
• Cloud Agents alpha ：Internal prototype stage to verify the feasibility of the serverless Agent runtime architecture. There is no official precise date yet. （~2025-12）