diff --git a/.github/workflows/real-e2e.yml b/.github/workflows/real-e2e.yml
index e88c7f66..c073ea59 100644
--- a/.github/workflows/real-e2e.yml
+++ b/.github/workflows/real-e2e.yml
@@ -90,7 +90,6 @@ jobs:
     runs-on: self-hosted
     env:
       UV_BIN: /home/admin/.local/bin
-      JAVA_VERSION: "17.0.14+7"
     steps:
       - name: Checkout code
         uses: actions/checkout@v6
@@ -102,24 +101,17 @@ jobs:
           uv --version
           uv run python --version
 
-      - name: Set up JDK
-        run: |
-          # Adoptium Temurin JDK 17 for Linux x64
-          JAVA_MAJOR="${JAVA_VERSION%%.*}"
-          JAVA_URL_VERSION=$(echo "${JAVA_VERSION}" | sed 's/+/%2B/')
-          JAVA_DIR="/home/admin/.local/jdk-${JAVA_VERSION}"
-          if [ -x "${JAVA_DIR}/bin/java" ]; then
-            echo "JDK ${JAVA_VERSION} already cached"
-          else
-            echo "Downloading Temurin JDK ${JAVA_VERSION}..."
-            mkdir -p /home/admin/.local
-            curl -fsSL "https://api.adoptium.net/v3/binary/version/jdk-${JAVA_URL_VERSION}/linux/x64/jdk/hotspot/normal/eclipse?project=jdk" \
-              | tar -xzf - -C /home/admin/.local/
-          fi
-          echo "${JAVA_DIR}/bin" >> "$GITHUB_PATH"
-          echo "JAVA_HOME=${JAVA_DIR}" >> "$GITHUB_ENV"
-          export PATH="${JAVA_DIR}/bin:${PATH}"
-          java -version
+      - name: Set up JDK 8
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: "8"
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: "17"
 
       - name: Clean up previous E2E resources
         run: |
@@ -131,6 +123,7 @@ jobs:
           GRADLE_USER_HOME: ${{ github.workspace }}/.gradle-user-home
         run: |
           set -e
+          export GRADLE_OPTS="-Dorg.gradle.java.installations.auto-detect=true -Dorg.gradle.java.installations.auto-download=false -Dorg.gradle.java.installations.paths=${JAVA_HOME_8_X64},${JAVA_HOME_17_X64}"
 
           # Create config file
           cat <<EOF > ~/.sandbox.toml
diff --git a/examples/README.md b/examples/README.md
index 44780b5e..ea17791f 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -7,6 +7,7 @@ Examples for common OpenSandbox use cases. Each subdirectory contains runnable c
 - <img src="https://kubernetes.io/icons/favicon-32.png" alt="Kubernetes" width="16" height="16" style="display:inline-block;width:16px;height:16px;vertical-align:middle;margin-right:4px;" /> [**agent-sandbox**](agent-sandbox): Create a kubernetes-sigs/agent-sandbox instance and run a command
 - 🧪 [**code-interpreter**](code-interpreter): Code Interpreter SDK singleton example
 - 💾 [**host-volume-mount**](host-volume-mount): Mount host directories into sandboxes (read-write, read-only, subpath)
+- ☁️ [**docker-ossfs-volume-mount**](docker-ossfs-volume-mount): Mount OSSFS volumes in Docker runtime (inline credentials, subpath, sharing)
 - 🎯 [**rl-training**](rl-training): Reinforcement learning training loop inside a sandbox
 - <img src="https://img.shields.io/badge/-%20-D97757?logo=claude&logoColor=white&style=flat-square" alt="Claude" width="16" height="16" style="display:inline-block;width:16px;height:16px;vertical-align:middle;margin-right:4px;" /> [**claude-code**](claude-code): Call Claude (Anthropic) API/CLI within the sandbox
 - <img src="https://cli.iflow.cn/img/favicon.ico" alt="iFlow" width="16" height="16" style="display:inline-block;width:16px;height:16px;vertical-align:middle;margin-right:4px;" /> [**iflow-cli**](iflow-cli): CLI invocation template for iFlow/custom HTTP LLM services
