> ## Documentation Index
> Fetch the complete documentation index at: https://docs.blaxel.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Agent Drive overview

> Agent Drive is a distributed filesystem mountable to multiple sandboxes or agents simultaneously, with concurrent read-write access and built-in replication.

<Note>
  This feature is currently in private preview. During the preview, the Agent Drive feature is only available in the `us-was-1` region. Both your drive and your sandbox must be created in this region. Drive size is not configurable at the moment. Similarly, drive access control is currently only possible at workspace level: once a drive is mounted in a sandbox, the sandbox has sufficient credentials to access all other drives in the same workspace. A quotas system for drive storage and more fine-grained access control features are coming soon. [Request access](https://blaxel.fillout.com/t/pbTXmanx3Sus).
</Note>

Agent Drive is a distributed filesystem that can be mounted to multiple sandboxes or agents at any time, including while they are already running. Drives support concurrent read-write access (RWX) from multiple sandboxes simultaneously, with built-in replication for durability.

Unlike [volumes](../Volumes/Overview), which are block storage devices attached at sandbox creation to a single sandbox, drives behave like a shared cloud filesystem, but mounted directly into a sandbox's file tree. An optimized FUSE client built specifically for this filesystem is added directly to the sandbox or agent to give a POSIX-compliant interface.

* A drive can be attached to an already-running sandbox at any mount path, without needing to recreate the sandbox
* Multiple sandboxes can mount the same drive simultaneously with full read-write access.
* A specific subdirectory of a drive can be mounted using `drivePath` (instead of mounting the entire drive).
* Drives scale automatically with no fixed capacity limits. Pre-provisioning or run-time resizing is not required.

## Use cases

Some examples of use cases are:

* Passing data or files from one sandbox to another directly, without needing intermediary storage or services
* Storing tool call outputs and context histories for use in other agents
* Sharing common datasets across agents
* Creating a shared filesystem cache of package dependencies to speed up future agent/sandbox deployments

## Create a drive

<Accordion title="Learn more about authentication on Blaxel">
  The Blaxel SDK requires two environment variables to authenticate:

  | Variable       | Description                |
  | -------------- | -------------------------- |
  | `BL_WORKSPACE` | Your Blaxel workspace name |
  | `BL_API_KEY`   | Your Blaxel API key        |

  You can create an API key from the [Blaxel console](https://app.blaxel.ai/profile/security). Your workspace name is visible in the URL when you log in to the console (e.g. `app.blaxel.ai/{workspace}`).

  Set them as environment variables or add them to a `.env` file at the root of your project:

  ```bash theme={null}
  export BL_WORKSPACE=my-workspace
  export BL_API_KEY=my-api-key
  ```

  When developing locally, you can also **log in to your workspace with Blaxel CLI** (as shown above). This allows you to run Blaxel SDK functions that will automatically connect to your workspace without additional setup. When you deploy on Blaxel, authentication is handled automatically — no environment variables needed.
</Accordion>

Create a standalone drive by specifying a unique `name` and `region`. You can also optionally specify the display name and labels for the drive.

<CodeGroup>
  ```tsx TypeScript theme={null}
  import { DriveInstance } from "@blaxel/core";

  const drive = await DriveInstance.create({
    name: "my-drive",
    region: "us-was-1",
    displayName: "My Project Drive", // optional; defaults to `name`
    labels: { env: "dev", project: "my-project" }, // optional; labels
  });
  ```

  ```python Python theme={null}
  from blaxel.core.drive import DriveInstance
  drive = await DriveInstance.create(
      {
          "name": "my-drive",
          "region": "us-was-1",
          "display_name": "My Project Drive", # optional; defaults to `name`
          "labels": {"env": "dev", "project": "my-project"},  # optional; labels
      }
  )
  ```
</CodeGroup>

You can also use `createIfNotExists()` to retrieve an existing drive or create a new one if it doesn't exist:

<CodeGroup>
  ```tsx TypeScript theme={null}
  const drive = await DriveInstance.createIfNotExists({
    name: "my-drive",
    region: "us-was-1",
    displayName: "My Project Drive", // optional; defaults to `name`
    labels: { env: "dev", project: "my-project" }, // optional; labels
  });
  ```

  ```python Python theme={null}
  from blaxel.core.drive import DriveInstance
  drive = await DriveInstance.create_if_not_exists(
      {
          "name": "my-drive",
          "region": "us-was-1",
          "display_name": "My Project Drive", # optional; defaults to `name`
          "labels": {"env": "dev", "project": "my-project"},  # optional; labels
      }
  )
  ```
</CodeGroup>

## Mount a drive to a sandbox

Mount a drive to a running sandbox by specifying the `driveName`, the `mountPath` (where the drive will appear in the sandbox's filesystem), and optionally the `drivePath` (a subdirectory within the drive to mount).

<CodeGroup>
  ```tsx TypeScript theme={null}
  import { SandboxInstance } from "@blaxel/core";

  const sandbox = await SandboxInstance.get("my-sandbox");

  await sandbox.drives.mount({
    driveName: "my-drive",
    mountPath: "/mnt/data",
    drivePath: "/",   // optional; defaults to root of the drive
  });
  ```

  ```python Python theme={null}
  from blaxel.core import SandboxInstance

  sandbox = await SandboxInstance.get("my-sandbox")

  await sandbox.drives.mount(
      drive_name="my-drive",
      mount_path="/mnt/data",
      drive_path="/", # optional; defaults to root of the drive
  )
  ```
</CodeGroup>

Once mounted, any file written to `/mnt/data` inside the sandbox will be stored on the drive and persist even after the sandbox is deleted.

### Mount a subdirectory

You can mount a specific subdirectory of a drive rather than its root. This is useful when a single drive contains multiple project directories:

<CodeGroup>
  ```tsx TypeScript theme={null}
  await sandbox.drives.mount({
    driveName: "my-drive",
    mountPath: "/app/project",
    drivePath: "/projects/alpha",
  });
  ```

  ```python Python theme={null}
  await sandbox.drives.mount(
      drive_name="my-drive",
      mount_path="/app/project",
      drive_path="/projects/alpha",
  )
  ```
</CodeGroup>

<Warning>
  `drivePath` / `drive_path` is a mount point convenience, not a security boundary. Once a drive is mounted at any location in a sandbox, the sandbox has sufficient credentials to access all other drives in the same workspace. This is a temporary constraint during the preview phase; the final release will include fine-grained access control.
</Warning>

### Mount a drive as read-only

You can mount a drive in read-only mode:

<CodeGroup>
  ```tsx TypeScript theme={null}
  await sandbox.drives.mount({
    driveName: "my-drive",
    mountPath: "/mnt/shared",
    readOnly: true,
  });
  ```

  ```python Python theme={null}
  await sandbox.drives.mount(
      drive_name="my-drive",
      mount_path="/mnt/shared",
      read_only=True,
  )
  ```
</CodeGroup>

The same drive can be mounted read-write in one sandbox and read-only in others. However, any write attempt to a drive mounted as read-only will fail with a permission error.

<Warning>
  Read-only mode is enforced at mount time, not at the storage/system level. Therefore,  if an agent running inside the sandbox manages to read the drive access token, located at `/var/run/secrets/blaxel.ai/identity/token` and re-invoke the `blfs` command itself, it could remount the drive in read-write mode and bypass the read-only restriction.

  To make the read-only guarantee effective in an adversarial/agentic setup, you should restrict the agent's access to `/var/run/secrets/blaxel.ai/identity/token`, and also block the `blfs` binary from the agent's `PATH` / execution scope.
</Warning>

## List mounted drives

List all drives currently mounted to a sandbox:

<CodeGroup>
  ```tsx TypeScript theme={null}
  const mounts = await sandbox.drives.list();
  console.log(mounts);
  ```

  ```python Python theme={null}
  mounts = await sandbox.drives.list()
  print(mounts)
  ```
</CodeGroup>

## List all drives

<CodeGroup>
  ```tsx TypeScript theme={null}
  import { DriveInstance } from "@blaxel/core";

  const drives = await DriveInstance.list();
  ```

  ```python Python theme={null}
  from blaxel.core.drive import DriveInstance
  drives = await DriveInstance.list()
  ```
</CodeGroup>

Or via CLI:

```bash theme={null}
bl get drives
```

## Unmount a drive

Unmount a drive from a running sandbox by specifying the mount path:

<CodeGroup>
  ```tsx TypeScript theme={null}
  await sandbox.drives.unmount("/mnt/data");
  ```

  ```python Python theme={null}
  await sandbox.drives.unmount("/mnt/data")
  ```
</CodeGroup>

## Delete a drive

<CodeGroup>
  ```tsx TypeScript theme={null}
  import { DriveInstance } from "@blaxel/core";

  // Class-level
  await DriveInstance.delete("my-drive");

  // Or instance-level
  const drive = await DriveInstance.get("my-drive");
  await drive.delete();
  ```

  ```python Python theme={null}
  from blaxel.core.drive import DriveInstance

  # Class-level
  await DriveInstance.delete("my-drive")

  # Or instance-level
  drive = await DriveInstance.get("my-drive")
  await drive.delete()
  ```
</CodeGroup>

<Tip>
  Complete code examples demonstrating all operations are available in Blaxel's GitHub repositories, [for TypeScript](https://github.com/blaxel-ai/sdk-typescript/tree/main/tests/integration/sandbox), [for Python](https://github.com/blaxel-ai/sdk-python/tree/main/tests/integration/core/sandbox), and [for Go](https://github.com/blaxel-ai/sdk-go/tree/main/integration_tests).
</Tip>

## Full example

The following example creates a drive, creates a sandbox from a custom sandbox image using its image ID, mounts the drive, writes a file to the mounted path, and reads it back:

<CodeGroup>
  ```tsx TypeScript theme={null}
  import { SandboxInstance, DriveInstance } from "@blaxel/core";

  // 1. Create a drive
  const drive = await DriveInstance.createIfNotExists({
    name: "agent-storage",
    region: "us-was-1",
  });

  // 2. Create a sandbox
  //    Use the image ID of the custom sandbox image
  const sandbox = await SandboxInstance.createIfNotExists({
    name: "my-agent-sandbox",
    image: "my-sandbox-image-id",
    memory: 2048,
    region: "us-was-1",
  });

  // 3. Mount the drive to the sandbox
  await sandbox.drives.mount({
    driveName: "agent-storage",
    mountPath: "/mnt/storage",
    drivePath: "/",
  });

  // 4. Write a file to the mounted drive
  await sandbox.fs.write("/mnt/storage/hello.txt", "Hello from the drive!");

  // 5. Read it back
  const content = await sandbox.fs.read("/mnt/storage/hello.txt");
  console.log(content); // "Hello from the drive!"

  // 6. List mounted drives
  const mounts = await sandbox.drives.list();
  console.log(mounts);
  ```

  ```python Python theme={null}
  import asyncio
  from blaxel.core.drive import DriveInstance
  from blaxel.core import SandboxInstance

  async def main():
      # 1. Create a drive
      drive = await DriveInstance.create_if_not_exists(
          {
              "name": "agent-storage",
              "region": "us-was-1",
          }
      )

      # 2. Create a sandbox
      sandbox = await SandboxInstance.create_if_not_exists(
          {
              "name": "my-agent-sandbox",
              "image": "my-sandbox-image-id",
              "memory": 2048,
              "region": "us-was-1",
          }
      )

      # 3. Mount the drive to the sandbox
      await sandbox.drives.mount(
          drive_name="agent-storage",
          mount_path="/mnt/storage",
          drive_path="/",
      )

      # 4. Write a file to the mounted drive
      await sandbox.fs.write("/mnt/storage/hello.txt", "Hello from the drive!")

      # 5. Read it back
      content = await sandbox.fs.read("/mnt/storage/hello.txt")
      print(content)  # "Hello from the drive!"

      # 6. List mounted drives
      mounts = await sandbox.drives.list()
      print(mounts)

  asyncio.run(main())
  ```
</CodeGroup>