🥪

Claude Code等をE2Bサンドボックスで動かすレポジトリを調べてみた

に公開

AIコーディングエージェントが本格的に実用化される中で、リモートサーバー上でClaude CodeなどのCLIエージェントを活用しようとする動きが活発になってきました。開発チーム全体でAIエージェントを共有したい、SaaSの機能として組み込みたい、CI/CDパイプラインに統合したい。こうしたニーズに応えるには、ローカル環境ではなくクラウド上でAIエージェントを動かす仕組みが必要です。

ここで注目されているのがE2Bです。E2Bは、サンドボックス環境(外部から隔離された安全な実行空間)をクラウド上に提供するサービスで、AIエージェントがリモートで安全にコードを実行できる場所を作ってくれます。本記事を読み終える頃には、Claude Codeをリモートサーバー上で動かし、チームやサービスから利用できる環境を構築できるようになります。Manusにも使われています。

必要なのはE2Bのアカウント(無料枠あり)と、各リポジトリで求められるAPIキーです。今回は、AIエージェントとE2Bを組み合わせる3つのレポジトリを実際に動かしながら解説していきます。具体的には3パターンあります。(1) E2BをClaude Codeのコード実行環境として使う方法、(2) Claude Agent SDKをWebSocketサーバー化する方法、(3) MastraでE2B実行エージェントを構築する方法です。最初の2つはClaude Codeエコシステムの活用で、3つ目はMastraとOpenAIモデルを前提にしたテンプレートです。最初の方法が最も手軽で、短時間で試せます。

E2Bサンドボックスとは何か

E2Bを一言で説明するなら、「使い捨ての仮想コンピュータをAPIで自動制御できるサービス」と言えそうです。仮想コンピュータとは、クラウド上に用意された「もう一台のサーバー」のようなものです。本番環境やインフラとは完全に切り離されているため、何か問題が起きても影響を受けません。ファイルの作成・編集、コマンドの実行、プロセスの起動・停止といった操作を、APIを通じて外部から実行できます。

いわば、AIエージェントに専用の作業部屋を与えるようなものですね。散らかし放題でも、部屋ごと消せば何も残りません。例えば、Claude Codeに「このAPIを叩いてデータを取得して」と指示したとき、万が一誤ったコマンドが実行されても、サンドボックス内で完結するため、その他の本番環境には一切影響がありません。これは、リモートサーバーでAIエージェントを運用する際の安全性を担保する上で重要なポイントです。

サンドボックスを作成すると、数秒で完全に隔離されたLinux環境が立ち上がります。この環境はAPIでフル制御できるため、Webアプリケーションのバックエンドから呼び出したり、CI/CDパイプラインに組み込んだりすることが可能です。

AIエージェントとE2Bの全体像

AIエージェントがE2Bサンドボックスを使ってコードを実行する流れを図で示すと、以下のようになります。

┌─────────────────────────────────────────────────────────────────┐
│  あなたのローカル環境 / Webアプリ                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ AIエージェント(Claude Code / GPT-4 / Gemini 等)       │   │
│  │ 「Pythonで素数を計算して」という指示を受ける            │   │
│  └────────────────────────┬────────────────────────────────┘   │
└───────────────────────────┼─────────────────────────────────────┘
                            │ E2B SDK経由でAPI呼び出し
                            ↓
┌─────────────────────────────────────────────────────────────────┐
│  E2B クラウドサービス                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ E2B API                                                  │   │
│  │ - サンドボックスの作成・削除                             │   │
│  │ - ファイル操作のリクエスト受付                           │   │
│  │ - コマンド実行のリクエスト受付                           │   │
│  └────────────────────────┬────────────────────────────────┘   │
│                           ↓                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ サンドボックス(隔離されたLinux環境)                    │   │
│  │ ┌─────────────────────────────────────────────────────┐ │   │
│  │ │ - Python, Node.js, etc. がプリインストール          │ │   │
│  │ │ - ファイルシステム(読み書き自由)                  │ │   │
│  │ │ - ネットワークアクセス可能                          │ │   │
│  │ │ - 本番環境から完全に隔離                            │ │   │
│  │ └─────────────────────────────────────────────────────┘ │   │
│  │ → コード実行結果をAPIレスポンスとして返却               │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

この構造のおかげで、AIエージェントは自分が書いたコードを「試しに実行してみる」ことができます。実行結果を見て、エラーがあれば修正し、成功すれば次のステップに進みます。この試行錯誤のループを、本番環境を汚すことなく繰り返せるのがE2Bの価値です。

基本的なAPI操作

E2Bでサンドボックスを作成し、コマンドを実行する流れを見てみましょう。
Pythonで試す場合はe2b-code-interpreterを使います。e2b-code-interpreter

from e2b_code_interpreter import Sandbox

# サンドボックスを作成(timeoutは秒)
sandbox = Sandbox.create(timeout=3600)
print(f"Sandbox ID: {sandbox.sandbox_id}")  # 例: sbx_abc123def456

# コマンドを実行
result = sandbox.commands.run("echo 'Hello from E2B!'")
print(result.stdout)  # "Hello from E2B!"

# ファイルを書き込む
sandbox.files.write("/home/user/app.py", "print('Hello World')")

# ファイルを実行
result = sandbox.commands.run("python /home/user/app.py")
print(result.stdout)  # "Hello World"

# 使い終わったら削除(またはタイムアウトで自動削除)
sandbox.kill()