diff --git a/examples/docker-ossfs-volume-mount/README.md b/examples/docker-ossfs-volume-mount/README.md
new file mode 100644
index 00000000..62628ed2
--- /dev/null
+++ b/examples/docker-ossfs-volume-mount/README.md
@@ -0,0 +1,112 @@
+# Docker OSSFS Volume Mount Example
+
+This example demonstrates how to use the new SDK `ossfs` volume model to mount Alibaba Cloud OSS into sandboxes on Docker runtime.
+
+## What this example covers
+
+1. **Basic read-write mount** on an OSSFS backend.
+2. **Cross-sandbox sharing** on the same OSSFS backend path.
+3. **Two mounts, different OSS prefixes via `subPath`**.
+
+## Prerequisites
+
+### 1) Start OpenSandbox server (Docker runtime)
+
+Make sure your server host has:
+
+- Linux host OS (OSSFS backend is not supported when OpenSandbox Server runs on Windows)
+- `ossfs` installed
+- FUSE support enabled
+- writable local mount root for OSSFS (default `storage.ossfs_mount_root=/mnt/ossfs`)
+
+`storage.ossfs_mount_root` is **optional** if you use the default `/mnt/ossfs`.
+Even with on-demand mounting, the runtime still needs a deterministic host-side
+base directory to place dynamic mounts (`<mount_root>/<bucket>/<subPath?>`).
+
+Optional config example:
+
+```toml
+[runtime]
+type = "docker"
+
+[storage]
+ossfs_mount_root = "/mnt/ossfs"
+```
+
+Then start the server:
+
+```bash
+opensandbox-server
+```
+
+### 2) Install Python SDK
+
+```bash
+uv pip install opensandbox
+```
+
+If your PyPI version does not include OSSFS volume models yet, install from source:
+
+```bash
+pip install -e sdks/sandbox/python
+```
+
+### 3) Prepare OSS credentials and target path
+
+```bash
+export SANDBOX_DOMAIN=localhost:8080
+export SANDBOX_API_KEY=your-api-key
+export SANDBOX_IMAGE=ubuntu
+
+export OSS_BUCKET=your-bucket
+export OSS_ENDPOINT=oss-cn-hangzhou.aliyuncs.com
+export OSS_ACCESS_KEY_ID=your-ak
+export OSS_ACCESS_KEY_SECRET=your-sk
+```
+
+## Run
+
+```bash
+uv run python examples/docker-ossfs-volume-mount/main.py
+```
+
+## Minimal SDK usage snippet
+
+```python
+from opensandbox import Sandbox
+from opensandbox.models.sandboxes import OSSFS, Volume
+
+sandbox = await Sandbox.create(
+    image="ubuntu",
+    volumes=[
+        Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="your-bucket",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                # version="2.0",   # optional, default is "2.0"
+                accessKeyId="your-ak",
+                accessKeySecret="your-sk",
+            ),
+            mountPath="/mnt/data",
+            subPath="train",      # optional
+            readOnly=False,       # optional
+        )
+    ],
+)
+```
+
+## Notes
+
+- Current implementation supports **inline credentials only** (`accessKeyId`/`accessKeySecret`).
+- Mounting is **on-demand** in Docker runtime (mount-or-reuse), not pre-mounted for all buckets.
+- `ossfs.version` exists in API/SDK with enum `"1.0" | "2.0"`, and defaults to `"2.0"` when omitted.
+- Docker runtime now applies **version-specific mount argument encoding**:
+  - `1.0`: mounts via `ossfs ... -o <option>`.
+  - `2.0`: mounts via `ossfs2 mount ... -c <config-file>` where options are written as `--<option>` config lines.
+- `options` values must be **raw payloads** without leading `-` (for example: `allow_other`, `umask=0022`).
+
+## References
+
+- [OSEP-0003: Volume and VolumeBinding Support](../../oseps/0003-volume-and-volumebinding-support.md)
+- [Sandbox Lifecycle API Spec](../../specs/sandbox-lifecycle.yml)
diff --git a/examples/docker-ossfs-volume-mount/README_zh.md b/examples/docker-ossfs-volume-mount/README_zh.md
new file mode 100644
index 00000000..0cfff0f5
--- /dev/null
+++ b/examples/docker-ossfs-volume-mount/README_zh.md
@@ -0,0 +1,112 @@
+# Docker OSSFS 挂载示例
+
+本示例演示如何使用新版 SDK 的 `ossfs` volume 模型，在 Docker 运行时将阿里云 OSS 挂载到沙箱容器。
+
+## 覆盖场景
+
+1. **基础读写挂载**（OSSFS backend）。
+2. **跨沙箱共享数据**（同一 OSSFS backend path）。
+3. **通过 `subPath` 挂载不同 OSS prefix**。
+
+## 前置条件
+
+### 1) 启动 OpenSandbox 服务（Docker runtime）
+
+请确保服务端主机满足：
+
+- Linux 主机系统（OpenSandbox Server 运行在 Windows 时不支持 OSSFS backend）
+- 已安装 `ossfs`
+- 已启用 FUSE
+- 已有可写的 OSSFS 本地挂载根目录（默认 `storage.ossfs_mount_root=/mnt/ossfs`）
+
+`storage.ossfs_mount_root` 是**可选配置**（使用默认值时可不写）。
+即使是按需动态挂载，运行时仍需要一个确定的宿主机根目录来放置挂载点：
+`<mount_root>/<bucket>/<subPath?>`。
+
+可选配置示例：
+
+```toml
+[runtime]
+type = "docker"
+
+[storage]
+ossfs_mount_root = "/mnt/ossfs"
+```
+
+启动服务：
+
+```bash
+opensandbox-server
+```
+
+### 2) 安装 Python SDK
+
+```bash
+uv pip install opensandbox
+```
+
+如果当前 PyPI 版本还不包含 OSSFS 相关模型，可从源码安装：
+
+```bash
+pip install -e sdks/sandbox/python
+```
+
+### 3) 配置 OSS 参数
+
+```bash
+export SANDBOX_DOMAIN=localhost:8080
+export SANDBOX_API_KEY=your-api-key
+export SANDBOX_IMAGE=ubuntu
+
+export OSS_BUCKET=your-bucket
+export OSS_ENDPOINT=oss-cn-hangzhou.aliyuncs.com
+export OSS_ACCESS_KEY_ID=your-ak
+export OSS_ACCESS_KEY_SECRET=your-sk
+```
+
+## 运行
+
+```bash
+uv run python examples/docker-ossfs-volume-mount/main.py
+```
+
+## SDK 最小示例
+
+```python
+from opensandbox import Sandbox
+from opensandbox.models.sandboxes import OSSFS, Volume
+
+sandbox = await Sandbox.create(
+    image="ubuntu",
+    volumes=[
+        Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="your-bucket",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                # version="2.0",   # 可选，默认 "2.0"
+                accessKeyId="your-ak",
+                accessKeySecret="your-sk",
+            ),
+            mountPath="/mnt/data",
+            subPath="train",      # 可选
+            readOnly=False,       # 可选
+        )
+    ],
+)
+```
+
+## 说明
+
+- 当前实现仅支持**内联凭据**（`accessKeyId` / `accessKeySecret`）。
+- Docker 运行时采用**按需挂载**（mount-or-reuse），不是预挂载所有 bucket。
+- API/SDK 中 `ossfs.version` 字段存在，枚举为 `"1.0"` / `"2.0"`，省略时默认 `"2.0"`。
+- Docker 运行时已按 `version` 区分挂载参数编码：
+  - `1.0`：通过 `ossfs ... -o <option>` 挂载。
+  - `2.0`：通过 `ossfs2 mount ... -c <config-file>` 挂载，`options` 以 `--<option>` 配置项写入配置文件。
+- `options` 必须是**不带前缀 `-` 的原始参数值**（例如：`allow_other`、`umask=0022`）。
+
+## 参考
+
+- [OSEP-0003: Volume 与 VolumeBinding 支持](../../oseps/0003-volume-and-volumebinding-support.md)
+- [Sandbox Lifecycle API 规范](../../specs/sandbox-lifecycle.yml)
diff --git a/examples/docker-ossfs-volume-mount/main.py b/examples/docker-ossfs-volume-mount/main.py
new file mode 100644
index 00000000..e446f6dd
--- /dev/null
+++ b/examples/docker-ossfs-volume-mount/main.py
@@ -0,0 +1,236 @@
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Docker OSSFS Volume Mount Example
+=================================
+
+Demonstrates how to create OSSFS volumes with the new SDK model and mount them
+into sandboxes on Docker runtime.
+
+Scenarios:
+1) Basic read-write mount on OSSFS backend.
+2) Cross-sandbox data sharing on same OSSFS backend path.
+3) Two volumes use different OSS prefixes via subPath.
+"""
+
+import asyncio
+import os
+from datetime import timedelta
+from uuid import uuid4
+
+from opensandbox import Sandbox
+from opensandbox.config import ConnectionConfig
+
+try:
+    from opensandbox.models.sandboxes import OSSFS, Volume
+except ImportError:
+    print(
+        "ERROR: Your installed opensandbox SDK does not include OSSFS/Volume models.\n"
+        "       Please install the latest SDK from source:\n"
+        "\n"
+        "           pip install -e sdks/sandbox/python\n"
+    )
+    raise SystemExit(1)
+
+
+def _required_env(name: str) -> str:
+    value = os.getenv(name, "").strip()
+    if not value:
+        raise RuntimeError(f"Missing required environment variable: {name}")
+    return value
+
+
+def build_ossfs() -> OSSFS:
+    return OSSFS(
+        bucket=_required_env("OSS_BUCKET"),
+        endpoint=_required_env("OSS_ENDPOINT"),
+        accessKeyId=_required_env("OSS_ACCESS_KEY_ID"),
+        accessKeySecret=_required_env("OSS_ACCESS_KEY_SECRET"),
+    )
+
+
+async def print_exec(sandbox: Sandbox, command: str) -> str:
+    result = await sandbox.commands.run(command)
+    stdout = "\n".join(msg.text for msg in result.logs.stdout).strip()
+    stderr = "\n".join(msg.text for msg in result.logs.stderr).strip()
+    if stdout:
+        print(stdout)
+    if stderr:
+        print(stderr)
+    if result.error:
+        raise RuntimeError(f"Command failed: {result.error.name}: {result.error.value}")
+    return stdout
+
+
+async def demo_basic_mount(config: ConnectionConfig, image: str, run_id: str) -> None:
+    print("\n" + "=" * 60)
+    print("Scenario 1: Basic OSSFS Read-Write Mount")
+    print("=" * 60)
+    sandbox = await Sandbox.create(
+        image=image,
+        connection_config=config,
+        timeout=timedelta(minutes=3),
+        volumes=[
+            Volume(
+                name="oss-root",
+                ossfs=build_ossfs(),
+                mountPath="/mnt/oss",
+                readOnly=False,
+            )
+        ],
+    )
+    async with sandbox:
+        try:
+            await print_exec(sandbox, "mkdir -p /mnt/oss/opensandbox-demo")
+            await print_exec(
+                sandbox,
+                f"echo 'hello-{run_id}' > /mnt/oss/opensandbox-demo/basic.txt",
+            )
+            print("[verify] read file from mounted OSSFS path:")
+            await print_exec(sandbox, "cat /mnt/oss/opensandbox-demo/basic.txt")
+        finally:
+            await sandbox.kill()
+
+
+async def demo_cross_sandbox_sharing(config: ConnectionConfig, image: str, run_id: str) -> None:
+    print("\n" + "=" * 60)
+    print("Scenario 2: Cross-Sandbox Sharing")
+    print("=" * 60)
+    writer = await Sandbox.create(
+        image=image,
+        connection_config=config,
+        timeout=timedelta(minutes=3),
+        volumes=[
+            Volume(
+                name="oss-root-writer",
+                ossfs=build_ossfs(),
+                mountPath="/mnt/oss",
+            )
+        ],
+    )
+    async with writer:
+        try:
+            await print_exec(
+                writer,
+                f"echo 'from-writer-{run_id}' > /mnt/oss/opensandbox-demo/shared.txt",
+            )
+        finally:
+            await writer.kill()
+
+    reader = await Sandbox.create(
+        image=image,
+        connection_config=config,
+        timeout=timedelta(minutes=3),
+        volumes=[
+            Volume(
+                name="oss-root-reader",
+                ossfs=build_ossfs(),
+                mountPath="/mnt/oss",
+                readOnly=True,
+            )
+        ],
+    )
+    async with reader:
+        try:
+            print("[verify] sandbox B reads file created by sandbox A:")
+            await print_exec(reader, "cat /mnt/oss/opensandbox-demo/shared.txt")
+        finally:
+            await reader.kill()
+
+
+async def demo_subpath_mounts(config: ConnectionConfig, image: str, run_id: str) -> None:
+    print("\n" + "=" * 60)
+    print("Scenario 3: Different OSS Prefixes via subPath")
+    print("=" * 60)
+    setup = await Sandbox.create(
+        image=image,
+        connection_config=config,
+        timeout=timedelta(minutes=3),
+        volumes=[
+            Volume(
+                name="oss-root-setup",
+                ossfs=build_ossfs(),
+                mountPath="/mnt/oss",
+            )
+        ],
+    )
+    async with setup:
+        try:
+            await print_exec(
+                setup,
+                "mkdir -p /mnt/oss/opensandbox-demo/subpath-a /mnt/oss/opensandbox-demo/subpath-b",
+            )
+        finally:
+            await setup.kill()
+
+    sandbox = await Sandbox.create(
+        image=image,
+        connection_config=config,
+        timeout=timedelta(minutes=3),
+        volumes=[
+            Volume(
+                name="oss-a",
+                ossfs=build_ossfs(),
+                mountPath="/mnt/a",
+                subPath="opensandbox-demo/subpath-a",
+            ),
+            Volume(
+                name="oss-b",
+                ossfs=build_ossfs(),
+                mountPath="/mnt/b",
+                subPath="opensandbox-demo/subpath-b",
+            ),
+        ],
+    )
+    async with sandbox:
+        try:
+            await print_exec(sandbox, f"echo 'A-{run_id}' > /mnt/a/file.txt")
+            await print_exec(sandbox, f"echo 'B-{run_id}' > /mnt/b/file.txt")
+            print("[verify] subPath A content:")
+            await print_exec(sandbox, "cat /mnt/a/file.txt")
+            print("[verify] subPath B content:")
+            await print_exec(sandbox, "cat /mnt/b/file.txt")
+        finally:
+            await sandbox.kill()
+
+
+async def main() -> None:
+    domain = os.getenv("SANDBOX_DOMAIN", "localhost:8080")
+    api_key = os.getenv("SANDBOX_API_KEY")
+    image = os.getenv("SANDBOX_IMAGE", "ubuntu")
+    run_id = uuid4().hex[:8]
+
+    config = ConnectionConfig(
+        domain=domain,
+        api_key=api_key,
+        request_timeout=timedelta(minutes=5),
+    )
+
+    print(f"OpenSandbox server : {domain}")
+    print(f"Sandbox image      : {image}")
+    print(f"OSS bucket         : {_required_env('OSS_BUCKET')}")
+    print(f"OSS endpoint       : {_required_env('OSS_ENDPOINT')}")
+
+    await demo_basic_mount(config, image, run_id)
+    await demo_cross_sandbox_sharing(config, image, run_id)
+    await demo_subpath_mounts(config, image, run_id)
+
+    print("\n" + "=" * 60)
+    print("All OSSFS scenarios completed successfully.")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/oseps/0003-volume-and-volumebinding-support.md b/oseps/0003-volume-and-volumebinding-support.md
index af81f97a..be200719 100644
--- a/oseps/0003-volume-and-volumebinding-support.md
+++ b/oseps/0003-volume-and-volumebinding-support.md
@@ -154,14 +154,11 @@ Each backend type is defined as a distinct struct with explicit typed fields:
 |-------|------|----------|-------------|
 | `bucket` | string | Yes | OSS bucket name |
 | `endpoint` | string | Yes | OSS endpoint URL (e.g., `oss-cn-hangzhou.aliyuncs.com`) |
-| `path` | string | No | Path prefix within the bucket (default: `/`) |
-| `accessKeyId` | string | Yes* | Access key ID for authentication |
-| `accessKeySecret` | string | Yes* | Access key secret for authentication |
-| `version` | string | No | ossfs version: `1.0` or `2.0` (default: `1.0`) |
+| `accessKeyId` | string | Yes | Access key ID for inline authentication |
+| `accessKeySecret` | string | Yes | Access key secret for inline authentication |
+| `version` | string | No | ossfs version: `1.0` or `2.0` (default: `2.0`) |
 | `options` | []string | No | Mount options list (e.g., `["allow_other", "umask=0022"]`) |
 
-*Future enhancement: support `credentialRef` for secret references instead of inline credentials.
-
 **`pvc`** - Platform-managed named volume:
 | Field | Type | Required | Description |
 |-------|------|----------|-------------|
@@ -182,7 +179,7 @@ Additional backends (e.g., `s3`) can be added by defining new structs following
 Validation rules for each backend struct to reduce runtime-only failures:
 
 - **`host`**: `path` must be an absolute path (e.g., `/data/opensandbox/user-a`). Reject relative paths and require normalization before validation.
-- **`ossfs`**: `bucket` must be a valid bucket name. `endpoint` must be a valid OSS endpoint. `accessKeyId` and `accessKeySecret` are required unless `credentialRef` is provided (future). `version` must be `1.0` or `2.0`; if omitted, defaults to `1.0`. The runtime performs the mount during sandbox creation.
+- **`ossfs`**: `bucket` must be a valid bucket name. `endpoint` must be a valid OSS endpoint. `accessKeyId` and `accessKeySecret` are required for current MVP. `version` must be `1.0` or `2.0`; if omitted, defaults to `2.0`. In OSSFS backend, `subPath` represents bucket prefix. The runtime performs the mount during sandbox creation.
 - **`pvc`**: `claimName` must be a valid resource name (DNS label: lowercase alphanumeric and hyphens, max 63 characters). The volume identified by `claimName` must already exist on the target platform; the runtime validates existence before container creation. In Kubernetes, the PVC must exist in the same namespace as the sandbox pod. In Docker, a named volume with the given name must exist (created via `docker volume create`); if the volume does not exist, the request fails validation rather than auto-creating it, to maintain explicit volume lifecycle management.
 - **`nfs`**: `server` must be a valid hostname or IP. `path` must be an absolute path (e.g., `/exports/sandbox`).
 
@@ -204,7 +201,7 @@ SubPath provides path-level isolation, not concurrency control. If multiple sand
 - If the resolved host path does not exist, the request fails validation (do not auto-create host directories in MVP to avoid permission and security pitfalls).
 - Allowed host paths are restricted by a server-side allowlist; users must specify a `host.path` under permitted prefixes. The allowlist is an operator-configured policy and should be documented for users of a given deployment.
 - `pvc` backend maps to Docker named volumes. `pvc.claimName` is used as the Docker volume name in the bind string (e.g., `my-volume:/mnt/data:rw`). Docker recognizes non-absolute-path sources as named volume references. The named volume must already exist (created via `docker volume create`); if it does not exist, the request fails validation. When `subPath` is specified, the runtime resolves the volume's host-side `Mountpoint` via `docker volume inspect` and appends the `subPath` to produce a standard bind mount (e.g., `/var/lib/docker/volumes/my-volume/_data/subdir:/mnt/data:rw`). This requires the volume to use the `local` driver; non-local drivers are rejected when `subPath` is present because their `Mountpoint` may not be a real filesystem path. The resolved path must exist on the host; if it does not, the request fails validation.
-- `ossfs` backend requires the runtime to mount OSS via ossfs during sandbox creation using the struct fields. If the runtime does not support ossfs mounting, the request is rejected.
+- `ossfs` backend requires the runtime to mount OSS via ossfs during sandbox creation. Current MVP uses inline credentials (`accessKeyId`/`accessKeySecret`). In OSSFS backend, `subPath` is treated as bucket prefix and is resolved/validated on host before bind-mounting into the container. If the runtime does not support ossfs mounting, the request is rejected.
 
 ### Kubernetes mapping
 - `pvc` backend maps to Kubernetes `persistentVolumeClaim` volume source: `pvc.claimName` → `volumes[].persistentVolumeClaim.claimName`.
@@ -281,7 +278,7 @@ volumes:
 ```
 
 Runtime mapping (Docker):
-- host path: created by ossfs mount under a configured mount root (e.g., `/mnt/ossfs/<bucket>/<path>`), then bind-mounted into the container
+- host path: runtime resolves target path under configured mount root (e.g., `/mnt/ossfs/<bucket>/<path>`), performs on-demand mount (or reuses existing mount), then bind-mounts into the container
 - container path: `/mnt/work`
 - readOnly: false (default, read-write)
 
@@ -492,7 +489,7 @@ post_sandboxes.sync(client=client, body=request)
 - Validate that exactly one backend struct is specified per volume entry.
 - Normalize and validate `subPath` against traversal; reject `..` and absolute path inputs.
 - Enforce allowlist prefixes for `host.path` in Docker.
-- For `ossfs` backend, validate required fields (`bucket`, `endpoint`, `accessKeyId`, `accessKeySecret`) and reject missing credentials.
+- For `ossfs` backend, validate required fields (`bucket`, `endpoint`, `accessKeyId`, `accessKeySecret`).
 - For `pvc` backend, validate `claimName` is a valid DNS label (lowercase alphanumeric and hyphens, max 63 characters). In Kubernetes, validate the PVC exists in the same namespace. In Docker, validate the named volume exists via the Docker API (`docker volume inspect`).
 - For `nfs` backend, validate required fields (`server`, `path`).
 - `subPath` is created if missing under the resolved backend path; if creation fails due to permissions or policy, the request is rejected.
@@ -515,7 +512,7 @@ ossfs_mount_root = "/mnt/ossfs"
 - Provider unit tests:
   - Docker `host`: bind mount generation, read-only enforcement, allowlist rejection.
   - Docker `pvc`: named volume bind generation, volume existence validation, read-only enforcement, `claimName` format validation, rejection when volume does not exist, `subPath` resolution via `Mountpoint` for `local` driver, rejection of `subPath` for non-local drivers, rejection when resolved subPath does not exist.
-  - Docker `ossfs`: mount option validation, credential validation, version validation (`1.0`/`2.0`), mount failure handling.
+  - Docker `ossfs`: mount option validation, inline credential validation (`accessKeyId`/`accessKeySecret`), version validation (`1.0`/`2.0`), `subPath`-as-prefix resolution, mount failure handling.
   - Kubernetes `pvc`: PVC reference validation, volume mount generation.
 - Integration tests:
   - Docker: sandbox creation with `host` volume, sandbox creation with `pvc` (named volume), `pvc` with `subPath` mount, cross-container data sharing via named volume.
@@ -534,8 +531,23 @@ ossfs_mount_root = "/mnt/ossfs"
 
 ## Infrastructure Needed
 
-The runtime must have the ability to perform filesystem mounts for the requested backend types. For `ossfs` backend, the runtime must have ossfs 1.0 or 2.0 installed; the MVP assumes the runtime can mount using the struct fields provided in the request. `credentialRef` for secret references is a future enhancement.
+The runtime must have the ability to perform filesystem mounts for the requested backend types. For `ossfs` backend, the runtime must have ossfs 1.0 or 2.0 installed; the MVP assumes the runtime can mount using the struct fields provided in the request.
 
 ## Upgrade & Migration Strategy
 
-This change is additive and backward compatible. Existing clients continue to work without modification. If a client submits volume fields to a runtime that does not support them, the API will return a clear validation error.
+This change is additive for volume support and supports OSSFS inline credentials (`accessKeyId`/`accessKeySecret`). If a client submits volume fields to a runtime that does not support them, the API will return a clear validation error.
+
+## Kubernetes Feasibility (Design Only)
+
+Kubernetes runtime is not implemented in this phase, but API compatibility is preserved by design:
+
+- Keep request schema runtime-neutral: `volumes[].ossfs` has consistent shape across Docker and Kubernetes.
+- Introduce runtime adapters:
+  - Docker adapter performs host-side ossfs mount + bind using inline credentials.
+  - Kubernetes adapter can map OSSFS fields to native Secret/CSI references in a future phase.
+- Keep failure semantics aligned:
+  - Missing credential reference -> validation error with shared error code family.
+  - Runtime unsupported backend -> explicit `UNSUPPORTED_VOLUME_BACKEND`.
+- Keep `subPath` semantics aligned:
+  - API meaning remains "`subPath` is mounted under backend path".
+  - Docker resolves to host path (`subPath` as OSS prefix); Kubernetes maps to `volumeMounts.subPath`.
diff --git a/sdks/sandbox/javascript/src/api/lifecycle.ts b/sdks/sandbox/javascript/src/api/lifecycle.ts
index 571eac18..c26fd884 100644
--- a/sdks/sandbox/javascript/src/api/lifecycle.ts
+++ b/sdks/sandbox/javascript/src/api/lifecycle.ts
@@ -758,7 +758,7 @@ export interface components {
         /**
          * @description Storage mount definition for a sandbox. Each volume entry contains:
          *     - A unique name identifier
-         *     - Exactly one backend struct (host, pvc, etc.) with backend-specific fields
+         *     - Exactly one backend struct (host, pvc, ossfs, etc.) with backend-specific fields
          *     - Common mount settings (mountPath, readOnly, subPath)
          */
         Volume: {
@@ -769,6 +769,7 @@ export interface components {
             name: string;
             host?: components["schemas"]["Host"];
             pvc?: components["schemas"]["PVC"];
+            ossfs?: components["schemas"]["OSSFS"];
             /**
              * @description Absolute path inside the container where the volume is mounted.
              *     Must start with '/'.
@@ -781,6 +782,7 @@ export interface components {
             readOnly: boolean;
             /**
              * @description Optional subdirectory under the backend path to mount.
+             *     For `ossfs` backend, this field is used as the bucket prefix.
              *     Must be a relative path without '..' components.
              */
             subPath?: string;
@@ -800,18 +802,48 @@ export interface components {
             path: string;
         };
         /**
-         * @description Kubernetes PersistentVolumeClaim mount backend. References an existing
-         *     PVC in the same namespace as the sandbox pod.
+         * @description Platform-managed named volume backend. A runtime-neutral abstraction
+         *     for referencing a pre-existing, platform-managed named volume.
          *
-         *     Only available in Kubernetes runtime.
+         *     - Kubernetes: maps to a PersistentVolumeClaim in the same namespace.
+         *     - Docker: maps to a Docker named volume (created via `docker volume create`).
+         *
+         *     The volume must already exist on the target platform before sandbox
+         *     creation.
          */
         PVC: {
             /**
-             * @description Name of the PersistentVolumeClaim in the same namespace.
-             *     Must be a valid Kubernetes resource name.
+             * @description Name of the volume on the target platform.
+             *     In Kubernetes this is the PVC name; in Docker this is the named
+             *     volume name. Must be a valid DNS label.
              */
             claimName: string;
         };
+        /**
+         * @description Alibaba Cloud OSS mount backend via ossfs.
+         *
+         *     The runtime mounts a host-side OSS path under `storage.ossfs_mount_root`
+         *     and bind-mounts the resolved path into the sandbox container.
+         *     Prefix selection is expressed via `Volume.subPath`.
+         */
+        OSSFS: {
+            /** @description OSS bucket name. */
+            bucket: string;
+            /** @description OSS endpoint (e.g., `oss-cn-hangzhou.aliyuncs.com`). */
+            endpoint: string;
+            /**
+             * @description ossfs major version used by runtime mount integration.
+             * @default 2.0
+             * @enum {string}
+             */
+            version: "1.0" | "2.0";
+            /** @description Additional ossfs mount options. */
+            options?: string[];
+            /** @description OSS access key ID for inline credentials mode. */
+            accessKeyId: string;
+            /** @description OSS access key secret for inline credentials mode. */
+            accessKeySecret: string;
+        };
     };
     responses: {
         /** @description Error response envelope */
diff --git a/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/__init__.py b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/__init__.py
index 945ac192..b0db5ca6 100644
--- a/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/__init__.py
+++ b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/__init__.py
@@ -33,6 +33,8 @@
 from .network_policy_default_action import NetworkPolicyDefaultAction
 from .network_rule import NetworkRule
 from .network_rule_action import NetworkRuleAction
+from .ossfs import OSSFS
+from .ossfs_version import OSSFSVersion
 from .pagination_info import PaginationInfo
 from .pvc import PVC
 from .renew_sandbox_expiration_request import RenewSandboxExpirationRequest
@@ -61,6 +63,8 @@
     "NetworkPolicyDefaultAction",
     "NetworkRule",
     "NetworkRuleAction",
+    "OSSFS",
+    "OSSFSVersion",
     "PaginationInfo",
     "PVC",
     "RenewSandboxExpirationRequest",
diff --git a/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/ossfs.py b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/ossfs.py
new file mode 100644
index 00000000..f6ff3152
--- /dev/null
+++ b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/ossfs.py
@@ -0,0 +1,120 @@
+#
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+
+from ..models.ossfs_version import OSSFSVersion
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OSSFS")
+
+
+@_attrs_define
+class OSSFS:
+    """Alibaba Cloud OSS mount backend via ossfs.
+
+    The runtime mounts a host-side OSS path under `storage.ossfs_mount_root`
+    and bind-mounts the resolved path into the sandbox container.
+    Prefix selection is expressed via `Volume.subPath`.
+
+        Attributes:
+            bucket (str): OSS bucket name.
+            endpoint (str): OSS endpoint (e.g., `oss-cn-hangzhou.aliyuncs.com`).
+            access_key_id (str): OSS access key ID for inline credentials mode.
+            access_key_secret (str): OSS access key secret for inline credentials mode.
+            version (OSSFSVersion | Unset): ossfs major version used by runtime mount integration. Default:
+                OSSFSVersion.VALUE_1.
+            options (list[str] | Unset): Additional ossfs mount options. Runtime encoding depends on version:
+                `1.0` -> `ossfs ... -o <option>`, `2.0` -> `ossfs2 config line --<option>`.
+                Provide raw option payloads without leading `-`.
+    """
+
+    bucket: str
+    endpoint: str
+    access_key_id: str
+    access_key_secret: str
+    version: OSSFSVersion | Unset = OSSFSVersion.VALUE_1
+    options: list[str] | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        bucket = self.bucket
+
+        endpoint = self.endpoint
+
+        access_key_id = self.access_key_id
+
+        access_key_secret = self.access_key_secret
+
+        version: str | Unset = UNSET
+        if not isinstance(self.version, Unset):
+            version = self.version.value
+
+        options: list[str] | Unset = UNSET
+        if not isinstance(self.options, Unset):
+            options = self.options
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "bucket": bucket,
+                "endpoint": endpoint,
+                "accessKeyId": access_key_id,
+                "accessKeySecret": access_key_secret,
+            }
+        )
+        if version is not UNSET:
+            field_dict["version"] = version
+        if options is not UNSET:
+            field_dict["options"] = options
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        bucket = d.pop("bucket")
+
+        endpoint = d.pop("endpoint")
+
+        access_key_id = d.pop("accessKeyId")
+
+        access_key_secret = d.pop("accessKeySecret")
+
+        _version = d.pop("version", UNSET)
+        version: OSSFSVersion | Unset
+        if isinstance(_version, Unset):
+            version = UNSET
+        else:
+            version = OSSFSVersion(_version)
+
+        options = cast(list[str], d.pop("options", UNSET))
+
+        ossfs = cls(
+            bucket=bucket,
+            endpoint=endpoint,
+            access_key_id=access_key_id,
+            access_key_secret=access_key_secret,
+            version=version,
+            options=options,
+        )
+
+        return ossfs
diff --git a/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/ossfs_version.py b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/ossfs_version.py
new file mode 100644
index 00000000..0892dc77
--- /dev/null
+++ b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/ossfs_version.py
@@ -0,0 +1,25 @@
+#
+# Copyright 2026 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from enum import Enum
+
+
+class OSSFSVersion(str, Enum):
+    VALUE_0 = "1.0"
+    VALUE_1 = "2.0"
+
+    def __str__(self) -> str:
+        return str(self.value)
diff --git a/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/pvc.py b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/pvc.py
index 43e2f077..dd73cc93 100644
--- a/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/pvc.py
+++ b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/pvc.py
@@ -26,14 +26,19 @@
 
 @_attrs_define
 class PVC:
-    """Kubernetes PersistentVolumeClaim mount backend. References an existing
-    PVC in the same namespace as the sandbox pod.
+    """Platform-managed named volume backend. A runtime-neutral abstraction
+    for referencing a pre-existing, platform-managed named volume.
 
-    Only available in Kubernetes runtime.
+    - Kubernetes: maps to a PersistentVolumeClaim in the same namespace.
+    - Docker: maps to a Docker named volume (created via `docker volume create`).
+
+    The volume must already exist on the target platform before sandbox
+    creation.
 
         Attributes:
-            claim_name (str): Name of the PersistentVolumeClaim in the same namespace.
-                Must be a valid Kubernetes resource name.
+            claim_name (str): Name of the volume on the target platform.
+                In Kubernetes this is the PVC name; in Docker this is the named
+                volume name. Must be a valid DNS label.
     """
 
     claim_name: str
