PolarDB Agent LakeBase is a workspace infrastructure designed to run AI agents at scale. It provides persistent workspaces for large numbers of agents, and each agent gets a fully isolated file system view that holds all the data assets it uses at runtime. Built on a cloud-native shared foundation, it lets millions of agents start and stop on demand and delivers agent-native workspace management such as second-level snapshots, second-level mount recovery, and lifecycle management. It connects to multiple compute environments, including Elastic Compute Service (ECS), Container Service for Kubernetes (ACK), and Function Compute (FC), and integrates with external data analytics ecosystems.
To use PolarDB Agent LakeBase, submit a ticket to contact us for assistance.
Product positioning
In the runtime architecture of an AI agent, infrastructure falls into the following parts:
The LLM acts as the CPU and handles inference and decision-making.
Tools such as MCP act as peripherals and connect to external tools.
The context window acts as memory and holds the temporary working area of the current session.
The workspace acts as the agent's persistent workspace and, like a hard disk, holds all of its persistent state and data.
As AI agents move toward large-scale deployment, they place new demands on workspaces. Traditional storage infrastructure can no longer meet agent requirements for large-scale access, elastic scaling, security isolation, lightweight deployment, and agent-native capabilities.
PolarDB Agent LakeBase is built for running AI agents at scale and provides persistent workspaces for large numbers of agents. Each agent gets a fully isolated workspace view that holds all the data it uses and generates while working. This supports stable access for large numbers of active agents and keeps agent data assets secure and under control. Its core capabilities include:
Agent-native independent view support: Each agent sees a complete, independent workspace file view that holds the file data the agent uses and generates at runtime. This matches the LLM paradigm trend of using files as the native interaction interface. Workspace views are independent of each other, which meets the isolation requirements of agents.
Agent-native connectivity: Support for multiple access protocols. Supports access from cloud compute environments such as Elastic Compute Service (ECS), Container Service for Kubernetes (ACK), Container Compute Service (ACS) Sandbox, and Function Compute (FC) Sandbox, and from self-managed systems in your IDC, for unified cloud and on-premises access.
Agent-native elasticity: Millions of agents start and stop on demand. The fully elastic storage space is built on object storage and handles sudden changes in agent count and data bursts.
Agent-native workspace management capabilities: Supports second-level snapshots, second-level mount recovery, workspace-level lifecycle management, quota management, traffic throttling, and file-level access control. These capabilities cover the entire lifecycle of an agent workspace, from creation and version management to hibernation and wake-up.
Agent-native ecosystem support: Runs embedded data processing components such as SQLite, LanceDB, and DuckDB directly to meet the various data processing needs of agents. It also integrates with external enterprise data processing and analytics systems, so data can be delivered directly to PolarDB ecosystem components for cleaning, retrieval, analysis, and other operations.
Architecture
PolarDB Agent LakeBase has the overall architecture shown in the preceding figure, and consists mainly of the following three layers:
Large numbers of active agents: Workspace storage is fully decoupled from agent compute. It supports access from compute environments such as Elastic Compute Service (ECS), Container Service for Kubernetes (ACK), Container Compute Service (ACS) Sandbox, and Function Compute (FC) Sandbox, and keeps millions of agents online at the same time.
Independent Agent Workspace views: Each agent sees a complete, independent workspace view where it can read and write files and organize directories, just as it would in a local file system. A workspace can hold the various data that an agent generates and uses while running, typically including:
Code and artifacts: Source code, scripts, application files, and website demos.
Documents and multi-modal data: Text, Markdown, PDF files, presentations, design documents, images, videos, and audio.
Knowledge bases and skills: Reference document sets, RAG corpora, shared documents, agent capability definitions, and prompt templates.
Runtime state and logs: State snapshots, session history, temporary files, and execution logs.
Data components: Embedded databases that agents read and write in place in the workspace (such as SQLite, DuckDB, and LanceDB), columnar datasets (such as Lance and Parquet), and package dependency directories (such as node_modules and Python site-packages).
Shared Agent Workspace foundation: A single cloud-native shared foundation holds the workspace data of all agents. It consists of three layers of components:
Metadatabase: Provides a high-performance metadata service based on PolarDB and supports large numbers of small files. PolarDB provides the transaction support, connection pooling, high concurrency, and rich indexing mechanisms that underpin advanced capabilities such as large-scale connections, snapshots, quotas, and lifecycle management.
Data storage: Built on elastic, low-cost object storage and billed by the storage capacity that you actually use.
Cache acceleration: Optimized for the access patterns of agent workloads. Hot data is cached close to compute nodes, which significantly reduces read latency.
Core capabilities
Agent-native independent view support
PolarDB Agent LakeBase provides an independent namespace for each agent to ensure access isolation:
Independent root directory for each agent: Each agent sees a complete file system view and can read and write files and organize directories as it would in a local file system, which lets agent code migrate between local environments and the cloud without changes.
Namespace isolation between agents: The files, directories, and databases of different agents are invisible to one another. This prevents cross-agent data leaks and meets the data security requirements of multi-tenant, multi-agent use cases.
Agent-native connectivity
PolarDB Agent LakeBase provides one unified access method for the diverse runtime forms of agents:
Support for multiple access protocols: PolarDB Agent LakeBase provides a standard POSIX file system interface through FUSE, which matches the LLM architecture trend of reading and writing with file primitives. It supports the file locking, atomic rename, symbolic link, and other semantics required by components such as embedded databases, columnar datasets, and package management tools. External applications can also access the same data through standard interfaces. Artifacts that agents generate, such as websites and reports, can be served externally without data migration.
Access from multiple compute environments: Natively supports access from cloud compute environments such as Elastic Compute Service (ECS), Container Service for Kubernetes (ACK), Container Compute Service (ACS) Sandbox, and Function Compute (FC) Sandbox, and also supports access from self-managed systems in your IDC.
Agent-native elasticity
PolarDB Agent LakeBase handles the load profile of millions of agents starting and stopping on demand, sudden changes in agent count, and data bursts:
Millions of agents starting and stopping on demand: Supports large-scale concurrent agent access and covers use cases in which large agent clusters are online at the same time.
Million-level metadata QPS: The metadata service, built on PolarDB, supports high-concurrency file lookups, directory listings, and permission checks, and sustains million-level metadata QPS. This keeps metadata from becoming a performance bottleneck in large-scale agent use cases.
Elastic storage space: Fully elastic storage space built on object storage, billed by actual usage with no charges for reserved capacity. After agent compute resources are released, only the storage cost of the actual data remains.
Cache acceleration: Hot data is cached close to compute nodes, which significantly reduces read latency and supports large-scale parallel reads.
Agent-native workspace management
PolarDB Agent LakeBase covers the complete lifecycle of an agent workspace, from startup and version management to deep sleep and wake-up:
Second-level directory snapshots: Supports directory-level snapshots that are created in seconds, for use cases such as agent workspace version management, template cloning, and state rollback. Snapshots are implemented at the metadata level, so a new workspace can be initialized from an existing template in seconds by copying only metadata instead of actual data. This greatly reduces initialization latency and storage overhead.
Second-level mount recovery: Based on the metadata service and connection pooling, a new agent process completes mounting and becomes ready in seconds. After an agent wakes from deep sleep, its workspace is fully restored in sub-second time once compute is ready, which meets the experience requirements of frequent agent startup and switching.
Quota management: Supports quotas on two dimensions, capacity and I/O performance, which you can configure at the directory level to ensure the quality of service in multi-tenant use cases.
Access control: Supports file-level permission management and ACLs, as well as tenant-level access policies.
Workspace-level lifecycle management: Supports directory-level TTL configuration. Policies can automatically archive cold data to low-cost storage or clean up expired data, so data governance for agent workspaces requires no manual intervention.
Shared directories: Supports sharing specified directories across agents to accumulate shared knowledge bases, skill assets, and public templates at the team or tenant level.
Monitoring and alerting: Provides fine-grained access monitoring, capacity trends, performance metrics, and anomaly alerts.
Agent-native ecosystem support
PolarDB Agent LakeBase runs data processing components in place within the workspace and connects directly to external enterprise data processing and analytics systems:
Direct execution of embedded data components: Embedded data processing components such as SQLite, LanceDB, and DuckDB read and write in place, which handles typical agent data processing needs such as application databases, vector indexes, and columnar analytics.
Integration with external data processing and analytics ecosystems: Workspace data can be delivered directly to the PolarDB product family for enterprise data processing such as cleaning, retrieval, and analysis.
Common use cases
Agent task execution platforms
Agent platforms provide end customers with natural language-driven task automation. They help you complete end-to-end tasks such as report generation, data analysis, and website building. This use case has the following characteristics:
Large numbers of customers drive agents at the same time, and each agent task needs an independent data space for intermediate files and final artifacts such as images, videos, and documents.
Tasks involve many rounds and conversation-level granularity, which places high demands on data version management.
Many agents stay idle, so cost is a major concern.
PolarDB Agent LakeBase supports this type of high-concurrency, long-tail agent task execution platform with millions of agents online at the same time, second-level directory snapshots, elastic capacity, and pay-as-you-go billing.
Agent website building and application deployment
Agents help customers generate complete, production-ready websites or applications, and the platform keeps hosting and running them. This use case has the following characteristics:
Websites generated by agents must stay online and connect to backend databases and static resources.
They also face large volumes of long-tail traffic and bursty access, and require flexible resource elasticity. Agents must wake up quickly after deep sleep, which makes them sensitive to mount recovery latency.
PolarDB Agent LakeBase allows website backend processes to read and write workspace data directly through multiple access protocols. Multi-level caching guarantees low-latency responses to user requests. Sub-second mount recovery allows agents to wake up quickly from deep sleep.
Rapid agent workspace initialization
A new agent must prepare its working environment quickly when it comes online. Preparation includes cloning project templates, loading skill files, initializing knowledge bases, and pre-installing dependency packages. This use case has the following characteristics:
New agents are created and destroyed frequently, so workspace initialization latency directly affects the user experience.
Template data can be large, which makes repeated copying costly.
Multiple agents need to reuse pre-warmed compute resources to shorten startup time.
PolarDB Agent LakeBase uses directory snapshots to initialize a new agent workspace from a template in seconds, copying only metadata instead of actual data.
Analysis and training on agent data assets
The large volumes of data that agents generate while working, such as task trajectories, artifacts, interaction records, and multi-modal assets, have analysis and training value of their own. They can be used for downstream purposes such as business insights, model fine-tuning, and skill optimization. This use case has the following characteristics:
Analysis and training tasks usually run on GPU clusters and require high throughput for parallel data reads.
Analysis tasks and online agent workloads share the same raw data.
Data volume keeps accumulating as the agent business grows, and the traditional export-migrate-reload approach is costly and involves a long pipeline.
PolarDB Agent LakeBase can be mounted directly to GPU clusters, so analysis and training tasks read raw agent data without any data movement. The cache acceleration design of the foundation supports large-scale parallel reads. Elastic pay-as-you-go capacity keeps long-accumulated historical data in low-cost storage, which you can access on demand.
Benefits
Natively designed for agent use cases
PolarDB Agent LakeBase is designed around the real requirements of agent use cases: large numbers of active agents connecting at the same time, bursty workloads, conversation-level version management, and tight integration with agent runtimes. Its core capabilities address real pain points in agent use cases instead of simply extending traditional file system capabilities.
Costs scale with business activity, not with agent count
The architecture decouples per-agent independent views from the shared foundation, so growth in agent count no longer translates linearly into infrastructure costs. For an agent business of the same scale, deployment costs can drop significantly compared with a one-instance-per-agent approach. Costs stay low during idle periods, and no manual scale-out is needed at peak times.
One copy of data, multiple ways to use it
Agent processes read and write directly through the POSIX file interface, while applications and external systems access the data through standard interfaces. Data that agents generate can be processed by the agents themselves, served directly to external users, or used for data analysis and training, with no redundant storage or cumbersome data movement.
Deep integration with the PolarDB Agent ecosystem
PolarDB Agent LakeBase works natively with PolarDB databases and other PolarDB Agent products to form a complete agent data infrastructure.