timeoutは秒指定で、デフォルトは300秒です。Hobbyは最大1時間、Proは最大24時間まで延長できます。E2B Python SDK

このサンドボックスをAIエージェントに渡すことで、AIは自由にコードを書いて実行し、結果を確認できるようになります。では、Claude Code・AIエージェントとE2Bを組み合わせて使うためのオープンソースリポジトリを3つ紹介していきます。

今回紹介する3つのリポジトリ

Claude CodeとE2Bを組み合わせて使うためのオープンソースリポジトリが、すでにいくつか公開されています。本記事では、その中から見つけた3つを取り上げて紹介します。

リポジトリ GitHub 特徴 向いているケース
agent-sandbox-skill disler/agent-sandbox-skill Claude Codeのコーディングの実行環境としてのE2B Claude Codeのコード実行をリモートで安全に行いたい
claude-agent-server dzhng/claude-agent-server Claude Agent SDKをWebSocketサーバー化 WebアプリやSaaSに統合したい
mastra-coding-agent evilmartians/mastra-coding-agent MastraでE2B実行エージェントを構築 Mastraベースで自作したい

最初の2つはClaude Codeエコシステムの活用です。Claude Codeのコード実行環境を整理したいならagent-sandbox-skillが参考になります。WebAPI化したいならclaude-agent-serverが適しています。3つ目のmastra-coding-agentは少し方向性が異なり、Mastraを使ってE2B実行エージェントを組み立てるテンプレートです。

それでは、各リポジトリを詳しく見ていきます。


1. disler/agent-sandbox-skill

GitHub: https://github.com/disler/agent-sandbox-skill

最初に紹介するリポジトリは、E2Bの環境でコードを実行できる「agent-sandbox-skill」です。Claude Codeの「スキル」機能を活用しており、バックスラッシュコマンド(\sandboxのような形式)で新しい機能を追加する仕組みになっています。

内部アーキテクチャ

このスキルがどのように動作するのか、まず全体像を把握しておきましょう。

┌─────────────────────────────────────────────────────────────────┐
│ あなたのターミナル                                              │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Claude Code                                                 │ │
│ │ ユーザー: "\sandbox Pythonで素数を計算して"                 │ │
│ └──────────────────────────┬──────────────────────────────────┘ │
│                            │ スキル呼び出し                     │
│                            ↓                                    │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Agent Sandbox Skill (Python CLI)                            │ │
│ │ sbx init → sbx files write → sbx exec                       │ │
│ └──────────────────────────┬──────────────────────────────────┘ │
└────────────────────────────┼────────────────────────────────────┘
                             │ E2B Python SDK
                             ↓
┌─────────────────────────────────────────────────────────────────┐
│ E2B クラウド                                                    │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ サンドボックス(フルスタック用テンプレート)               │ │
│ │ - Vue + FastAPI + SQLite を想定した構成                    │ │
│ │ - Playwright連携でブラウザ検証も可能                       │ │
│ │ - timeoutは`sbx init --timeout`で指定                      │ │
│ └─────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘

READMEでは、Vue + FastAPI + SQLiteのフルスタック構成とPlaywright連携が明記されています。agent-sandbox-skill
READMEの例ではsbx init --timeout 1800が示されており、timeoutは秒指定のオプションとして扱われています。agent-sandbox-skill

ポイントは、Claude CodeとE2Bの間に「Python CLI」が挟まっていることです。このCLIはE2Bの公式ツールではなく、このリポジトリ独自のラッパーです。READMEでは、CLIがPythonで実装され、e2bとclickとrichを使う構成であることが示されています。agent-sandbox-skill

READMEで紹介されている主なコマンドは次の通りです。agent-sandbox-skill

  • sbx init --timeout 1800でサンドボックスを初期化
  • sbx files lsでファイル一覧を取得
  • sbx exec "command"でコマンドを実行
  • sbx browser startでブラウザ検証を開始

セットアップ手順

まず、リポジトリをクローンして環境変数を設定します。

# リポジトリをクローン
git clone https://github.com/disler/agent-sandbox-skill.git
cd agent-sandbox-skill

# 環境変数を設定
cp .env.sample .env

.envファイルを開いて、E2BのAPIキーを設定します。APIキーはE2Bダッシュボードから取得できます。

E2B_API_KEY=sbx_your_api_key_here

これだけで準備完了です。Claude Codeを起動してみましょう。

claude

基本的な使い方

最もシンプルな使い方は\sandboxコマンドです。

\sandbox "Pythonで1から10までの素数を計算して"

このコマンドを実行すると、Claude CodeはまずE2Bサンドボックスを作成し、Pythonコードを書いてサンドボックス内に保存します。その後、コードを実行して結果を返してくれます。すべてクラウド上のサンドボックスで完結するため、本番環境に影響を与えることなく安全に動作確認ができます。

フルスタックアプリを自動構築する

agent-sandbox-skillを使っていて「これは面白い」と感じたのが、フルスタックアプリケーションを一気に構築できるワークフローです。\agent-sandboxes:plan-build-host-testコマンドを使うと、計画→実装→ホスト→テストまでを自動で行います。agent-sandbox-skill

\agent-sandboxes:plan-build-host-test "シンプルなToDoアプリを作って" "todo_app"

このコマンドを実行すると、サンドボックスの初期化から実装計画の生成、コード作成、サーバー起動、テスト実行までが自動で進みます。具体的な流れはこんな感じです。