diff --git a/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/volume.py b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/volume.py
index 5dfc4f83..110a51cc 100644
--- a/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/volume.py
+++ b/sdks/sandbox/python/src/opensandbox/api/lifecycle/models/volume.py
@@ -25,6 +25,7 @@
 
 if TYPE_CHECKING:
     from ..models.host import Host
+    from ..models.ossfs import OSSFS
     from ..models.pvc import PVC
 
 
@@ -35,7 +36,7 @@
 class Volume:
     """Storage mount definition for a sandbox. Each volume entry contains:
     - A unique name identifier
-    - Exactly one backend struct (host, pvc, etc.) with backend-specific fields
+    - Exactly one backend struct (host, pvc, ossfs, etc.) with backend-specific fields
     - Common mount settings (mountPath, readOnly, subPath)
 
         Attributes:
@@ -48,13 +49,23 @@ class Volume:
 
                 Security note: Host paths are restricted by server-side allowlist.
                 Users must specify paths under permitted prefixes.
-            pvc (PVC | Unset): Kubernetes PersistentVolumeClaim mount backend. References an existing
-                PVC in the same namespace as the sandbox pod.
+            pvc (PVC | Unset): Platform-managed named volume backend. A runtime-neutral abstraction
+                for referencing a pre-existing, platform-managed named volume.
 
-                Only available in Kubernetes runtime.
+                - Kubernetes: maps to a PersistentVolumeClaim in the same namespace.
+                - Docker: maps to a Docker named volume (created via `docker volume create`).
+
+                The volume must already exist on the target platform before sandbox
+                creation.
+            ossfs (OSSFS | Unset): Alibaba Cloud OSS mount backend via ossfs.
+
+                The runtime mounts a host-side OSS path under `storage.ossfs_mount_root`
+                and bind-mounts the resolved path into the sandbox container.
+                Prefix selection is expressed via `Volume.subPath`.
             read_only (bool | Unset): If true, the volume is mounted as read-only. Defaults to false (read-write).
                  Default: False.
             sub_path (str | Unset): Optional subdirectory under the backend path to mount.
+                For `ossfs` backend, this field is used as the bucket prefix.
                 Must be a relative path without '..' components.
     """
 
@@ -62,6 +73,7 @@ class Volume:
     mount_path: str
     host: Host | Unset = UNSET
     pvc: PVC | Unset = UNSET
+    ossfs: OSSFS | Unset = UNSET
     read_only: bool | Unset = False
     sub_path: str | Unset = UNSET
 
@@ -78,6 +90,10 @@ def to_dict(self) -> dict[str, Any]:
         if not isinstance(self.pvc, Unset):
             pvc = self.pvc.to_dict()
 
+        ossfs: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.ossfs, Unset):
+            ossfs = self.ossfs.to_dict()
+
         read_only = self.read_only
 
         sub_path = self.sub_path
@@ -94,6 +110,8 @@ def to_dict(self) -> dict[str, Any]:
             field_dict["host"] = host
         if pvc is not UNSET:
             field_dict["pvc"] = pvc
+        if ossfs is not UNSET:
+            field_dict["ossfs"] = ossfs
         if read_only is not UNSET:
             field_dict["readOnly"] = read_only
         if sub_path is not UNSET:
@@ -104,6 +122,7 @@ def to_dict(self) -> dict[str, Any]:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.host import Host
+        from ..models.ossfs import OSSFS
         from ..models.pvc import PVC
 
         d = dict(src_dict)
@@ -125,6 +144,13 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         else:
             pvc = PVC.from_dict(_pvc)
 
