PolarDB Agent LakeBase is a workspace infrastructure designed for large-scale AI agent operations. It provides persistent workspaces for massive numbers of agents. Each agent has a fully isolated file system view that uniformly holds all its data assets during runtime. Built on a cloud-native shared foundation, it supports millions of agents starting and stopping instantly and delivers agent-native workspace management capabilities such as second-level snapshots, second-level mount recovery, and lifecycle management. The service integrates with multiple compute environments—including Elastic Compute Service (ECS), Container Service for Kubernetes (ACK), and Function Compute (FC)—and connects seamlessly with external data analytics ecosystems.
If you have any questions about PolarDB Agent LakeBase, join the DingTalk group by searching the group number below. You can directly @ experts in the group and include your question.
DingTalk group number: 34560007316
Product positioning
In the AI agent runtime architecture, infrastructure can be divided into the following parts:
The LLM acts as the CPU, handling inference and decision-making.
Tools such as MCP serve as peripherals, connecting to external services.
The context window functions as memory, holding temporary workspace data for the current session.
The workspace serves as the agent’s persistent workspace—like a hard drive—storing all persistent states and data.
As AI agents scale, they impose new demands on workspaces. Traditional storage infrastructure struggles to meet requirements for massive concurrency, elastic support, security isolation, lightweight deployment, and other agent-native capabilities.
PolarDB Agent LakeBase is built for large-scale AI agent operations, providing persistent workspaces for massive agent fleets. Each agent has a fully isolated workspace view that uniformly holds all data used and generated during its operation. This ensures stable access for millions of active agents while keeping agent data assets secure and controllable. Core capabilities include the following:
Agent-native independent view support: Each agent sees a complete, independent workspace file view that holds all files used or produced during runtime. This aligns with the emerging LLM paradigm of using files as the native interaction interface. Independent workspace views satisfy agent isolation requirements.
Agent-native connectivity: Compatible with both POSIX and S3 protocols, it supports integration with multiple cloud compute environments—including Elastic Compute Service (ECS), Container Service for Kubernetes (ACK), Container Compute Service (ACS) Sandbox, and Function Compute (FC) Sandbox—along with on-premises systems, enabling unified cloud-and-on-premises operations.
Agent-native elastic scaling: Supports millions of agents starting and stopping instantly. Its fully elastic storage space, built on object storage, easily handles sudden spikes in agent count and data volume.
Agent-native workspace management: Offers second-level snapshots, second-level mount recovery, workspace-granularity lifecycle management, quota management, traffic shaping, and file-level access control—covering the full lifecycle from workspace creation and version control to hibernation and wake-up.
Agent-native ecosystem support: Enables direct execution of embedded data processing components such as SQLite, LanceDB, and DuckDB to meet diverse agent data needs. It also integrates with enterprise-grade external data processing and analytics systems, allowing data to flow directly into PolarDB ecosystem components for traffic scrubbing, retrieval, analysis, and more.
Service architecture
The overall architecture of PolarDB Agent LakeBase is shown above and consists of three main layers:
Massive active agents: Workspace storage is fully decoupled from agent compute. It supports integration with Elastic Compute Service (ECS), Container Service for Kubernetes (ACK), Container Compute Service (ACS) Sandbox, and Function Compute (FC) Sandbox, enabling millions of agents to run online simultaneously.
Agent workspace independent views: Each agent sees a complete, independent workspace view. Agents can read and write files and organize folders just like in a local file system. The workspace stores all data used or generated during agent operation, typically including the following:
Code and artifacts: Source code, scripts, application files, website demos, and more.
Documents and multimodal data: Text, Markdown, PDFs, presentations, design documents, images, videos, audio, and more.
Knowledge bases and skills: Reference document sets, RAG corpora, shared documents, agent capability definitions, prompt templates, and more.
Runtime state and logs: State snapshots, session history, temporary files, execution logs, and more.
Data components: Embedded databases (such as SQLite, DuckDB, LanceDB), columnar datasets (such as Lance, Parquet), and package dependency directories (such as node_modules, Python site-packages) that agents read and write directly within the workspace.
Agent workspace shared foundation: All agent workspace data is uniformly managed by a single cloud-native shared foundation composed of three layers:
Metadatabase: Delivers high-performance metadata services based on PolarDB, optimized for massive small files. PolarDB’s transaction support, connection pooling, high concurrency, and rich indexing mechanisms underpin advanced capabilities like massive connections, snapshots, quotas, and lifecycle management.
Data storage: Built on elastic, low-cost Object Storage Service, billed based on actual usage.
Cache acceleration: Optimized for agent access patterns, hot data is cached near compute nodes to significantly reduce read latency.
Core capabilities
Agent-native independent view support
Provides each agent with an independent namespace to ensure access isolation:
Independent root directory per agent: Each agent sees a complete file system view and can read, write, and organize files just like in a local file system, enabling seamless migration of agent code between local and cloud environments.
Namespace isolation between agents: Files, directories, and databases of different agents are mutually invisible, preventing cross-agent data breaches and meeting data security requirements in multi-tenant, multi-agent scenarios.
Agent-native connectivity
Offers a unified connection method for diverse agent runtime environments:
POSIX protocol compatibility: PolarDB Agent LakeBase provides a standard file system interface via Filesystem in Userspace (FUSE), aligning with the LLM trend of file-based primitives for reads and writes. It meets semantic requirements of embedded databases, columnar datasets, and package management tools for file locking, atomic renames, symbolic links, and more.
S3 protocol compatibility: The same data can be accessed directly by agent processes through the POSIX file interface or by external applications through the S3 object interface. Artifacts like websites and reports generated by agents can be served externally without data migration.
Support for multiple compute environments: Natively supports integration with Elastic Compute Service (ECS), Container Service for Kubernetes (ACK), Container Compute Service (ACS) Sandbox, and Function Compute (FC) Sandbox. It also supports on-premises self-managed systems.
Agent-native elastic scaling
Handles load characteristics of millions of agents starting and stopping instantly, sudden agent count changes, and data bursts:
Millions of agents starting and stopping instantly: Supports massive concurrent agent access, covering scenarios where large-scale agent clusters operate online simultaneously.
Million-level metadata QPS: The metadata service, powered by PolarDB, supports high-concurrency file lookups, directory listings, and permission verification. It sustains million-level metadata queries per second, preventing metadata from becoming a performance bottleneck in large-scale agent scenarios.
Elastic storage space: Fully elastic storage built on Object Storage Service is billed by actual usage—no capacity reservation fees. After agent compute resources are released, only the actual data incurs storage costs.
Cache acceleration: Hot data is cached near compute nodes to significantly reduce read latency and support massive parallel reads.
Agent-native workspace management
Covers the full lifecycle of agent workspaces—from startup and version control to deep hibernation and wake-up:
Second-level directory snapshots: Supports directory-granularity snapshots created in seconds, ideal for workspace versioning, template cloning, and state rollback. Implemented at the metadata level, new workspaces can initialize from existing templates in seconds—copying only metadata, not actual data—to drastically reduce initialization latency and storage overhead.
Second-level mount recovery: Using metadata services and connection pooling, new agent processes mount and become ready in seconds. After deep hibernation, an agent’s workspace fully recovers in sub-second time once compute is ready, meeting user experience demands for frequent starts and switches.
Quota management: Supports dual-dimension quotas for capacity and I/O performance, configurable flexibly at the directory level to ensure quality of service in multi-tenant scenarios.
Access control: Provides file-level permission management and ACLs, along with tenant-level access policies.
Workspace-granularity lifecycle management: Supports directory-level TTL configuration. Cold data can be automatically archived to low-cost storage or expired data purged based on policy, enabling hands-free data governance for agent workspaces.
Shared directories: Enables cross-agent sharing of specified directories to consolidate team- or tenant-level shared knowledge bases, skill assets, and public templates.
Monitoring and alerts: Delivers fine-grained access monitoring, capacity trends, performance metrics, and anomaly alerts.
Agent-native ecosystem support
Enables in-place execution of various data processing components within the workspace and seamless integration with external enterprise data processing and analytics systems:
Direct execution of embedded data components: Supports in-place reads and writes by embedded data processing components like SQLite, LanceDB, and DuckDB to handle typical agent data needs—including application databases, vector indexes, and columnar analytics.
Integrate with external data processing and analysis ecosystems: Workspace data can be directly delivered to the PolarDB suite of products to perform enterprise-grade data processing tasks such as data cleaning, retrieval, and analysis.
Scenarios
Agent task execution platform
Agent platforms offer end users “natural language–driven task automation” services—such as end-to-end report generation, data analytics, or website building. Key characteristics of this scenario include the following:
Massive customers concurrently driving agents, with each agent task requiring an isolated data space for intermediate files and final artifacts (multimodal content like images, videos, and documents).
Frequent task rounds and conversation-level granularity, demanding robust data versioning.
Many idle agents, making the platform cost-sensitive.
PolarDB Agent LakeBase supports this high-concurrency, long-tail agent task execution platform through million-agent concurrency, second-level directory snapshots, elastic capacity, and pay-as-you-go billing.
Agent-powered website and application deployment
Agents help customers generate fully functional, production-ready websites or applications that the platform continues to host. Key characteristics include the following:
Websites generated by agents must remain online, connecting to backend databases and static resources.
They face both long-tail traffic and bursty access patterns. Agents often enter deep sleep and must wake quickly, making mount recovery latency critical.
PolarDB Agent LakeBase enables website backend processes to read and write workspace data directly via POSIX and S3 protocols. Multi-level caching ensures low-latency user responses. Sub-second mount recovery allows agents to wake rapidly from deep hibernation.
Rapid agent workspace initialization
New agents require fast setup of their operating environment—including cloning project templates, loading skill files, initializing knowledge bases, and pre-installing dependency packages. Key characteristics include the following:
Frequent creation and destruction of new agents, where workspace initialization latency directly impacts user experience.
Large template data sizes make repeated copying costly.
Multiple agents need to reuse pre-warmed compute resources to shorten startup time.
PolarDB Agent LakeBase uses directory snapshots to enable new agent workspaces to initialize from templates in seconds—copying only metadata, not actual data.
Analysis and training on agent data assets
Data generated by agents during operation—such as task trajectories, artifacts, interaction logs, and multimodal assets—holds value for downstream uses like business insight, model fine-tuning, and skill optimization. Key characteristics include the following:
Analysis and training jobs typically run on GPU clusters and require high-throughput parallel data reads.
Analysis tasks share the same raw data as online agent operations.
Data volume continuously grows with agent business scale, making traditional “export–migrate–reload” workflows costly and complex.
PolarDB Agent LakeBase can be directly mounted to GPU clusters, letting analysis and training jobs read raw agent data without any data movement. The foundation’s cache acceleration supports massive parallel reads. Elastic, pay-as-you-go capacity keeps long-term historical data in low-cost storage, accessible on demand.
Benefits
Built natively for agent scenarios
PolarDB Agent LakeBase is designed from real agent-scenario requirements: massive concurrent active agents, bursty workloads, conversation-granularity versioning, and tight integration with agent runtimes. Its core capabilities address genuine agent-scenario pain points—not just extensions of traditional file system features.
Cost scales with business activity, not agent count
Its architecture decouples per-agent independent views from a shared foundation. Infrastructure costs no longer grow linearly with agent count. For the same scale of agent business, deployment costs are significantly lower than “one independent instance per agent” approaches. Costs stay low during idle periods, and no manual scaling is needed during peaks.
One dataset, multiple usage modes
The POSIX protocol serves agent process reads and writes, while the S3 protocol serves applications and external systems. Data generated by agents can be processed by the agents themselves, served externally, or used for analytics and training—all without redundant storage or complex data movement.
Deep integration with the PolarDB Agent ecosystem
PolarDB Agent LakeBase natively collaborates with PolarDB databases and other PolarDB Agent products to form a complete agent data infrastructure.