Step 1: サンドボックスを初期化
   → sandbox_id: sbx_abc123 を取得

Step 2: 実装計画を生成
   → フロントエンド: Vue
   → バックエンド: FastAPI + SQLite

Step 3: コードを実装
   → フロントエンドとバックエンドを自動生成

Step 4: サーバーを起動して公開URLを取得
   → ブラウザでアクセス可能な公開URLを返す

Step 5: テストを実行
   → APIエンドポイントの動作確認
   → ブラウザでUIをテスト

最終的に、実際にアクセスできるURLが返ってきます。このURLをブラウザで開くと、AIが作ったToDoアプリが動作しています。

仕組みを理解する

このスキルがどのように動いているのか、コードを見てみましょう。中核となるのはPythonで書かれたCLIツールです。

Claude Codeは\sandboxコマンドを受け取ると、このCLIツールを実行します。CLIツールはE2B SDKを使ってサンドボックスを操作し、結果をClaude Codeに返します。

sbx init              # サンドボックス作成
sbx files ls          # ファイル一覧
sbx exec "command"    # コマンド実行
sbx browser start     # ブラウザ検証

マルチエージェント対応

複数のAIエージェントが同時に動作する場合、サンドボックスIDの管理が重要になります。agent-sandbox-skillでは、シェル変数ではなくエージェントのコンテキスト(記憶)にIDを保存するルールになっています。

# NGパターン: シェル変数を使うと他エージェントと衝突する
SANDBOX_ID=$(sbx init | grep "Sandbox ID")

# OKパターン: エージェントがコンテキストに記憶する
# 出力: "Sandbox ID: sbx_abc123"
# → エージェントが記憶して後続コマンドで使用

この設計により、複数のエージェントが並列で動作しても、それぞれが独立したサンドボックスを管理できます。


2. dzhng/claude-agent-server

GitHub: https://github.com/dzhng/claude-agent-server

「Webアプリのバックエンドから呼び出したい」「複数のクライアントから同時にアクセスしたい」という要件もあるのではないでしょうか。2つ目に紹介する「claude-agent-server」は、まさにそのニーズに応えるリポジトリです。

Claude Agent SDKをWebSocketサーバー(クライアントとサーバー間で双方向のリアルタイム通信を可能にする仕組み)として包み込み、E2Bサンドボックス内で動作させます。WebSocketを使う理由は、AIエージェントの応答をストリーミング形式でリアルタイムに受け取れるためです。これにより、リモートからClaude Codeの機能にアクセスできるようになります。

アーキテクチャ

claude-agent-serverのアーキテクチャを詳しく見ていきましょう。このリポジトリは「モノレポ」構成になっており、サーバー、クライアント、E2Bテンプレートの3つのパッケージで構成されています。

┌─────────────────────────────────────────────────────────────────┐
│ あなたのWebアプリ / バックエンド                                │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ ClaudeAgentClient (@dzhng/claude-agent)                     │ │
│ │ - E2Bサンドボックスを作成                                   │ │
│ │ - WebSocket接続を確立                                       │ │
│ │ - メッセージ送受信                                          │ │
│ └──────────────────────────┬──────────────────────────────────┘ │
└────────────────────────────┼────────────────────────────────────┘
                             │ ① client.start()
                             │    → サンドボックス作成
                             │    → /config に設定POST
                             │    → WebSocket接続
                             ↓
┌─────────────────────────────────────────────────────────────────┐
│ E2B サンドボックス                                              │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Bun WebSocketサーバー (port 3000)                           │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ POST /config  → APIキー・設定を受信                     │ │ │
│ │ │ WS   /ws      → メッセージのやり取り                    │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │                          ↓                                  │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ Claude Agent SDK                                        │ │ │
│ │ │ - メッセージキューから順次処理                          │ │ │
│ │ │ - tool_use(ファイル操作、コマンド実行)                │ │ │
│ │ └────────────────────────┬────────────────────────────────┘ │ │
│ │                          ↓                                  │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ ワークスペース (agent-workspace/)                       │ │ │
│ │ │ - ファイル読み書き                                      │ │ │
│ │ │ - コード実行                                            │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
                             │
                             │ ② レスポンスをWebSocketで返却
                             ↓
┌─────────────────────────────────────────────────────────────────┐
│ クライアント側で受信                                            │
│ client.onMessage(msg => { ... })                                │
└─────────────────────────────────────────────────────────────────┘

この構造が意味するのは、Claude Agent SDKがE2Bサンドボックスの「中」で動いているということです。AIエージェントが生成したコードはすべてサンドボックス内で実行されるため、本番インフラに影響を与えることなく、どんなコードでも安全に試せます。
READMEでは、BunのWebSocketサーバーがport 3000で起動し、/configと/wsでやり取りする構成だと説明されています。claude-agent-server

メッセージフロー

クライアントとサーバー間のメッセージのやり取りを追ってみましょう。

クライアント                          サーバー(E2B内)
    │                                      │
    │  { type: 'user_message',             │
    │    data: { message: '...' } }        │
    │ ────────────────────────────────────→│
    │                                      │ メッセージキューに追加
    │                                      │ Claude Agent SDKで処理
    │                                      │
    │  { type: 'sdk_message',              │
    │    data: { type: 'assistant', ... } }│
    │ ←────────────────────────────────────│
    │                                      │
    │  (tool_useがあれば)                  │
    │  サンドボックス内でファイル操作      │
    │  またはコマンド実行                  │
    │                                      │
    │  { type: 'sdk_message',              │
    │    data: { 実行結果 } }              │
    │ ←────────────────────────────────────│
    │                                      │