+        _ossfs = d.pop("ossfs", UNSET)
+        ossfs: OSSFS | Unset
+        if isinstance(_ossfs, Unset):
+            ossfs = UNSET
+        else:
+            ossfs = OSSFS.from_dict(_ossfs)
+
         read_only = d.pop("readOnly", UNSET)
 
         sub_path = d.pop("subPath", UNSET)
@@ -134,6 +160,7 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
             mount_path=mount_path,
             host=host,
             pvc=pvc,
+            ossfs=ossfs,
             read_only=read_only,
             sub_path=sub_path,
         )
diff --git a/sdks/sandbox/python/src/opensandbox/models/sandboxes.py b/sdks/sandbox/python/src/opensandbox/models/sandboxes.py
index 8a4130e2..bf1c1ae3 100644
--- a/sdks/sandbox/python/src/opensandbox/models/sandboxes.py
+++ b/sdks/sandbox/python/src/opensandbox/models/sandboxes.py
@@ -180,13 +180,47 @@ def claim_name_must_not_be_empty(cls, v: str) -> str:
         return v
 
 
+class OSSFS(BaseModel):
+    """Alibaba Cloud OSS mount backend via ossfs."""
+
+    bucket: str = Field(description="OSS bucket name.")
+    endpoint: str = Field(description="OSS endpoint (e.g., oss-cn-hangzhou.aliyuncs.com).")
+    version: Literal["1.0", "2.0"] = Field(
+        default="2.0",
+        description="ossfs major version used by runtime mount integration.",
+    )
+    options: list[str] | None = Field(
+        default=None,
+        description="Additional ossfs mount options.",
+    )
+    access_key_id: str | None = Field(
+        default=None,
+        alias="accessKeyId",
+        description="OSS access key ID for inline credentials mode.",
+    )
+    access_key_secret: str | None = Field(
+        default=None,
+        alias="accessKeySecret",
+        description="OSS access key secret for inline credentials mode.",
+    )
+    model_config = ConfigDict(populate_by_name=True)
+
+    @model_validator(mode="after")
+    def validate_inline_credentials(self) -> "OSSFS":
+        if not self.access_key_id or not self.access_key_secret:
+            raise ValueError(
+                "OSSFS inline credentials are required: accessKeyId and accessKeySecret."
+            )
+        return self
+
+
 class Volume(BaseModel):
     """
     Storage mount definition for a sandbox.
 
     Each volume entry contains:
     - A unique name identifier
-    - Exactly one backend (host, pvc) with backend-specific fields
+    - Exactly one backend (host, pvc, ossfs) with backend-specific fields
     - Common mount settings (mount_path, read_only, sub_path)
 
     Usage:
@@ -217,6 +251,10 @@ class Volume(BaseModel):
         default=None,
         description="Kubernetes PersistentVolumeClaim mount backend.",
     )
+    ossfs: OSSFS | None = Field(
+        default=None,
+        description="OSSFS mount backend.",
+    )
     mount_path: str = Field(
         description="Absolute path inside the container where the volume is mounted.",
         alias="mountPath",
@@ -250,16 +288,16 @@ def mount_path_must_be_absolute(cls, v: str) -> str:
 
     @model_validator(mode="after")
     def validate_exactly_one_backend(self) -> "Volume":
-        """Ensure exactly one backend (host or pvc) is specified."""
-        backends = [self.host, self.pvc]
+        """Ensure exactly one backend (host, pvc, or ossfs) is specified."""
+        backends = [self.host, self.pvc, self.ossfs]
         specified = [b for b in backends if b is not None]
         if len(specified) == 0:
             raise ValueError(
-                "Exactly one backend (host, pvc) must be specified, but none was provided."
+                "Exactly one backend (host, pvc, ossfs) must be specified, but none was provided."
             )
         if len(specified) > 1:
             raise ValueError(
-                "Exactly one backend (host, pvc) must be specified, but multiple were provided."
+                "Exactly one backend (host, pvc, ossfs) must be specified, but multiple were provided."
             )
         return self
 
diff --git a/sdks/sandbox/python/tests/test_models_stability.py b/sdks/sandbox/python/tests/test_models_stability.py
index e307cbbd..aabcb8d6 100644
--- a/sdks/sandbox/python/tests/test_models_stability.py
+++ b/sdks/sandbox/python/tests/test_models_stability.py
@@ -21,6 +21,7 @@
 
 from opensandbox.models.filesystem import MoveEntry, WriteEntry
 from opensandbox.models.sandboxes import (
+    OSSFS,
     PVC,
     Host,
     SandboxFilter,
@@ -105,6 +106,16 @@ def test_pvc_backend_rejects_blank_claim_name() -> None:
         PVC(claimName="   ")
 
 
+def test_ossfs_backend_default_version_is_2_0() -> None:
+    backend = OSSFS(
+        bucket="bucket-test-3",
+        endpoint="oss-cn-hangzhou.aliyuncs.com",
+        accessKeyId="ak",
+        accessKeySecret="sk",
+    )
+    assert backend.version == "2.0"
+
+
 def test_volume_with_host_backend() -> None:
     vol = Volume(
         name="data",
diff --git a/server/pyproject.toml b/server/pyproject.toml
index 8cae0aea..ca41b330 100644
--- a/server/pyproject.toml
+++ b/server/pyproject.toml
@@ -85,13 +85,13 @@ include = [
 
 [tool.hatch.build.targets.wheel]
 packages = ["src"]
-force-include = {
-    "example.config.toml" = "example.config.toml",
-    "example.config.zh.toml" = "example.config.zh.toml",
-    "example.config.k8s.toml" = "example.config.k8s.toml",
-    "example.config.k8s.zh.toml" = "example.config.k8s.zh.toml",
-    "example.batchsandbox-template.yaml" = "example.batchsandbox-template.yaml",
-}
+
+[tool.hatch.build.targets.wheel.force-include]
+"example.config.toml" = "example.config.toml"
+"example.config.zh.toml" = "example.config.zh.toml"
+"example.config.k8s.toml" = "example.config.k8s.toml"
+"example.config.k8s.zh.toml" = "example.config.k8s.zh.toml"
+"example.batchsandbox-template.yaml" = "example.batchsandbox-template.yaml"
 
 [dependency-groups]
 dev = [
diff --git a/server/src/api/schema.py b/server/src/api/schema.py
index c6373dd0..762f5505 100644
--- a/server/src/api/schema.py
+++ b/server/src/api/schema.py
@@ -20,7 +20,7 @@
 """
 
 from datetime import datetime
-from typing import Dict, List, Optional
+from typing import Dict, List, Literal, Optional
 
 from pydantic import BaseModel, Field, RootModel, model_validator
 
@@ -156,6 +156,64 @@ class Config:
         populate_by_name = True
 
 
+class OSSFS(BaseModel):
+    """
+    Alibaba Cloud OSS mount backend via ossfs.
+
+    The runtime mounts a host-side OSS path under ``storage.ossfs_mount_root``
+    and then bind-mounts the resolved path into the sandbox container. Prefix
+    selection is expressed via ``Volume.subPath``.
+    In Docker runtime, OSSFS backend requires the server host to be Linux with FUSE support.
+    """
+
+    bucket: str = Field(
+        ...,
+        description="OSS bucket name.",
+        min_length=3,
+        max_length=63,
+    )
+    endpoint: str = Field(
+        ...,
+        description="OSS endpoint, e.g. 'oss-cn-hangzhou.aliyuncs.com'.",
+        min_length=1,
+    )
+    version: Literal["1.0", "2.0"] = Field(
+        "2.0",
+        description="ossfs major version used by runtime mount integration.",
+    )
+    options: Optional[List[str]] = Field(
+        None,
+        description=(
+            "Additional ossfs mount options. Runtime encodes options by version: "
+            "1.0 => 'ossfs ... -o <option>', 2.0 => 'ossfs2 config line --<option>'. "
+            "Provide raw option payloads without leading '-'."
+        ),
+    )
+    access_key_id: Optional[str] = Field(
+        None,
+        alias="accessKeyId",
+        description="OSS access key ID for inline credentials mode.",
+        min_length=1,
+    )
+    access_key_secret: Optional[str] = Field(
+        None,
+        alias="accessKeySecret",
+        description="OSS access key secret for inline credentials mode.",
+        min_length=1,
+    )
+    class Config:
+        populate_by_name = True
+
+    @model_validator(mode="after")
+    def validate_inline_credentials(self) -> "OSSFS":
+        """Ensure inline credentials are provided for current OSSFS mode."""
+        if not self.access_key_id or not self.access_key_secret:
+            raise ValueError(
+                "OSSFS inline credentials are required: accessKeyId and accessKeySecret."
+            )
+        return self
+
+
 class Volume(BaseModel):
     """
     Storage mount definition for a sandbox.
@@ -180,6 +238,10 @@ class Volume(BaseModel):
         None,
         description="Platform-managed named volume backend (PVC in Kubernetes, named volume in Docker).",
     )
+    ossfs: Optional[OSSFS] = Field(
+        None,
+        description="OSSFS mount backend.",
+    )
     mount_path: str = Field(
         ...,
         alias="mountPath",
@@ -203,12 +265,12 @@ class Config:
     @model_validator(mode="after")
     def validate_exactly_one_backend(self) -> "Volume":
         """Ensure exactly one backend type is specified."""
-        backends = [self.host, self.pvc]
+        backends = [self.host, self.pvc, self.ossfs]
         specified = [b for b in backends if b is not None]
         if len(specified) == 0:
-            raise ValueError("Exactly one backend (host, pvc) must be specified, but none was provided.")
+            raise ValueError("Exactly one backend (host, pvc, ossfs) must be specified, but none was provided.")
         if len(specified) > 1:
-            raise ValueError("Exactly one backend (host, pvc) must be specified, but multiple were provided.")
+            raise ValueError("Exactly one backend (host, pvc, ossfs) must be specified, but multiple were provided.")
         return self
 
 
diff --git a/server/src/config.py b/server/src/config.py
index 11ecc7bb..3ea973ad 100644
--- a/server/src/config.py
+++ b/server/src/config.py
@@ -262,6 +262,14 @@ class StorageConfig(BaseModel):
             "Each entry must be an absolute path (e.g., '/data/opensandbox')."
         ),
     )
+    ossfs_mount_root: str = Field(
+        default="/mnt/ossfs",
+        description=(
+            "Host-side root directory where OSSFS mounts are resolved. "
+            "Resolved OSSFS host paths are built as "
+            "'ossfs_mount_root/<bucket>/<volume.subPath?>'."
+        ),
+    )
 
 
 class EgressConfig(BaseModel):
diff --git a/server/src/services/constants.py b/server/src/services/constants.py
index d9645cab..2939c76f 100644
--- a/server/src/services/constants.py
+++ b/server/src/services/constants.py
@@ -19,6 +19,7 @@
 # Host-mapped ports recorded on containers (bridge mode).
 SANDBOX_EMBEDDING_PROXY_PORT_LABEL = "opensandbox.io/embedding-proxy-port"  # maps container 44772 -> host port
 SANDBOX_HTTP_PORT_LABEL = "opensandbox.io/http-port"  # maps container 8080 -> host port
+SANDBOX_OSSFS_MOUNTS_LABEL = "opensandbox.io/ossfs-mounts"
 OPEN_SANDBOX_INGRESS_HEADER = "OpenSandbox-Ingress-To"
 
 class SandboxErrorCodes:
@@ -72,6 +73,15 @@ class SandboxErrorCodes:
     PVC_VOLUME_NOT_FOUND = "VOLUME::PVC_NOT_FOUND"
     PVC_VOLUME_INSPECT_FAILED = "VOLUME::PVC_INSPECT_FAILED"
     PVC_SUBPATH_UNSUPPORTED_DRIVER = "VOLUME::PVC_SUBPATH_UNSUPPORTED_DRIVER"
+    INVALID_OSSFS_VERSION = "VOLUME::INVALID_OSSFS_VERSION"
+    INVALID_OSSFS_ENDPOINT = "VOLUME::INVALID_OSSFS_ENDPOINT"
+    INVALID_OSSFS_BUCKET = "VOLUME::INVALID_OSSFS_BUCKET"
+    INVALID_OSSFS_OPTION = "VOLUME::INVALID_OSSFS_OPTION"
+    INVALID_OSSFS_CREDENTIALS = "VOLUME::INVALID_OSSFS_CREDENTIALS"
+    INVALID_OSSFS_MOUNT_ROOT = "VOLUME::INVALID_OSSFS_MOUNT_ROOT"
+    OSSFS_PATH_NOT_FOUND = "VOLUME::OSSFS_PATH_NOT_FOUND"
+    OSSFS_MOUNT_FAILED = "VOLUME::OSSFS_MOUNT_FAILED"
+    OSSFS_UNMOUNT_FAILED = "VOLUME::OSSFS_UNMOUNT_FAILED"
 
 
 __all__ = [
@@ -79,6 +89,7 @@ class SandboxErrorCodes:
     "SANDBOX_EXPIRES_AT_LABEL",
     "SANDBOX_EMBEDDING_PROXY_PORT_LABEL",
     "SANDBOX_HTTP_PORT_LABEL",
+    "SANDBOX_OSSFS_MOUNTS_LABEL",
     "OPEN_SANDBOX_INGRESS_HEADER",
     "SandboxErrorCodes",
 ]
diff --git a/server/src/services/docker.py b/server/src/services/docker.py
index 6ff79613..fb37830d 100644
--- a/server/src/services/docker.py
+++ b/server/src/services/docker.py
@@ -63,6 +63,7 @@
     SANDBOX_EXPIRES_AT_LABEL,
     SANDBOX_HTTP_PORT_LABEL,
     SANDBOX_ID_LABEL,
+    SANDBOX_OSSFS_MOUNTS_LABEL,
     SandboxErrorCodes,
 )
 from src.services.helpers import (
@@ -71,6 +72,7 @@
     parse_nano_cpus,
     parse_timestamp,
 )
+from src.services.ossfs_mixin import OSSFSMixin
 from src.services.sandbox_service import SandboxService
 from src.services.validators import (
     ensure_egress_configured,
@@ -110,7 +112,7 @@ class PendingSandbox:
     status: SandboxStatus
 
 
-class DockerSandboxService(SandboxService):
+class DockerSandboxService(OSSFSMixin, SandboxService):
     """
     Docker-based implementation of SandboxService.
 