注意点として、現在の実装では同時に1つのWebSocket接続しか受け付けません。複数のクライアントから同時にアクセスしたい場合は、サンドボックスを複数起動するか、接続管理のレイヤーを追加する必要があります。

Claude Agent SDKはどうやってファイル操作しているのか

ここで疑問が浮かぶかもしれません。「Claude Agent SDKはどうやってファイルを書いたり編集したりできるの?」と。この仕組みを理解するには、Claude Agent SDKの内部動作を知る必要があります。

┌─────────────────────────────────────────────────────────────────┐
│ ユーザーの指示                                                  │
│ 「input.txtを読んで、内容を反転してoutput.txtに保存して」      │
└──────────────────────────┬──────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────────────┐
│ Claude Agent SDK (サンドボックス内で動作)                       │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 1. Claude APIにメッセージ送信                               │ │
│ │    「ファイルを読んで反転して保存してほしい」               │ │
│ └──────────────────────────┬──────────────────────────────────┘ │
│                            ↓                                    │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 2. Claudeがtool_useを発行                                   │ │
│ │    { "name": "read_file", "input": { "path": "input.txt" } }│ │
│ └──────────────────────────┬──────────────────────────────────┘ │
│                            ↓                                    │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 3. SDKがツールを自動実行                                    │ │
│ │    fs.readFileSync("input.txt")  ← 直接ファイルシステム     │ │
│ │    fs.writeFileSync("output.txt", reversed)                 │ │
│ └──────────────────────────┬──────────────────────────────────┘ │
│                            ↓                                    │
│ │ 4. 実行結果をClaudeに返却 → 最終レスポンス生成              │ │
└─────────────────────────────────────────────────────────────────┘

ここが重要なポイントです。Claude Agent SDKはサンドボックスの中で動いています。そのため、SDKはサンドボックス内のファイルシステムに直接アクセスできます。Claudeがtool_use(ツール使用)を発行すると、SDKが自動的にそのツールを実行し、ファイルの読み書きやコマンド実行を行います。

つまり、ファイル操作の流れをまとめると以下のようになります。

  1. ユーザーがメッセージを送信
  2. Claude APIがtool_useを発行(「read_fileツールを使いたい」)
  3. Claude Agent SDKがツールを自動実行(サンドボックス内のfsに直接アクセス)
  4. 実行結果をClaudeに返却
  5. Claudeが最終レスポンスを生成

サーバーはこの一連の流れを中継しているだけで、ファイル操作自体はSDKが自動的に行っているのです。

セットアップ手順

# リポジトリをクローン
git clone https://github.com/dzhng/claude-agent-server.git
cd claude-agent-server

# 環境変数を設定
cp .env.example .env
# ANTHROPIC_API_KEY=sk-ant-...
# E2B_API_KEY=e2b_...

# 依存関係をインストール
bun install

# E2Bテンプレートをビルド(初回のみ、数分かかる)
bun run build:e2b

READMEでは、Bun 1.3ベースのテンプレートを作成し、サーバー起動までを自動化する流れが説明されています。

クライアントから接続する

ビルドが完了したら、TypeScriptクライアントから接続できます。

import { ClaudeAgentClient } from '@dzhng/claude-agent'

const client = new ClaudeAgentClient({
  e2bApiKey: process.env.E2B_API_KEY,
  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
  template: 'claude-agent-server',
  debug: true
})

// E2Bサンドボックスを起動してWebSocket接続
await client.start()

// メッセージを受信するハンドラを設定
client.onMessage(message => {
  if (message.type === 'sdk_message') {
    console.log('Claude:', message.data)
  }
})

// メッセージを送信
client.send({
  type: 'user_message',
  data: {
    type: 'user',
    session_id: 'my-session',
    message: {
      role: 'user',
      content: 'Pythonでフィボナッチ数列を計算するコードを書いて実行して'
    }
  }
})

// 使い終わったらクリーンアップ
await client.stop()

client.start()を呼ぶと、E2Bサンドボックスが作成され、その中でWebSocketサーバーが起動します。クライアントは自動的にそのサーバーに接続します。

サーバーの実装を見てみる

サーバー側の実装はシンプルです。Bunの組み込みWebSocketサーバーを使っています。

サーバー側は、受け取ったメッセージをSDKに渡し、その結果をWebSocketでクライアントへストリーミングします。

ファイル操作

クライアントライブラリにはファイル操作のヘルパーメソッドも用意されています。

// ファイルを書き込む
await client.writeFile('/app/main.py', 'print("Hello")')

// ファイルを読み込む
const content = await client.readFile('/app/main.py')

// ファイル一覧を取得
const files = await client.listFiles('/app')

// ディレクトリの変更を監視
client.watchDir('/app', (event) => {
  console.log(`File ${event.name} was ${event.type}`)
})

ローカル開発

E2Bにデプロイせずにローカルでテストすることもできます。

# ローカルサーバーを起動
bun run start:server

# 別ターミナルでテスト
bun run test:local

ローカルモードでは、connectionUrlオプションを使って接続先を指定します。

const client = new ClaudeAgentClient({
  connectionUrl: 'http://localhost:3000',
  anthropicApiKey: process.env.ANTHROPIC_API_KEY
})

3. evilmartians/mastra-coding-agent

GitHub: https://github.com/evilmartians/mastra-coding-agent

ここまでの2つのリポジトリは、Claude CodeやClaude Agent SDKといったAnthropicのエコシステムを活用する方向性でした。しかし3つ目のリポジトリは、少し毛色が異なります。

「mastra-coding-agent」は、Claude Codeそのものを動かすのではなく、Mastraを使ってE2B実行のコーディングエージェントを構築するためのテンプレートです。OpenAIのモデルを前提にした構成で、エージェントがサンドボックスを作成し、コードを書き、実行結果を見て反復する流れを実装しています。

「Claude Codeは便利だけど、自社のサービスに組み込むなら独自のエージェントが欲しい」という方には、このアプローチが向いています。Mastraというフレームワークを使っており、エージェントの振る舞いとツールの設計をコードで定義できます。

全体アーキテクチャ

このテンプレートでコーディングエージェントを作ると、どのような構造になるのか見てみましょう。

┌─────────────────────────────────────────────────────────────────┐
│ あなたのアプリケーション                                        │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ codingAgent.run({ messages: [...] })                        │ │
│ └──────────────────────────┬──────────────────────────────────┘ │
└────────────────────────────┼────────────────────────────────────┘
                             ↓
┌─────────────────────────────────────────────────────────────────┐
│ Mastra Agent                                                    │
│ ┌───────────────────────────────────────────────────────────┐   │
│ │ LLM(OpenAIモデル前提)                                  │   │
│ │ ┌─────────────┐                                          │   │
│ │ │  OpenAI     │                                          │   │
│ │ │  GPT-4.1    │                                          │   │
│ │ └─────────────┘                                          │   │
│ └───────────────────────────────────────────────────────────┘   │
│                             ↓                                   │
│ ┌───────────────────────────────────────────────────────────┐   │
│ │ E2B Tools(tool_useで呼び出し)                           │   │
│ │ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐   │   │
│ │ │createSandbox│ │ runCode  │ │ writeFile │ │ readFile  │   │   │
│ │ └───────────┘ └───────────┘ └───────────┘ └───────────┘   │   │
│ │ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐   │   │
│ │ │ listFiles │ │deleteFile │ │runCommand │ │watchDir   │   │   │
│ │ └───────────┘ └───────────┘ └───────────┘ └───────────┘   │   │
│ └───────────────────────────────────────────────────────────┘   │
│                             ↓                                   │
│ ┌───────────────────────────────────────────────────────────┐   │
│ │ Memory(LibSQLベース)                                   │   │
│ │ - 会話履歴を保持                                          │   │
│ │ - セマンティック検索                                      │   │
│ └───────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘
                             ↓ E2B SDK
┌─────────────────────────────────────────────────────────────────┐
│ E2B サンドボックス                                              │
│ - Python / JavaScript / TypeScript 実行                        │
│ - ファイルシステム操作                                          │
│ - シェルコマンド実行                                            │
└─────────────────────────────────────────────────────────────────┘

ポイントは3つあります。

1つ目は、OpenAIモデルを前提に構成されていることです。実装ではopenai('gpt-4.1')が使われています。coding-agent.ts

2つ目は、E2B操作が「ツール」として抽象化されていることです。LLMがtool_useを発行すると、対応するE2B操作が実行されます。

3つ目は、LibSQLを使ったメモリ機構が組み込まれていることです。会話の流れを踏まえた処理が可能になります。

Mastraとは

Mastraは、AIエージェントを構築するためのTypeScriptフレームワークです。エージェントの振る舞い定義、ツール設定(ファイル操作やAPI呼び出しなど)、メモリ管理(会話履歴の保持)を統一されたコード体系で記述できます。

import { Agent } from '@mastra/core/agent'
import { openai } from '@ai-sdk/openai'

const myAgent = new Agent({
  name: 'My Agent',
  instructions: 'あなたは...',
  model: openai('gpt-4.1'),
  tools: { ... }
})

セットアップ手順

# リポジトリをクローン
git clone https://github.com/evilmartians/mastra-coding-agent.git
cd mastra-coding-agent

# 依存関係をインストール
pnpm install

# 環境変数を設定
cp .env.example .env
# E2B_API_KEY=your-e2b-api-key
# OPENAI_API_KEY=your-openai-api-key

# 開発サーバーを起動
pnpm run dev

E2Bツールの実装

このプロジェクトの核心は、E2B操作をMastraのツールとして実装している部分です。

// src/mastra/tools/e2b.ts
import { createTool } from '@mastra/core/tools'
import z from 'zod'
import { Sandbox } from '@e2b/code-interpreter'

export const createSandbox = createTool({
  id: 'createSandbox',
  description: 'Create an e2b sandbox',
  inputSchema: z.object({
    metadata: z.record(z.string()).optional(),
    envs: z.record(z.string()).optional(),
    timeoutMS: z.number().optional()
  }),
  outputSchema: z.object({
    sandboxId: z.string()
  }).or(z.object({
    error: z.string()
  })),
  execute: async ({ context: sandboxOptions }) => {
    try {
      const sandbox = await Sandbox.create(sandboxOptions)
      return { sandboxId: sandbox.sandboxId }
    } catch (e) {
      return { error: JSON.stringify(e) }
    }
  }
})

Zodスキーマを使って入出力を定義しているのがポイントです。

実装されているツール