@@ -186,6 +188,8 @@ def __init__(self, config: Optional[AppConfig] = None):
         self._pending_sandboxes: Dict[str, PendingSandbox] = {}
         self._pending_lock = Lock()
         self._pending_cleanup_timers: Dict[str, Timer] = {}
+        self._ossfs_mount_lock = Lock()
+        self._ossfs_mount_ref_counts: Dict[str, int] = {}
         self._restore_existing_sandboxes()
 
     def _resolve_api_timeout(self) -> int:
@@ -289,6 +293,7 @@ def _get_tracked_expiration(
 
     def _expire_sandbox(self, sandbox_id: str) -> None:
         """Timer callback to terminate expired sandboxes."""
+        mount_keys: list[str] = []
         try:
             container = self._get_container_by_sandbox_id(sandbox_id)
         except HTTPException as exc:
@@ -299,6 +304,15 @@ def _expire_sandbox(self, sandbox_id: str) -> None:
             self._remove_expiration_tracking(sandbox_id)
             return
 
+        labels = container.attrs.get("Config", {}).get("Labels") or {}
+        mount_keys_raw = labels.get(SANDBOX_OSSFS_MOUNTS_LABEL, "[]")
+        try:
+            parsed_mount_keys = json.loads(mount_keys_raw)
+            if isinstance(parsed_mount_keys, list):
+                mount_keys = [key for key in parsed_mount_keys if isinstance(key, str) and key]
+        except (TypeError, json.JSONDecodeError):
+            mount_keys = []
+
         try:
             state = container.attrs.get("State", {})
             if state.get("Running", False):
@@ -314,6 +328,7 @@ def _expire_sandbox(self, sandbox_id: str) -> None:
         self._remove_expiration_tracking(sandbox_id)
         # Ensure sidecar is also cleaned up on expiration
         self._cleanup_egress_sidecar(sandbox_id)
+        self._release_ossfs_mounts(mount_keys)
 
     def _restore_existing_sandboxes(self) -> None:
         """On startup, rebuild expiration timers for containers already running."""
@@ -325,6 +340,7 @@ def _restore_existing_sandboxes(self) -> None:
 
         restored = 0
         seen_sidecars: set[str] = set()
+        restored_mount_refs: dict[str, int] = {}
         now = datetime.now(timezone.utc)
         for container in containers:
             labels = container.attrs.get("Config", {}).get("Labels") or {}
@@ -353,6 +369,15 @@ def _restore_existing_sandboxes(self) -> None:
                 continue
 
             self._schedule_expiration(sandbox_id, expires_at)
+            mount_keys_raw = labels.get(SANDBOX_OSSFS_MOUNTS_LABEL, "[]")
+            try:
+                mount_keys = json.loads(mount_keys_raw)
+            except (TypeError, json.JSONDecodeError):
+                mount_keys = []
+            if isinstance(mount_keys, list):
+                for key in mount_keys:
+                    if isinstance(key, str) and key:
+                        restored_mount_refs[key] = restored_mount_refs.get(key, 0) + 1
             restored += 1
 
         # Cleanup orphan sidecars (no matching sandbox container)
@@ -369,6 +394,8 @@ def _restore_existing_sandboxes(self) -> None:
 
         if restored:
             logger.info("Restored expiration timers for %d sandbox(es).", restored)
+        with self._ossfs_mount_lock:
+            self._ossfs_mount_ref_counts = restored_mount_refs
 
     def _fetch_execd_archive(self) -> bytes:
         """Fetch (and memoize) the execd archive from the platform container."""
@@ -707,6 +734,12 @@ def _cleanup_failed_containers(self, sandbox_id: str) -> None:
             return
 
         for container in containers:
+            labels = container.attrs.get("Config", {}).get("Labels") or {}
+            mount_keys_raw = labels.get(SANDBOX_OSSFS_MOUNTS_LABEL, "[]")
+            try:
+                mount_keys: list[str] = json.loads(mount_keys_raw)
+            except (TypeError, json.JSONDecodeError):
+                mount_keys = []
             try:
                 with self._docker_operation("cleanup failed sandbox container", sandbox_id):
                     container.remove(force=True)
@@ -717,6 +750,8 @@ def _cleanup_failed_containers(self, sandbox_id: str) -> None:
                     container.id,
                     exc,
                 )
+            finally:
+                self._release_ossfs_mounts(mount_keys)
         # Always attempt to cleanup sidecar as well
         self._cleanup_egress_sidecar(sandbox_id)
 
@@ -825,6 +860,14 @@ def _provision_sandbox(
         image_uri, auth_config = self._resolve_image_auth(request, sandbox_id)
         mem_limit, nano_cpus = self._resolve_resource_limits(request)
 
+        # Prepare OSSFS mounts first so binds can reference mounted host paths.
+        ossfs_mount_keys = self._prepare_ossfs_mounts(request.volumes)
+        if ossfs_mount_keys:
+            labels[SANDBOX_OSSFS_MOUNTS_LABEL] = json.dumps(
+                ossfs_mount_keys,
+                separators=(",", ":"),
+            )
+
         # Build volume bind mounts from request volumes.
         # pvc_inspect_cache carries Docker volume inspect data from the
         # validation phase, avoiding a redundant API call.
@@ -891,6 +934,7 @@ def _provision_sandbox(
                         sandbox_id,
                         cleanup_exc,
                     )
+            self._release_ossfs_mounts(ossfs_mount_keys)
             raise
 
         status_info = SandboxStatus(
@@ -967,6 +1011,8 @@ def _validate_volumes(self, request: CreateSandboxRequest) -> dict[str, dict]:
             elif volume.pvc is not None:
                 vol_info = self._validate_pvc_volume(volume)
                 pvc_inspect_cache[volume.pvc.claim_name] = vol_info
+            elif volume.ossfs is not None:
+                self._validate_ossfs_volume(volume)
 
         return pvc_inspect_cache
 
@@ -1185,6 +1231,8 @@ def _build_volume_binds(
           Format (with subPath): ``/var/lib/docker/volumes/…/subdir:/container/path:ro|rw``
           When subPath is specified, the volume's host Mountpoint (obtained from
           ``pvc_inspect_cache``) is used to produce a standard bind mount.
+        - ``ossfs``: host bind mount to runtime-mounted OSSFS path.
+          Format: ``/mnt/ossfs/<bucket>/<subPath?>:/container/path:ro|rw``
 
         Each mount string uses ``:ro`` for read-only and ``:rw`` for read-write
         (default).
@@ -1236,6 +1284,9 @@ def _build_volume_binds(
                     binds.append(
                         f"{volume.pvc.claim_name}:{container_path}:{mode}"
                     )
+            elif volume.ossfs is not None:
+                _, host_path = self._resolve_ossfs_paths(volume)
+                binds.append(f"{host_path}:{container_path}:{mode}")
 
         return binds
 
@@ -1341,6 +1392,12 @@ def delete_sandbox(self, sandbox_id: str) -> None:
             HTTPException: If sandbox not found or deletion fails
         """
         container = self._get_container_by_sandbox_id(sandbox_id)
+        labels = container.attrs.get("Config", {}).get("Labels") or {}
+        mount_keys_raw = labels.get(SANDBOX_OSSFS_MOUNTS_LABEL, "[]")
+        try:
+            mount_keys: list[str] = json.loads(mount_keys_raw)
+        except (TypeError, json.JSONDecodeError):
+            mount_keys = []
         try:
             try:
                 with self._docker_operation("kill sandbox container", sandbox_id):
@@ -1362,6 +1419,7 @@ def delete_sandbox(self, sandbox_id: str) -> None:
         finally:
             self._remove_expiration_tracking(sandbox_id)
             self._cleanup_egress_sidecar(sandbox_id)
+            self._release_ossfs_mounts(mount_keys)
 
     def pause_sandbox(self, sandbox_id: str) -> None:
         """
diff --git a/server/src/services/helpers.py b/server/src/services/helpers.py
index 8653db1f..15878973 100644
--- a/server/src/services/helpers.py
+++ b/server/src/services/helpers.py
@@ -132,6 +132,14 @@ def parse_timestamp(timestamp: Optional[str]) -> datetime:
         return datetime.now(timezone.utc)
 
 
+def normalize_external_endpoint_url(endpoint: str, default_scheme: str = "https") -> str:
+    """Normalize host or URL to a full URL with an explicit scheme."""
+    endpoint = endpoint.strip()
+    if endpoint.startswith("http://") or endpoint.startswith("https://"):
+        return endpoint
+    return f"{default_scheme}://{endpoint}"
+
+
 def matches_filter(sandbox: Sandbox, filter_: SandboxFilter) -> bool:
     """Apply state/metadata filters to a sandbox instance."""
     if not filter_:
@@ -192,6 +200,7 @@ def format_ingress_endpoint(
     "parse_memory_limit",
     "parse_nano_cpus",
     "parse_timestamp",
+    "normalize_external_endpoint_url",
     "format_ingress_endpoint",
     "matches_filter",
 ]
diff --git a/server/src/services/ossfs_mixin.py b/server/src/services/ossfs_mixin.py
new file mode 100644
index 00000000..6e032040
--- /dev/null
+++ b/server/src/services/ossfs_mixin.py
@@ -0,0 +1,375 @@
+# Copyright 2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""OSSFS-specific Docker runtime behaviors."""
+
+from __future__ import annotations
+
+import logging
+import os
+import posixpath
+import subprocess
+import tempfile
+from typing import Any, Optional
+from uuid import uuid4
+
+from fastapi import HTTPException, status
+
+from src.services.constants import SandboxErrorCodes
+from src.services.helpers import normalize_external_endpoint_url
+
+logger = logging.getLogger(__name__)
+
+
+class OSSFSMixin:
+    @staticmethod
+    def _normalize_ossfs_option(raw_option: str) -> str:
+        option = str(raw_option).strip()
+        if not option:
+            return ""
+        return option
+
+    def _resolve_ossfs_paths(self, volume) -> tuple[str, str]:
+        """
+        Resolve OSSFS base mount path and bind path.
+
+        For OSSFS, ``volume.subPath`` represents the bucket prefix.
+        The backend mount path and bind path are identical:
+        - path = ossfs_mount_root/<bucket>/<subPath?>
+        """
+        mount_root = (self.app_config.storage.ossfs_mount_root or "").strip()
+        if not mount_root.startswith("/"):
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail={
+                    "code": SandboxErrorCodes.INVALID_OSSFS_MOUNT_ROOT,
+                    "message": (
+                        "storage.ossfs_mount_root must be configured as an absolute path."
+                    ),
+                },
+            )
+
+        mount_root = posixpath.normpath(mount_root)
+        bucket_root = posixpath.normpath(posixpath.join(mount_root, volume.ossfs.bucket))
+        prefix = (volume.sub_path or "").lstrip("/")
+        backend_path = posixpath.normpath(posixpath.join(bucket_root, prefix))
+
+        bucket_prefix = bucket_root if bucket_root.endswith("/") else bucket_root + "/"
+        if backend_path != bucket_root and not backend_path.startswith(bucket_prefix):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail={
+                    "code": SandboxErrorCodes.INVALID_SUB_PATH,
+                    "message": (
+                        f"Volume '{volume.name}': resolved OSSFS prefix escapes bucket root."
+                    ),
+                },
+            )
+
+        return backend_path, backend_path
+
+    def _build_ossfs_v1_command(
+        self,
+        volume,
+        source: str,
+        backend_path: str,
+        endpoint_url: str,
+        passwd_file: str,
+    ) -> list[str]:
+        cmd: list[str] = [
+            "ossfs",
+            source,
+            backend_path,
+            "-o",
+            f"url={endpoint_url}",
+            "-o",
+            f"passwd_file={passwd_file}",
+        ]
+        if volume.ossfs.options:
+            for raw_opt in volume.ossfs.options:
+                opt = self._normalize_ossfs_option(raw_opt)
+                if opt:
+                    cmd.extend(["-o", opt])
+        return cmd
+
+    def _build_ossfs_v2_config_lines(
+        self,
+        volume,
+        endpoint_url: str,
+        prefix: str,
+    ) -> list[str]:
+        conf_lines: list[str] = [
+            f"--oss_endpoint={endpoint_url}",
+            f"--oss_bucket={volume.ossfs.bucket}",
+            f"--oss_access_key_id={volume.ossfs.access_key_id}",
+            f"--oss_access_key_secret={volume.ossfs.access_key_secret}",
+        ]
+        if prefix:
+            normalized_prefix = prefix if prefix.endswith("/") else f"{prefix}/"
+            conf_lines.append(f"--oss_bucket_prefix={normalized_prefix}")
+        if volume.ossfs.options:
+            for raw_opt in volume.ossfs.options:
+                opt = self._normalize_ossfs_option(raw_opt)
+                if opt:
+                    conf_lines.append(f"--{opt}")
+        return conf_lines
+
+    @staticmethod
+    def _build_ossfs_v2_mount_command(backend_path: str, conf_file: str) -> list[str]:
+        return ["ossfs2", "mount", backend_path, "-c", conf_file]
+
+    @staticmethod
+    def _run_ossfs_mount_command(cmd: list[str], volume_name: str) -> None:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=30,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail={
+                    "code": SandboxErrorCodes.OSSFS_MOUNT_FAILED,
+                    "message": (
+                        f"Volume '{volume_name}': failed to mount OSSFS backend. "
+                        f"stderr={result.stderr.strip() or 'unknown error'}"
+                    ),
+                },
+            )
+
+    def _mount_ossfs_backend_path(self, volume, backend_path: str) -> None:
+        """Mount OSS bucket/path to backend_path with version-specific OSSFS arguments."""
+        access_key_id = volume.ossfs.access_key_id
+        access_key_secret = volume.ossfs.access_key_secret
+        if not access_key_id or not access_key_secret:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail={
+                    "code": SandboxErrorCodes.INVALID_OSSFS_CREDENTIALS,
+                    "message": (
+                        "OSSFS inline credentials are required: "
+                        "accessKeyId and accessKeySecret must be provided."
+                    ),
+                },
+            )
+        os.makedirs(backend_path, exist_ok=True)
+
+        bucket = volume.ossfs.bucket
+        prefix = (volume.sub_path or "").strip("/")
+        source = f"{bucket}:/{prefix}" if prefix else bucket
+        endpoint = volume.ossfs.endpoint
+        endpoint_url = normalize_external_endpoint_url(endpoint)
+
+        passwd_file: Optional[str] = None
+        conf_file: Optional[str] = None
+        version = volume.ossfs.version or "2.0"
+        try:
+            if version == "1.0":
+                passwd_file = os.path.join(
+                    tempfile.gettempdir(),
+                    f"opensandbox-ossfs-inline-{uuid4().hex}",
+                )
+                with open(passwd_file, "w", encoding="utf-8") as f:
+                    # ossfs passwd_file format: bucket:accessKeyId:accessKeySecret
+                    f.write(f"{bucket}:{access_key_id}:{access_key_secret}")
+                os.chmod(passwd_file, 0o600)
+                cmd = self._build_ossfs_v1_command(
+                    volume=volume,
+                    source=source,
+                    backend_path=backend_path,
+                    endpoint_url=endpoint_url,
+                    passwd_file=passwd_file,
+                )
+            elif version == "2.0":
+                conf_lines = self._build_ossfs_v2_config_lines(
+                    volume=volume,
+                    endpoint_url=endpoint_url,
+                    prefix=prefix,
+                )
+                conf_file = os.path.join(
+                    tempfile.gettempdir(),
+                    f"opensandbox-ossfs2-{uuid4().hex}.conf",
+                )
+                with open(conf_file, "w", encoding="utf-8") as f:
+                    f.write("\n".join(conf_lines) + "\n")
+                os.chmod(conf_file, 0o600)
+                cmd = self._build_ossfs_v2_mount_command(backend_path, conf_file)
+            else:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail={
+                        "code": SandboxErrorCodes.INVALID_OSSFS_VERSION,
+                        "message": (
+                            f"Volume '{volume.name}': unsupported OSSFS version '{version}'."
+                        ),
+                    },
+                )
+            self._run_ossfs_mount_command(cmd, volume.name)
+        except OSError as exc:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail={
+                    "code": SandboxErrorCodes.OSSFS_MOUNT_FAILED,
+                    "message": (
+                        f"Volume '{volume.name}': failed to execute ossfs command: {exc}"
+                    ),
+                },
+            ) from exc
+        finally:
+            if passwd_file:
+                try:
+                    os.remove(passwd_file)
+                except OSError:
+                    pass
+            if conf_file:
+                try:
+                    os.remove(conf_file)
+                except OSError:
+                    pass
+
+    def _ensure_ossfs_mounted(self, volume_or_mount_key) -> str:
+        """Ensure OSSFS backend path is mounted and return mount key."""
+        if isinstance(volume_or_mount_key, str):
+            mount_key = volume_or_mount_key
+            backend_path = volume_or_mount_key
+            volume = None
+        else:
+            volume = volume_or_mount_key
+            backend_path, _ = self._resolve_ossfs_paths(volume)
+            mount_key = backend_path
+
+        with self._ossfs_mount_lock:
+            current = self._ossfs_mount_ref_counts.get(mount_key, 0)
+            if current > 0:
+                self._ossfs_mount_ref_counts[mount_key] = current + 1
+                return mount_key
+
+            if not os.path.ismount(backend_path):
+                if volume is None:
+                    raise HTTPException(
+                        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                        detail={
+                            "code": SandboxErrorCodes.OSSFS_MOUNT_FAILED,
+                            "message": (
+                                f"Failed to mount OSSFS path '{mount_key}': "
+                                "missing volume context."
+                            ),
+                        },
+                    )
+                self._mount_ossfs_backend_path(volume, backend_path)
+
+            self._ossfs_mount_ref_counts[mount_key] = 1
+            return mount_key
+
+    def _release_ossfs_mount(self, mount_key: str) -> None:
+        """Release one reference and unmount when ref count reaches zero."""
+        with self._ossfs_mount_lock:
+            current = self._ossfs_mount_ref_counts.get(mount_key, 0)
+            if current <= 0:
+                logger.warning(
+                    "Skipping OSSFS unmount for untracked mount key '%s'.",
+                    mount_key,
+                )
+                return
+            if current == 1:
+                self._ossfs_mount_ref_counts.pop(mount_key, None)
+                should_unmount = True
+            else:
+                self._ossfs_mount_ref_counts[mount_key] = current - 1
+                should_unmount = False
+
+        if not should_unmount or not os.path.ismount(mount_key):
+            return
+
+        errors: list[str] = []
+        for cmd in (["fusermount", "-u", mount_key], ["umount", mount_key]):
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=20,
+                check=False,
+            )
+            if result.returncode == 0:
+                return
+            errors.append(result.stderr.strip() or "unknown error")
+
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail={
+                "code": SandboxErrorCodes.OSSFS_UNMOUNT_FAILED,
+                "message": f"Failed to unmount OSSFS path '{mount_key}': {'; '.join(errors)}",
+            },
+        )
+
+    def _release_ossfs_mounts(self, mount_keys: list[str]) -> None:
+        for key in mount_keys:
+            try:
+                self._release_ossfs_mount(key)
+            except HTTPException as exc:
+                logger.warning("Failed to release OSSFS mount %s: %s", key, exc.detail)
+
+    def _prepare_ossfs_mounts(self, volumes: Optional[list]) -> list[str]:
+        if not volumes:
+            return []
+        key_to_volume: dict[str, Any] = {}
+        prepared_mount_keys: list[str] = []
+        for volume in volumes:
+            if volume.ossfs is not None:
+                mount_key, _ = self._resolve_ossfs_paths(volume)
+                if mount_key not in key_to_volume:
+                    key_to_volume[mount_key] = volume
+        try:
+            for mount_key, volume in key_to_volume.items():
+                self._ensure_ossfs_mounted(volume)
+                prepared_mount_keys.append(mount_key)
+            return list(key_to_volume.keys())
+        except Exception:
+            # Roll back mounts already prepared in this batch.
+            self._release_ossfs_mounts(prepared_mount_keys)
+            raise
+
+    def _validate_ossfs_volume(self, volume) -> None:
+        """
+        Docker-specific validation for OSSFS backend.
+
+        Ensures inline credentials and path semantics are valid.
+        """
+        if os.name == "nt":
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail={
+                    "code": SandboxErrorCodes.INVALID_PARAMETER,
+                    "message": (
+                        "OSSFS backend on Docker runtime requires a Linux host with FUSE support. "
+                        "Running OpenSandbox Server on Windows is not supported for OSSFS mounts."
+                    ),
+                },
+            )
+
+        if not volume.ossfs.access_key_id or not volume.ossfs.access_key_secret:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail={
+                    "code": SandboxErrorCodes.INVALID_OSSFS_CREDENTIALS,
+                    "message": (
+                        "OSSFS inline credentials are required: "
+                        "accessKeyId and accessKeySecret must be provided."
+                    ),
+                },
+            )
+
+        self._resolve_ossfs_paths(volume)
diff --git a/server/src/services/validators.py b/server/src/services/validators.py
index dd55e5e1..e9095aee 100644
--- a/server/src/services/validators.py
+++ b/server/src/services/validators.py
@@ -31,7 +31,7 @@
 from src.services.constants import SandboxErrorCodes
 
 if TYPE_CHECKING:
-    from src.api.schema import NetworkPolicy, Volume
+    from src.api.schema import NetworkPolicy, OSSFS, Volume
     from src.config import EgressConfig
 
 
@@ -386,6 +386,70 @@ def ensure_valid_pvc_name(claim_name: str) -> None:
         )
 
 
+def ensure_valid_ossfs_volume(ossfs: "OSSFS") -> None:
+    """
+    Validate OSSFS backend fields.
+
+    Args:
+        ossfs: OSSFS backend model.
+
+    Raises:
+        HTTPException: When any OSSFS field is invalid.
+    """
+    if not isinstance(ossfs.bucket, str) or not ossfs.bucket.strip():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "code": SandboxErrorCodes.INVALID_OSSFS_BUCKET,
+                "message": "OSSFS bucket cannot be empty.",
+            },
+        )
+
+    if not ossfs.endpoint.strip():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "code": SandboxErrorCodes.INVALID_OSSFS_ENDPOINT,
+                "message": "OSSFS endpoint cannot be empty.",
+            },
+        )
+
+    if ossfs.options is not None:
+        for opt in ossfs.options:
+            if not isinstance(opt, str) or not opt.strip():
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail={
+                        "code": SandboxErrorCodes.INVALID_OSSFS_OPTION,
+                        "message": "OSSFS options must be non-empty strings.",
+                    },
+                )
+            normalized = opt.strip()
+            if normalized.startswith("-"):
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail={
+                        "code": SandboxErrorCodes.INVALID_OSSFS_OPTION,
+                        "message": (
+                            "OSSFS options must be raw option payloads without '-' prefix "
+                            "(e.g. 'allow_other', 'uid=1000')."
+                        ),
+                    },
+                )
+
+    if not ossfs.access_key_id or not ossfs.access_key_secret:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "code": SandboxErrorCodes.INVALID_OSSFS_CREDENTIALS,
+                "message": (
+                    "OSSFS inline credentials are required: "
+                    "accessKeyId and accessKeySecret must be provided."
+                ),
+            },
+        )
+
+
 def ensure_egress_configured(
     network_policy: Optional["NetworkPolicy"],
     egress_config: Optional["EgressConfig"],
@@ -428,7 +492,7 @@ def ensure_volumes_valid(
     - Exactly one backend per volume
     - Valid mount paths
     - Valid subPaths
-    - Backend-specific validation (host path, pvc name)
+    - Backend-specific validation (host path, pvc name, ossfs config)
 
     Args:
         volumes: List of volumes to validate (optional).
@@ -466,6 +530,7 @@ def ensure_volumes_valid(
         backends_specified = sum([
             volume.host is not None,
             volume.pvc is not None,
+            volume.ossfs is not None,
         ])
 
         if backends_specified == 0:
@@ -473,7 +538,10 @@ def ensure_volumes_valid(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 detail={
                     "code": SandboxErrorCodes.INVALID_VOLUME_BACKEND,
-                    "message": f"Volume '{volume.name}' must specify exactly one backend (host, pvc), but none was provided.",
+                    "message": (
+                        f"Volume '{volume.name}' must specify exactly one backend "
+                        "(host, pvc, ossfs), but none was provided."
+                    ),
                 },
             )
 
@@ -482,7 +550,10 @@ def ensure_volumes_valid(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 detail={
                     "code": SandboxErrorCodes.INVALID_VOLUME_BACKEND,
-                    "message": f"Volume '{volume.name}' must specify exactly one backend (host, pvc), but multiple were provided.",
+                    "message": (
+                        f"Volume '{volume.name}' must specify exactly one backend "
+                        "(host, pvc, ossfs), but multiple were provided."
+                    ),
                 },
             )
 
@@ -493,6 +564,9 @@ def ensure_volumes_valid(
         if volume.pvc is not None:
             ensure_valid_pvc_name(volume.pvc.claim_name)
 
+        if volume.ossfs is not None:
+            ensure_valid_ossfs_volume(volume.ossfs)
+
 
 __all__ = [
     "ensure_entrypoint",
@@ -505,5 +579,6 @@ def ensure_volumes_valid(
     "ensure_valid_sub_path",
     "ensure_valid_host_path",
     "ensure_valid_pvc_name",
+    "ensure_valid_ossfs_volume",
     "ensure_volumes_valid",
 ]
diff --git a/server/tests/test_docker_service.py b/server/tests/test_docker_service.py
index a5828975..27924ddd 100644
--- a/server/tests/test_docker_service.py
+++ b/server/tests/test_docker_service.py
@@ -13,15 +13,21 @@
 # limitations under the License.
 
 import os
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from unittest.mock import MagicMock, patch
 
 from docker.errors import DockerException, NotFound as DockerNotFound
 import pytest
 from fastapi import HTTPException, status
+from pydantic import ValidationError
 
 from src.config import AppConfig, EgressConfig, RuntimeConfig, ServerConfig, StorageConfig, IngressConfig
-from src.services.constants import SANDBOX_ID_LABEL, SandboxErrorCodes
+from src.services.constants import (
+    SANDBOX_EXPIRES_AT_LABEL,
+    SANDBOX_ID_LABEL,
+    SANDBOX_OSSFS_MOUNTS_LABEL,
+    SandboxErrorCodes,
+)
 from src.services.docker import DockerSandboxService, PendingSandbox
 from src.services.helpers import parse_memory_limit, parse_nano_cpus, parse_timestamp
 from src.api.schema import (
@@ -31,6 +37,7 @@
     ImageSpec,
     NetworkPolicy,
     ListSandboxesRequest,
+    OSSFS,
     PVC,
     ResourceLimits,
     Sandbox,
@@ -716,6 +723,25 @@ def test_mixed_host_and_pvc_volumes(self, mock_docker):
         assert "/data/work:/mnt/work:rw" in binds
         assert "my-shared-volume:/mnt/data:ro" in binds
 
+    def test_ossfs_volume_with_subpath(self, mock_docker):
+        """OSSFS volume should resolve host path using subPath as OSS prefix."""
+        mock_docker.from_env.return_value = MagicMock()
+        service = DockerSandboxService(config=_app_config())
+        volume = Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+            read_only=False,
+            sub_path="task-001",
+        )
+        binds = service._build_volume_binds([volume])
+        assert binds == ["/mnt/ossfs/bucket-test-3/task-001:/mnt/data:rw"]
+
 
 @patch("src.services.docker.docker")
 class TestDockerVolumeValidation:
@@ -753,6 +779,423 @@ def test_pvc_volume_not_found_rejected(self, mock_docker):
         assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST
         assert exc_info.value.detail["code"] == SandboxErrorCodes.PVC_VOLUME_NOT_FOUND
 
+    def test_ossfs_inline_credentials_missing_rejected(self, mock_docker):
+        """OSSFS with missing inline credentials should be rejected at schema validation."""
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = []
+        mock_docker.from_env.return_value = mock_client
+        with pytest.raises(ValidationError):
+            OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                access_key_id=None,
+                access_key_secret=None,
+            )
+
+    def test_ossfs_mount_failure_rejected(self, mock_docker):
+        """OSSFS mount failure should be rejected."""
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = []
+        mock_docker.from_env.return_value = mock_client
+        service = DockerSandboxService(config=_app_config())
+
+        request = CreateSandboxRequest(
+            image=ImageSpec(uri="python:3.11"),
+            timeout=120,
+            resourceLimits=ResourceLimits(root={}),
+            env={},
+            metadata={},
+            entrypoint=["python"],
+            volumes=[
+                Volume(
+                    name="oss-data",
+                    ossfs=OSSFS(
+                        bucket="bucket-test-3",
+                        endpoint="oss-cn-hangzhou.aliyuncs.com",
+                        access_key_id="AKIDEXAMPLE",
+                        access_key_secret="SECRETEXAMPLE",
+                    ),
+                    mount_path="/mnt/data",
+                    sub_path="task-001",
+                )
+            ],
+        )
+
+        with patch("src.services.ossfs_mixin.os.name", "posix"):
+            with patch("src.services.ossfs_mixin.os.path.ismount", return_value=False):
+                with patch("src.services.ossfs_mixin.os.makedirs"):
+                    with patch("src.services.ossfs_mixin.subprocess.run") as mock_run:
+                        mock_run.return_value = MagicMock(returncode=1, stderr="mount failed")
+                        with pytest.raises(HTTPException) as exc_info:
+                            service.create_sandbox(request)
+
+        assert exc_info.value.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+        assert exc_info.value.detail["code"] == SandboxErrorCodes.OSSFS_MOUNT_FAILED
+
+    def test_ossfs_windows_host_not_supported(self, mock_docker):
+        """OSSFS backend should be rejected when server host is Windows."""
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = []
+        mock_docker.from_env.return_value = mock_client
+        service = DockerSandboxService(config=_app_config())
+        volume = Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+        )
+
+        with patch("src.services.ossfs_mixin.os.name", "nt"):
+            with pytest.raises(HTTPException) as exc_info:
+                service._validate_ossfs_volume(volume)
+        assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST
+        assert exc_info.value.detail["code"] == SandboxErrorCodes.INVALID_PARAMETER
+
+    def test_ossfs_v1_mount_command_uses_o_options(self, mock_docker):
+        """OSSFS 1.0 should build mount command with -o style options."""
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = []
+        mock_docker.from_env.return_value = mock_client
+        service = DockerSandboxService(config=_app_config())
+        volume = Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                version="1.0",
+                options=["allow_other", "umask=0022"],
+                access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+            sub_path="task-001",
+        )
+        backend_path = "/mnt/ossfs/bucket-test-3/task-001"
+
+        with patch("src.services.ossfs_mixin.os.makedirs"):
+            with patch("src.services.ossfs_mixin.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(returncode=0, stderr="")
+                service._mount_ossfs_backend_path(volume, backend_path)
+
+        cmd = mock_run.call_args.args[0]
+        assert "bucket-test-3:/task-001" in cmd
+        assert "-o" in cmd
+        assert "allow_other" in cmd
+        assert "umask=0022" in cmd
+        assert "--allow_other" not in cmd
+        assert "sigv4" not in cmd
+        assert not any(str(part).startswith("region=") for part in cmd)
+
+    def test_ossfs_v2_mount_command_uses_config_file(self, mock_docker):
+        """OSSFS 2.0 should mount by ossfs2 config file."""
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = []
+        mock_docker.from_env.return_value = mock_client
+        service = DockerSandboxService(config=_app_config())
+        volume = Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                version="2.0",
+                options=["allow_other", "umask=0022"],
+                access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+            sub_path="task-001",
+        )
+        backend_path = "/mnt/ossfs/bucket-test-3/task-001"
+
+        with patch("src.services.ossfs_mixin.os.makedirs"):
+            with patch("src.services.ossfs_mixin.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(returncode=0, stderr="")
+                service._mount_ossfs_backend_path(volume, backend_path)
+
+        cmd = mock_run.call_args.args[0]
+        assert cmd[0] == "ossfs2"
+        assert cmd[1] == "mount"
+        assert cmd[2] == backend_path
+        assert cmd[3] == "-c"
+        assert cmd[4].endswith(".conf")
+
+    def test_ossfs_v2_config_contains_required_lines(self, mock_docker):
+        """OSSFS 2.0 config should encode endpoint/bucket/creds/options/prefix."""
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = []
+        mock_docker.from_env.return_value = mock_client
+        service = DockerSandboxService(config=_app_config())
+        volume = Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                version="2.0",
+                options=["allow_other", "umask=0022"],
+                access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+            sub_path="task-001",
+        )
+
+        conf_lines = service._build_ossfs_v2_config_lines(
+            volume=volume,
+            endpoint_url="http://oss-cn-hangzhou.aliyuncs.com",
+            prefix="task-001",
+        )
+        assert "--oss_endpoint=http://oss-cn-hangzhou.aliyuncs.com" in conf_lines
+        assert "--oss_bucket=bucket-test-3" in conf_lines
+        assert "--oss_access_key_id=AKIDEXAMPLE" in conf_lines
+        assert "--oss_access_key_secret=SECRETEXAMPLE" in conf_lines
+        assert "--oss_bucket_prefix=task-001/" in conf_lines
+        assert "--allow_other" in conf_lines
+        assert "--umask=0022" in conf_lines
+
+    def test_ossfs_volume_binds_passed_to_docker(self, mock_docker):
+        """OSSFS volume should be converted to host bind path and passed to Docker."""
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = []
+        mock_client.api.create_host_config.return_value = {}
+        mock_client.api.create_container.return_value = {"Id": "cid"}
+        mock_client.containers.get.return_value = MagicMock()
+        mock_docker.from_env.return_value = mock_client
+        service = DockerSandboxService(config=_app_config())
+
+        request = CreateSandboxRequest(
+            image=ImageSpec(uri="python:3.11"),
+            timeout=120,
+            resourceLimits=ResourceLimits(root={}),
+            env={},
+            metadata={},
+            entrypoint=["python"],
+            volumes=[
+                Volume(
+                    name="oss-data",
+                    ossfs=OSSFS(
+                        bucket="bucket-test-3",
+                        endpoint="oss-cn-hangzhou.aliyuncs.com",
+                        access_key_id="AKIDEXAMPLE",
+                        access_key_secret="SECRETEXAMPLE",
+                    ),
+                    mount_path="/mnt/data",
+                    read_only=True,
+                    sub_path="task-001",
+                )
+            ],
+        )
+
+        with patch("src.services.ossfs_mixin.os.name", "posix"):
+            with patch("src.services.ossfs_mixin.os.path.ismount", return_value=False):
+                with patch("src.services.ossfs_mixin.os.makedirs"):
+                    with patch("src.services.ossfs_mixin.subprocess.run") as mock_run:
+                        mock_run.return_value = MagicMock(returncode=0, stderr="")
+                        with patch.object(service, "_ensure_image_available"), patch.object(
+                            service, "_prepare_sandbox_runtime"
+                        ):
+                            response = service.create_sandbox(request)
+
+        assert response.status.state == "Running"
+        assert mock_run.called
+        host_config_call = mock_client.api.create_host_config.call_args
+        binds = host_config_call.kwargs["binds"]
+        assert binds[0] == "/mnt/ossfs/bucket-test-3/task-001:/mnt/data:ro"
+        create_call = mock_client.api.create_container.call_args
+        labels = create_call.kwargs["labels"]
+        assert SANDBOX_OSSFS_MOUNTS_LABEL in labels
+        assert labels[SANDBOX_OSSFS_MOUNTS_LABEL] == '["/mnt/ossfs/bucket-test-3/task-001"]'
+
+    def test_prepare_ossfs_mounts_reuses_mount_key(self, mock_docker):
+        """Two OSSFS volumes on same base path should mount once and share refs."""
+        mock_docker.from_env.return_value = MagicMock()
+        service = DockerSandboxService(config=_app_config())
+        volumes = [
+            Volume(
+                name="oss-data-a",
+                ossfs=OSSFS(
+                    bucket="bucket-test-3",
+                    endpoint="oss-cn-hangzhou.aliyuncs.com",
+                    access_key_id="AKIDEXAMPLE",
+                    access_key_secret="SECRETEXAMPLE",
+                ),
+                mount_path="/mnt/data-a",
+                sub_path="task-001",
+            ),
+            Volume(
+                name="oss-data-b",
+                ossfs=OSSFS(
+                    bucket="bucket-test-3",
+                    endpoint="oss-cn-hangzhou.aliyuncs.com",
+                    access_key_id="AKIDEXAMPLE",
+                    access_key_secret="SECRETEXAMPLE",
+                ),
+                mount_path="/mnt/data-b",
+                sub_path="task-001",
+            ),
+        ]
+
+        with patch("src.services.ossfs_mixin.os.path.ismount", return_value=False):
+            with patch("src.services.ossfs_mixin.os.makedirs"):
+                with patch("src.services.ossfs_mixin.subprocess.run") as mock_run:
+                    mock_run.return_value = MagicMock(returncode=0, stderr="")
+                    mount_keys = service._prepare_ossfs_mounts(volumes)
+
+        mount_key = "/mnt/ossfs/bucket-test-3/task-001"
+        assert mount_keys == [mount_key]
+        assert service._ossfs_mount_ref_counts[mount_key] == 1
+        assert mock_run.call_count == 1
+
+    def test_prepare_ossfs_mounts_rolls_back_on_partial_failure(self, mock_docker):
+        """If one OSSFS mount fails, already prepared mounts should be rolled back."""
+        mock_docker.from_env.return_value = MagicMock()
+        service = DockerSandboxService(config=_app_config())
+        volumes = [
+            Volume(
+                name="oss-data-a",
+                ossfs=OSSFS(
+                    bucket="bucket-a",
+                    endpoint="oss-cn-hangzhou.aliyuncs.com",
+                    access_key_id="AKIDEXAMPLE",
+                    access_key_secret="SECRETEXAMPLE",
+                ),
+                mount_path="/mnt/data-a",
+            ),
+            Volume(
+                name="oss-data-b",
+                ossfs=OSSFS(
+                    bucket="bucket-b",
+                    endpoint="oss-cn-hangzhou.aliyuncs.com",
+                    access_key_id="AKIDEXAMPLE",
+                    access_key_secret="SECRETEXAMPLE",
+                ),
+                mount_path="/mnt/data-b",
+            ),
+        ]
+
+        mount_key_a = "/mnt/ossfs/bucket-a"
+        mount_key_b = "/mnt/ossfs/bucket-b"
+
+        with patch.object(
+            service,
+            "_ensure_ossfs_mounted",
+            side_effect=[mount_key_a, HTTPException(status_code=500, detail={"code": "E", "message": "boom"})],
+        ) as ensure_mock:
+            with patch.object(service, "_release_ossfs_mounts") as release_mock:
+                with pytest.raises(HTTPException):
+                    service._prepare_ossfs_mounts(volumes)
+
+        assert ensure_mock.call_count == 2
+        release_mock.assert_called_once_with([mount_key_a])
+        assert mount_key_b not in release_mock.call_args.args[0]
+
+    def test_delete_sandbox_releases_ossfs_mount(self, mock_docker):
+        """Deleting sandbox should release and unmount tracked OSSFS mount."""
+        mount_key = "/mnt/ossfs/bucket-test-3/task-001"
+        mock_container = MagicMock()
+        mock_container.attrs = {
+            "Config": {
+                "Labels": {
+                    SANDBOX_ID_LABEL: "sandbox-1",
+                    SANDBOX_OSSFS_MOUNTS_LABEL: f'["{mount_key}"]',
+                }
+            },
+            "State": {"Running": True},
+        }
+
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = [mock_container]
+        mock_docker.from_env.return_value = mock_client
+        service = DockerSandboxService(config=_app_config())
+        service._ossfs_mount_ref_counts[mount_key] = 1
+
+        with patch("src.services.ossfs_mixin.os.path.ismount", return_value=True):
+            with patch("src.services.ossfs_mixin.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(returncode=0, stderr="")
+                service.delete_sandbox("sandbox-1")
+
+        assert mount_key not in service._ossfs_mount_ref_counts
+        assert mock_run.called
+
+    def test_release_ossfs_mount_untracked_key_does_not_unmount(self, mock_docker):
+        """Untracked mount key must not trigger unmount command."""
+        mount_key = "/mnt/ossfs/bucket-test-3/task-001"
+        mock_docker.from_env.return_value = MagicMock()
+        service = DockerSandboxService(config=_app_config())
+
+        with patch("src.services.ossfs_mixin.os.path.ismount", return_value=True):
+            with patch("src.services.ossfs_mixin.subprocess.run") as mock_run:
+                service._release_ossfs_mount(mount_key)
+
+        mock_run.assert_not_called()
+        assert mount_key not in service._ossfs_mount_ref_counts
+
+    def test_restore_existing_sandboxes_rebuilds_ossfs_refs(self, mock_docker):
+        """Service startup rebuilds OSSFS mount refs from container labels."""
+        mount_key = "/mnt/ossfs/bucket-test-3/task-001"
+        expires_at = (datetime.now(timezone.utc) + timedelta(minutes=10)).isoformat()
+        container = MagicMock()
+        container.attrs = {
+            "Config": {
+                "Labels": {
+                    SANDBOX_ID_LABEL: "sandbox-1",
+                    SANDBOX_EXPIRES_AT_LABEL: expires_at,
+                    SANDBOX_OSSFS_MOUNTS_LABEL: f'["{mount_key}"]',
+                }
+            },
+            "State": {"Running": True},
+        }
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = [container]
+        mock_docker.from_env.return_value = mock_client
+
+        service = DockerSandboxService(config=_app_config())
+
+        assert service._ossfs_mount_ref_counts[mount_key] == 1
+
+    def test_delete_one_sandbox_after_restart_keeps_shared_mount(self, mock_docker):
+        """After restart, deleting one of two users must not unmount shared OSSFS mount."""
+        mount_key = "/mnt/ossfs/bucket-test-3/task-001"
+        expires_at = (datetime.now(timezone.utc) + timedelta(minutes=10)).isoformat()
+        container_a = MagicMock()
+        container_a.attrs = {
+            "Config": {
+                "Labels": {
+                    SANDBOX_ID_LABEL: "sandbox-a",
+                    SANDBOX_EXPIRES_AT_LABEL: expires_at,
+                    SANDBOX_OSSFS_MOUNTS_LABEL: f'["{mount_key}"]',
+                }
+            },
+            "State": {"Running": True},
+        }
+        container_b = MagicMock()
+        container_b.attrs = {
+            "Config": {
+                "Labels": {
+                    SANDBOX_ID_LABEL: "sandbox-b",
+                    SANDBOX_EXPIRES_AT_LABEL: expires_at,
+                    SANDBOX_OSSFS_MOUNTS_LABEL: f'["{mount_key}"]',
+                }
+            },
+            "State": {"Running": True},
+        }
+        mock_client = MagicMock()
+        mock_client.containers.list.return_value = [container_a, container_b]
+        mock_docker.from_env.return_value = mock_client
+
+        service = DockerSandboxService(config=_app_config())
+        assert service._ossfs_mount_ref_counts[mount_key] == 2
+
+        with patch("src.services.ossfs_mixin.os.path.ismount", return_value=True):
+            with patch("src.services.ossfs_mixin.subprocess.run") as mock_run:
+                service.delete_sandbox("sandbox-a")
+
+        assert service._ossfs_mount_ref_counts[mount_key] == 1
+        mock_run.assert_not_called()
+
     def test_pvc_volume_inspect_failure_returns_500(self, mock_docker):
         """Docker API failure during volume inspection should return 500."""
         mock_client = MagicMock()
diff --git a/server/tests/test_endpoint.py b/server/tests/test_endpoint.py
new file mode 100644
index 00000000..d121b0cd
--- /dev/null
+++ b/server/tests/test_endpoint.py
@@ -0,0 +1,29 @@
+# Copyright 2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from src.services.helpers import normalize_external_endpoint_url
+
+
+def test_normalize_external_endpoint_url_defaults_to_https() -> None:
+    assert (
+        normalize_external_endpoint_url("oss-cn-hangzhou.aliyuncs.com")
+        == "https://oss-cn-hangzhou.aliyuncs.com"
+    )
+
+
+def test_normalize_external_endpoint_url_keeps_existing_scheme() -> None:
+    assert (
+        normalize_external_endpoint_url("http://oss-cn-hangzhou.aliyuncs.com")
+        == "http://oss-cn-hangzhou.aliyuncs.com"
+    )
diff --git a/server/tests/test_schema.py b/server/tests/test_schema.py
index 1dc7d653..3046cd1d 100644
--- a/server/tests/test_schema.py
+++ b/server/tests/test_schema.py
@@ -21,6 +21,7 @@
     CreateSandboxRequest,
     Host,
     ImageSpec,
+    OSSFS,
     PVC,
     ResourceLimits,
     Volume,
@@ -93,6 +94,44 @@ def test_claim_name_required(self):
         assert any("claim_name" in str(e["loc"]) or "claimName" in str(e["loc"]) for e in errors)
 
 
+# ============================================================================
+# OSSFS Tests
+# ============================================================================
+
+
+class TestOSSFS:
+    """Tests for OSSFS model."""
+
+    def test_valid_ossfs(self):
+        backend = OSSFS(
+            bucket="bucket-test-3",
+            endpoint="oss-cn-hangzhou.aliyuncs.com",
+            version="2.0",
+            options=["allow_other"],
+            access_key_id="AKIDEXAMPLE",
+            access_key_secret="SECRETEXAMPLE",
+        )
+        assert backend.bucket == "bucket-test-3"
+        assert backend.version == "2.0"
+        assert backend.access_key_id == "AKIDEXAMPLE"
+
+    def test_default_ossfs_version_is_2_0(self):
+        backend = OSSFS(
+            bucket="bucket-test-3",
+            endpoint="oss-cn-hangzhou.aliyuncs.com",
+            access_key_id="AKIDEXAMPLE",
+            access_key_secret="SECRETEXAMPLE",
+        )
+        assert backend.version == "2.0"
+
+    def test_inline_credentials_required(self):
+        with pytest.raises(ValidationError):
+            OSSFS(  # type: ignore
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+            )
+
+
 # ============================================================================
 # Volume Tests
 # ============================================================================
@@ -143,6 +182,23 @@ def test_valid_volume_with_subpath(self):
         )
         assert volume.sub_path == "task-001"
 
+    def test_valid_ossfs_volume(self):
+        """Valid OSSFS volume should be accepted."""
+        volume = Volume(
+            name="data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                    access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+            sub_path="task-001",
+        )
+        assert volume.ossfs is not None
+        assert volume.ossfs.access_key_id == "AKIDEXAMPLE"
+        assert volume.sub_path == "task-001"
+
     def test_no_backend_raises(self):
         """Volume without any backend should raise ValidationError."""
         with pytest.raises(ValidationError) as exc_info:
@@ -235,6 +291,24 @@ def test_deserialization_pvc_volume(self):
         assert volume.mount_path == "/mnt/models"
         assert volume.read_only is True
 
+    def test_serialization_ossfs_volume(self):
+        volume = Volume(
+            name="data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                    access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+            read_only=False,
+            sub_path="task-001",
+        )
+        data = volume.model_dump(by_alias=True, exclude_none=True)
+        assert data["ossfs"]["bucket"] == "bucket-test-3"
+        assert data["ossfs"]["accessKeyId"] == "AKIDEXAMPLE"
+        assert data["subPath"] == "task-001"
+
 
 # ============================================================================
 # CreateSandboxRequest with Volumes Tests
diff --git a/server/tests/test_validators.py b/server/tests/test_validators.py
index 3810961b..7fba701f 100644
--- a/server/tests/test_validators.py
+++ b/server/tests/test_validators.py
@@ -15,7 +15,7 @@
 import pytest
 from fastapi import HTTPException
 
-from src.api.schema import Host, PVC, Volume
+from src.api.schema import Host, OSSFS, PVC, Volume
 from src.services.constants import SandboxErrorCodes
 from src.services.validators import (
     ensure_metadata_labels,
@@ -347,6 +347,22 @@ def test_valid_pvc_volume(self):
         )
         ensure_volumes_valid([volume])
 
+    def test_valid_ossfs_volume(self):
+        """Valid OSSFS volume should pass validation."""
+        volume = Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                    access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+            read_only=False,
+            sub_path="task-001",
+        )
+        ensure_volumes_valid([volume])
+
     def test_valid_volume_with_subpath(self):
         """Valid volume with subPath should pass validation."""
         volume = Volume(
@@ -452,6 +468,75 @@ def test_host_path_allowlist_enforced(self):
         assert exc_info.value.status_code == 400
         assert exc_info.value.detail["code"] == SandboxErrorCodes.HOST_PATH_NOT_ALLOWED
 
+    def test_ossfs_invalid_version_rejected_by_schema(self):
+        """Unsupported OSSFS version should be rejected by schema validation."""
+        from pydantic import ValidationError
+
+        with pytest.raises(ValidationError):
+            OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                version="3.0",  # type: ignore[arg-type]
+                access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            )
+
+    def test_ossfs_missing_inline_credentials_raises(self):
+        """Missing inline credentials should raise HTTPException."""
+        volume = Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+        )
+        volume.ossfs.access_key_id = None
+        with pytest.raises(HTTPException) as exc_info:
+            ensure_volumes_valid([volume])
+        assert exc_info.value.status_code == 400
+        assert exc_info.value.detail["code"] == SandboxErrorCodes.INVALID_OSSFS_CREDENTIALS
+
+    def test_ossfs_v1_options_reject_prefixed_entries(self):
+        """OSSFS options should reject prefixed entries for 1.0."""
+        volume = Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                version="1.0",
+                options=["--allow_other"],
+                access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+        )
+        with pytest.raises(HTTPException) as exc_info:
+            ensure_volumes_valid([volume])
+        assert exc_info.value.status_code == 400
+        assert exc_info.value.detail["code"] == SandboxErrorCodes.INVALID_OSSFS_OPTION
+
+    def test_ossfs_v2_options_reject_prefixed_entries(self):
+        """OSSFS options should reject prefixed entries for 2.0."""
+        volume = Volume(
+            name="oss-data",
+            ossfs=OSSFS(
+                bucket="bucket-test-3",
+                endpoint="oss-cn-hangzhou.aliyuncs.com",
+                version="2.0",
+                options=["-o allow_other"],
+                access_key_id="AKIDEXAMPLE",
+                access_key_secret="SECRETEXAMPLE",
+            ),
+            mount_path="/mnt/data",
+        )
+        with pytest.raises(HTTPException) as exc_info:
+            ensure_volumes_valid([volume])
+        assert exc_info.value.status_code == 400
+        assert exc_info.value.detail["code"] == SandboxErrorCodes.INVALID_OSSFS_OPTION
+
     def test_invalid_pvc_name_rejected_by_pydantic(self):
         """Invalid PVC name should be rejected by Pydantic pattern validation."""
         from pydantic import ValidationError