13個のE2Bツールが実装されています。e2b.ts

ツール 機能
createSandbox サンドボックスを作成
runCode Python/JavaScript/TypeScriptを実行
writeFile ファイルを書き込む
writeFiles 複数ファイルを一括で書き込む
readFile ファイルを読み込む
listFiles ディレクトリの内容を一覧表示
deleteFile ファイルを削除
createDirectory ディレクトリを作成
getFileInfo ファイルの詳細情報を取得
checkFileExists ファイルの存在を確認
getFileSize ファイルサイズを取得
watchDirectory ディレクトリの変更を監視
runCommand シェルコマンドを実行

エージェントの定義

これらのツールを使ってエージェントを定義します。

// src/mastra/agents/coding-agent.ts
import { Agent } from '@mastra/core/agent'
import { openai } from '@ai-sdk/openai'
import * as e2bTools from '../tools/e2b'

export const codingAgent = new Agent({
  name: 'Coding Agent',
  instructions: `
あなたはE2Bサンドボックスを使用するコーディングエージェントです。

## 開発ワークフロー
1. まずcreateSandboxでサンドボックスを作成
2. writeFileでコードを書く
3. runCodeまたはrunCommandで実行
4. 結果を確認して必要に応じて修正

## 言語サポート
- Python: runCodeでlanguage='python'を指定
- JavaScript: runCodeでlanguage='js'を指定
- TypeScript: runCodeでlanguage='ts'を指定
  `,
  model: openai('gpt-4.1'),
  tools: {
    createSandbox: e2bTools.createSandbox,
    runCode: e2bTools.runCode,
    readFile: e2bTools.readFile,
    writeFile: e2bTools.writeFile,
    writeFiles: e2bTools.writeFiles,
    listFiles: e2bTools.listFiles,
    deleteFile: e2bTools.deleteFile,
    createDirectory: e2bTools.createDirectory,
    getFileInfo: e2bTools.getFileInfo,
    checkFileExists: e2bTools.checkFileExists,
    getFileSize: e2bTools.getFileSize,
    watchDirectory: e2bTools.watchDirectory,
    runCommand: e2bTools.runCommand
  },
  defaultStreamOptions: { maxSteps: 20 }
})

メモリシステム

Mastraにはメモリシステムが組み込まれており、会話履歴の保持に加えて、セマンティック検索(キーワードの完全一致ではなく、意味的に関連する情報を見つける検索方式)を行えます。たとえば「ファイル作成」と入力すると、過去の会話から「新しいファイルを生成した」という表現も関連情報として取得できます。

import { Memory } from '@mastra/memory'
import { LibSQLStore, LibSQLVector } from '@mastra/libsql'
import { fastembed } from '@mastra/fastembed'

const memory = new Memory({
  storage: new LibSQLStore({ url: 'file:../../mastra.db' }),
  options: {
    threads: { generateTitle: true },
    semanticRecall: true,
    workingMemory: { enabled: true }
  },
  embedder: fastembed,
  vector: new LibSQLVector({ connectionUrl: 'file:../../mastra.db' })
})

これにより、エージェントは過去の会話を参照しながらタスクを実行できます。「さっき作ったファイルを修正して」のような指示も理解できるようになるわけです。

使用例

import { codingAgent } from './src/mastra/agents/coding-agent'

const response = await codingAgent.run({
  messages: [
    {
      role: 'user',
      content: 'Pythonで素数を判定する関数を作って、100以下の素数を全て出力して'
    }
  ]
})

// エージェントの内部動作:
// 1. createSandbox() → sandboxId取得
// 2. writeFile('/app/primes.py', '...') → コード作成
// 3. runCode(code, { language: 'python' }) → 実行
// 4. 結果をユーザーに返す

E2Bサンドボックスのファイルを永続化する

ここまでの説明で、E2Bサンドボックスの便利さは伝わったと思います。ただ、一つ気になる点があるのではないでしょうか。「サンドボックスが消えたら、ファイルも消えるの?」という疑問です。

答えはYesです。デフォルトでは、サンドボックスを削除(kill)するとファイルも消えます。しかし、ローカルPCのようにファイルを永続化する方法がいくつか用意されています。

方法1: Pause/Resume機能(ベータ版)

E2Bのドキュメントによると、サンドボックスを「一時停止」して、ファイルシステムとメモリ状態をまるごと保存できます。

┌────────────────────┐   betaPause()   ┌────────────────────┐
│ E2B サンドボックス  │ ────────────→  │ 状態を保存          │
│ - ファイル         │                 │ (最大30日間保持)    │
│ - メモリ           │                 │                    │
│ - 実行中プロセス    │ ←────────────  │                    │
└────────────────────┘    connect()    └────────────────────┘
import { Sandbox } from '@e2b/code-interpreter'

// 自動一時停止を有効にしてサンドボックス作成
const sandbox = await Sandbox.betaCreate({ autoPause: true })

// 作業...

// 手動で一時停止(ファイルもメモリもプロセスも保存される)
await sandbox.betaPause()

// 後日、再開(前回の状態がそのまま復元)
const resumedSandbox = await Sandbox.connect(sandboxId)

JS/TSでは@e2b/code-interpreterを使います。E2B Code Interpreter Quickstart
便利な機能ですが、いくつか制限があります。最大30日間の保持期限があること、pauseに1GiBあたり約4秒かかること、resumeに約1秒かかること、resume時のtimeoutがデフォルト5分に戻ること、非アクティブ10分で自動停止することが挙げられます。E2B Sandbox Persistence
また、複数回のresume後にファイルが消えるバグが報告されています。ベータ版なので、今後改善されることを期待しましょう。

方法2: クラウドバケット連携(S3/GCS/R2)

より堅牢な永続化が必要なら、クラウドバケットをマウントする方法があります。S3、Google Cloud Storage、Cloudflare R2をFUSEプロトコルでサンドボックスにマウントできます。

┌────────────────────┐                  ┌────────────────────┐
│ E2B サンドボックス  │  ←── FUSE ──→   │ Amazon S3          │
│                    │                  │ (永続ストレージ)    │
│ /home/user/bucket/ │ = 実質ローカル   │                    │
└────────────────────┘                  └────────────────────┘
       ↑                                        ↑
   サンドボックスが消えても...          ファイルは残る!
const sandbox = await Sandbox.create('<s3fs入りテンプレート>')

// S3バケットをマウント
await sandbox.files.makeDir('/home/user/bucket')
await sandbox.files.write('/root/.passwd-s3fs',
  '<AWS_ACCESS_KEY_ID>:<AWS_SECRET_ACCESS_KEY>')
await sandbox.commands.run('sudo chmod 600 /root/.passwd-s3fs')
await sandbox.commands.run('sudo s3fs my-bucket /home/user/bucket')

// これ以降、/home/user/bucket への書き込みは S3 に永続化される
// サンドボックスが消えても、次回同じバケットをマウントすれば続きから作業可能

この方法なら、サンドボックスが消えてもファイルはクラウドストレージに残ります。新しいサンドボックスを作成して同じバケットをマウントすれば、前回の続きから作業できます。一番「ローカルPCっぽい」使い方ができる方法です。

複数ユーザーで使う場合

チームやSaaSで複数ユーザーがE2Bを使う場合はどうなるのでしょうか。E2Bのドキュメントによると、基本的な考え方は「ユーザーごと / セッションごとにサンドボックスを作成する」です。

ストレージもユーザーごとに分離したい場合は、S3バケット内でユーザーIDをプレフィックスとして使う方法が現実的です。

┌─────────────┐     ┌─────────────────────┐     ┌─────────────────────┐
│ ユーザーA   │ ──→ │ サンドボックスA     │ ──→ │ s3://bucket/user-a/ │
└─────────────┘     └─────────────────────┘     └─────────────────────┘

┌─────────────┐     ┌─────────────────────┐     ┌─────────────────────┐
│ ユーザーB   │ ──→ │ サンドボックスB     │ ──→ │ s3://bucket/user-b/ │
└─────────────┘     └─────────────────────┘     └─────────────────────┘

┌─────────────┐     ┌─────────────────────┐     ┌─────────────────────┐
│ ユーザーC   │ ──→ │ サンドボックスC     │ ──→ │ s3://bucket/user-c/ │
└─────────────┘     └─────────────────────┘     └─────────────────────┘
        ↓                    ↓                          ↓
   それぞれ独立      Firecracker microVMで       ストレージも分離
                     完全隔離

実装例を見てみましょう。サンドボックス作成時にユーザーIDを渡し、そのユーザー専用のS3パスをマウントします。

async function createUserSandbox(userId: string) {
  const sandbox = await Sandbox.create('<s3fs入りテンプレート>')

  // ユーザー専用のS3パスをマウント
  await sandbox.files.makeDir('/home/user/storage')
  await sandbox.files.write('/root/.passwd-s3fs',
    `${AWS_ACCESS_KEY_ID}:${AWS_SECRET_ACCESS_KEY}`)
  await sandbox.commands.run('sudo chmod 600 /root/.passwd-s3fs')

  // ユーザーIDをプレフィックスとして使用
  await sandbox.commands.run(
    `sudo s3fs my-bucket:/users/${userId} /home/user/storage`
  )

  return sandbox
}

// ユーザーAのサンドボックス → s3://my-bucket/users/user-a/ にマウント
// ユーザーBのサンドボックス → s3://my-bucket/users/user-b/ にマウント

各サンドボックスはFirecracker microVM(AWSが開発した軽量仮想マシン)で完全に隔離されているため、あるユーザーのサンドボックスで悪意のあるコードが実行されても、他のユーザーには影響しません。ストレージもユーザーごとに分離されているため、ユーザーAがユーザーBのファイルにアクセスすることはできません。

Hugging FaceのOpen R1では学習の1ステップあたり数百のサンドボックスを起動したと紹介されています。

同時実行数はプランによって異なります。

プラン 同時サンドボックス数 セッション時間
Hobby(無料) 20(Rate Limits) 最大1時間(Pricing)
Pro($150/月) 100(Pricing)〜1,100(Rate Limits) 最大24時間(Pricing)
Enterprise カスタム(Pricing) カスタム(Pricing)

セキュリティ要件に応じたストレージ分離

先ほどの例ではS3バケット内でプレフィックス(フォルダ)を分ける方法を紹介しましたが、より厳格なセキュリティ要件がある場合は、バケット自体を顧客ごとに分けることも可能です。

AWSのドキュメントによると、AWSアカウントあたりデフォルトで10,000バケット、申請すれば最大100万バケットまで作成できます。つまり、顧客ごとにバケットを自動作成する運用も技術的には可能です。

import { S3Client, CreateBucketCommand } from '@aws-sdk/client-s3'