diff --git a/specs/sandbox-lifecycle.yml b/specs/sandbox-lifecycle.yml
index cb9b4575..ceeb5012 100644
--- a/specs/sandbox-lifecycle.yml
+++ b/specs/sandbox-lifecycle.yml
@@ -892,7 +892,7 @@ components:
       description: |
         Storage mount definition for a sandbox. Each volume entry contains:
         - A unique name identifier
-        - Exactly one backend struct (host, pvc, etc.) with backend-specific fields
+        - Exactly one backend struct (host, pvc, ossfs, etc.) with backend-specific fields
         - Common mount settings (mountPath, readOnly, subPath)
       required: [name, mountPath]
       properties:
@@ -907,6 +907,8 @@ components:
           $ref: '#/components/schemas/Host'
         pvc:
           $ref: '#/components/schemas/PVC'
+        ossfs:
+          $ref: '#/components/schemas/OSSFS'
         mountPath:
           type: string
           description: |
@@ -922,6 +924,7 @@ components:
           type: string
           description: |
             Optional subdirectory under the backend path to mount.
+            For `ossfs` backend, this field is used as the bucket prefix.
             Must be a relative path without '..' components.
       additionalProperties: false
 
@@ -966,3 +969,48 @@ components:
           maxLength: 253
       additionalProperties: false
 