async function createTenantBucketAndSandbox(tenantId: string) {
  const s3 = new S3Client({ region: 'ap-northeast-1' })

  // テナント専用バケットを作成
  const bucketName = `my-saas-tenant-${tenantId}`
  await s3.send(new CreateBucketCommand({
    Bucket: bucketName,
    CreateBucketConfiguration: { LocationConstraint: 'ap-northeast-1' }
  }))

  // そのバケットをE2Bサンドボックスにマウント
  const sandbox = await Sandbox.create('<s3fs入りテンプレート>')
  await sandbox.commands.run(`sudo s3fs ${bucketName} /home/user/storage`)

  return sandbox
}

ただし、AWSのマルチテナント設計パターンでは、スケーラビリティと運用コストの観点から、多くの場合「プレフィックス分離 + IAMポリシー」が推奨されています。

分離方式 メリット デメリット 向いているケース
プレフィックス分離 スケーラブル、管理が容易 バケット設定は共通 数千〜数万テナント
バケット分離 完全な隔離、テナント別暗号化キー 管理が複雑 厳格なコンプライアンス要件

エンタープライズ向けでより高度なセキュリティが必要な場合は、Token Vending Machine(テナントごとに一時的なアクセス権限を発行する仕組み)やテナント別の暗号化キーを組み合わせる構成も検討できます。

どの方法を選ぶべきか

ユースケース おすすめ方法
個人利用・短期作業 Pause/Resume
長期プロジェクト S3/GCSマウント
マルチテナントSaaS(標準) プレフィックス分離 + IAMポリシー
マルチテナントSaaS(厳格なコンプライアンス) バケット分離 + テナント別暗号化キー

実際のプロダクションでは、まずプレフィックス分離から始めて、コンプライアンス要件に応じてバケット分離に移行するのが現実的な進め方だと思います。


どのリポジトリを選ぶべきか

ここまで3つのリポジトリを紹介してきました。最後に、どのリポジトリを選ぶべきかをまとめておきます。

agent-sandbox-skillを選ぶべき場合

  • Claude Codeを普段から使っている
  • 設定に時間をかけたくない
  • フルスタックアプリを自動構築したい
  • ブラウザテストも自動化したい

claude-agent-serverを選ぶべき場合

  • WebアプリやSaaSにClaude機能を統合したい
  • リモートからアクセスしたい
  • 複数のクライアントから使いたい(ただし同時は1接続)
  • TypeScriptでクライアントを書きたい

mastra-coding-agentを選ぶべき場合

  • Mastraベースでエージェントを作りたい
  • OpenAIモデル前提でE2B実行を組み込みたい
  • LibSQLベースのメモリを使いたい

迷ったら

迷っている方には、まずagent-sandbox-skillから試してみることをおすすめしたいと思います。セットアップが最も簡単で、E2Bサンドボックスの力をすぐに体験できます。私自身もここから始めて、必要に応じて他のリポジトリを試していきました。最初の一歩としては、これが一番取っつきやすいのではないでしょうか。


まとめ

Claude CodeとE2Bサンドボックスを組み合わせることで、AIエージェントをリモートサーバー上で安全に運用できる基盤が手に入ります。これにより、開発チームでのAIエージェント共有、SaaSへの機能組み込み、CI/CDパイプラインへの統合といったユースケースが現実的になってきました。

個人で試すならagent-sandbox-skillが手軽ですし、本番サービスへの組み込みを検討しているならclaude-agent-serverやmastra-coding-agentが選択肢になります。E2Bの無料枠で十分に動作確認ができますので、まずは手を動かして試してみてください。

今回紹介した3つのリポジトリは、それぞれ異なるニーズに対応しています。

  • agent-sandbox-skillは、Claude Codeのスキルとして使う最も手軽な方法
  • claude-agent-serverは、WebSocket経由でリモートアクセスでき、SaaS統合に向いている
  • mastra-coding-agentは、MastraベースでE2B実行エージェントを組み立てられる

どのリポジトリを選んでも、E2Bサンドボックスの基本的な使い方は共通しています。サンドボックスを作成し、コードを書き、実行し、結果を確認する。このサイクルを理解していれば、自分のニーズに合ったリポジトリを選んで実装できるはずです。

リモートサーバーでAIエージェントを運用するニーズは、今後ますます高まっていくと思われます。E2Bのような隔離環境を活用することで、セキュリティを担保しながらAIエージェントの力を最大限に引き出せるようになりました。ぜひ実際に手を動かして、チームやサービスへの導入を検討してみてください。


参考リンク


About me

現在、市場調査やデスクリサーチの生成AIエージェントを作っています 仲間探し中 / Founder of AI Desk Research Agent @deskrex , https://deskrex.ai

ぜひお気軽にチャットしましょう!
https://x.com/ItaruTomita9779/status/1856471446614356395

お仕事のご相談は以下まで、AIエージェントの開発や研修、調査代行やビジネスコンサルなどの対応も可能です。

生成AIデスクリサーチサービス Deskrex | サービスページ

https://lp.deskrex.ai/

生成AIデスクリサーチエージェント Deskrex App | アプリケーションサイト

https://app.deskrex.ai/

DeskrexAIリサーチ | メディア

https://media.deskrex.ai/

株式会社Deskrex | 会社概要

https://www.deskrex.ai/

Deskrex | Xページ

https://x.com/deskrex

Deskrex テックブログ

Discussion