+    OSSFS:
+      type: object
+      description: |
+        Alibaba Cloud OSS mount backend via ossfs.
+
+        The runtime mounts a host-side OSS path under `storage.ossfs_mount_root`
+        and bind-mounts the resolved path into the sandbox container.
+        Prefix selection is expressed via `Volume.subPath`.
+        In Docker runtime, OSSFS backend requires OpenSandbox Server to run on a Linux host with FUSE support.
+      required: [bucket, endpoint, accessKeyId, accessKeySecret]
+      properties:
+        bucket:
+          type: string
+          description: OSS bucket name.
+          minLength: 3
+          maxLength: 63
+        endpoint:
+          type: string
+          description: OSS endpoint (e.g., `oss-cn-hangzhou.aliyuncs.com`).
+          minLength: 1
+        version:
+          type: string
+          description: ossfs major version used by runtime mount integration.
+          enum: ["1.0", "2.0"]
+          default: "2.0"
+        options:
+          type: array
+          description: |
+            Additional ossfs mount options.
+            Runtime encodes options by `version`:
+            - `1.0`: mounts with `ossfs ... -o <option>`
+            - `2.0`: mounts with `ossfs2 mount ... -c <config-file>` and encodes options as `--<option>` lines in the config file
+            Option values must be provided as raw payloads without leading `-`.
+          items:
+            type: string
+        accessKeyId:
+          type: string
+          description: OSS access key ID for inline credentials mode.
+          minLength: 1
+        accessKeySecret:
+          type: string
+          description: OSS access key secret for inline credentials mode.
+          minLength: 1
+      additionalProperties: false
+