Cloudflare @cloudflare/computer 深度拆解：当 Cloudflare 决定「给每个 AI Agent 一台自己的电脑」——从 Dynamic Workers 到 SQLite 虚拟文件系统，一个开源库如何重新定义 Agent 执行基础设施

2026 年 8 月 3 日，Cloudflare 发布了 @cloudflare/computer 开源库的早期预览版。这个看似简单的 npm 包背后，隐藏着 Cloudflare 对「AI Agent 执行基础设施」的终极思考：不要为每个 Agent 开一个容器，而是给每个 Agent 一台轻量级的虚拟计算机。

引言：Agent 的「最后一公里」困境

2026 年，AI Agent 已经从论文走进了生产环境。但一个尴尬的现实是：大多数 Agent 框架只解决了「怎么想」的问题，却没有解决「怎么做」的问题。

一个编程类 Agent 的工作流是这样的：

读取源代码 → 理解需求 → 修改文件 → 运行测试 → 审查结果 → 继续修正

这个循环的核心是：Agent 需要一个可以读写文件、执行命令、保存状态的工作环境。 而这正是当前大多数 Agent 框架的短板。

行业主流方案是为 Agent 构建容器。容器提供隔离的 Linux 环境和各类工具，但问题在于：当你需要同时运行数亿到数十亿个 AI Agent 时，为每个 Agent 配置一个容器的模式面临严重的扩展性限制。

一个标准 Docker 容器启动需要 500ms-2s，占用 50-200MB 内存。如果一个 SaaS 平台有 100 万用户，每个用户都有一个 Agent 在后台运行，光是容器就需要 50TB 内存——这还不算 CPU 开销。

Cloudflare 的回答是：别开容器了，给 Agent 一台虚拟电脑。

第一章：从 Dynamic Workers 到 @cloudflare/computer

1.1 Dynamic Workers：Isolate 沙箱的先声

要理解 @cloudflare/computer，必须先回顾 Cloudflare 在 2026 年 4 月发布的 Dynamic Workers。

Dynamic Workers 的核心理念是：用 V8 Isolates 替代 Linux 容器，作为 AI Agent 代码执行的沙箱。

V8 Isolates 是 Google Chrome 使用的 JavaScript 引擎隔离单元。Cloudflare Workers 平台过去八年一直基于这项技术。与容器相比，Isolates 有三个关键优势：

Dynamic Workers 允许一个 Worker 在运行时通过动态指定的代码创建新 Worker，每个新 Worker 运行在独立的 Isolate 沙箱中。这意味着你可以为每个用户的请求按需创建新 Isolate，执行一段代码后立即销毁——无需预热容器池，无需复用容器。

但 Dynamic Workers 只解决了一半问题：代码执行有了，文件系统呢？

1.2 @cloudflare/computer：补齐最后一块拼图

Dynamic Workers 提供了安全的代码执行沙箱，但 Agent 还需要：

• 持久化的文件系统：读取源代码、写入修改后的文件、保存中间状态
• 命令执行环境：运行 npm install、git commit、pytest 等工具
• 权限控制：限制 Agent 可以执行的操作，防止意外破坏
• 审计追踪：记录 Agent 的每一步操作，方便事后复核

@cloudflare/computer 就是为了补齐这些能力而生的。它以 Dynamic Workers 为基础，围绕**工作区（Workspace）**构建，使用 SQLite 支持虚拟文件系统。

第二章：架构深度解析

2.1 工作区（Workspace）：Agent 的「桌面」

@cloudflare/computer 的核心抽象是工作区。每个 Agent 获得一个独立的工作区，包含：

workspace/
├── files/          # SQLite 虚拟文件系统
├── metadata.json   # 工作区元信息
├── permissions.json # 权限配置
└── audit.log       # 操作审计日志

工作区的底层使用 SQLite 作为文件系统的存储引擎。这个选择非常精妙——SQLite 是世界上部署最广泛的数据库，单文件、零配置、事务安全，天然适合作为虚拟文件系统的后端。

工作区提供五个核心工具，全部兼容 AI SDK 标准：

// AI SDK 兼容的工具接口
interface WorkspaceTools {
  read(path: string): Promise<string>;      // 读取文件
  write(path: string, content: string): Promise<void>;  // 写入文件
  edit(path: string, oldText: string, newText: string): Promise<void>;  // 精确编辑
  ls(path: string): Promise<string[]>;      // 列出目录内容
  exec(command: string): Promise<ExecResult>;  // 执行命令
}

这意味着任何支持 AI SDK 的 Agent 框架（如 Vercel AI SDK、LangChain.js）都可以直接使用这些工具，无需额外适配。

2.2 双执行后端：Isolate 与 Container 的智能路由

@cloudflare/computer 最精妙的设计在于它的双执行后端架构。系统根据任务类型自动选择最佳执行环境：

后端一：Isolate 执行环境

基于 Dynamic Workers 的 V8 Isolates，通过 just-bash（Shell 转 JavaScript 工具）把 Shell 代码转换为 JavaScript，在动态 Worker 中运行。

适合的场景：

• 文件读写和编辑
• 数据处理和转换
• Git 仓库操作（clone、commit、push）
• 轻量级脚本执行

// Isolate 后端示例：文件处理
const workspace = await Computer.create({
  backend: 'isolate',
  import: { type: 'git', url: 'https://github.com/user/repo' }
});

// 读取文件（在 Isolate 中执行）
const code = await workspace.read('src/index.ts');

// 修改文件
await workspace.edit('src/index.ts', 
  'console.log("hello")',
  'console.log("hello world")'
);

// 轻量级命令（转为 JS 执行）
await workspace.exec('git diff');

后端二：Container 执行环境

借助 Cloudflare Containers 提供完整 Linux 环境，并通过 FUSE（用户态文件系统）挂载同步文件。

适合的场景：

• 运行 npm install / yarn add
• 执行原生二进制文件
• 运行测试套件（pytest、jest、cargo test）
• 需要完整 Linux 工具链的任务

// Container 后端示例：完整 Linux 环境
const workspace = await Computer.create({
  backend: 'container',
  image: 'node:20-slim',
  import: { type: 'git', url: 'https://github.com/user/repo' }
});

// 安装依赖（需要完整 Node.js 环境）
await workspace.exec('npm install');

// 运行测试
const result = await workspace.exec('npm test');
console.log(result.stdout);

// 编译原生模块
await workspace.exec('cargo build --release');

智能路由机制

当 Agent 执行命令时，AI 模型会依据工具描述自动选择适合的执行环境。系统内置了一套路由规则：

// 内置路由规则
const routingRules = [
  // 轻量任务 → Isolate
  { pattern: /^(read|write|edit|ls|cat|head|tail)/, backend: 'isolate' },
  { pattern: /^git (diff|log|status|add|commit)/, backend: 'isolate' },
  { pattern: /^grep|^find|^sort|^uniq/, backend: 'isolate' },
  
  // 重负载任务 → Container
  { pattern: /^npm (install|run|test)/, backend: 'container' },
  { pattern: /^cargo (build|test|run)/, backend: 'container' },
  { pattern: /^python (pip|pytest|setup)/, backend: 'container' },
  { pattern: /^docker/, backend: 'container' },
];

关键设计：无论任务在哪个环境执行，均使用同一组工作区文件，文件变更会自动同步。 这意味着 Agent 在 Isolate 中编辑的文件，可以立即在 Container 中被测试命令访问到。

2.3 权限与审计：Agent 的「安全围栏」

给 Agent 一台电脑是一回事，让它不搞破坏是另一回事。@cloudflare/computer 提供了细粒度的权限控制和完整的审计追踪。

权限配置

// permissions.json
{
  "read": {
    "allowed": true,
    "paths": ["src/**", "tests/**", "docs/**"],
    "denied": [".env", "*.key", "*.pem"]
  },
  "write": {
    "allowed": true,
    "paths": ["src/**", "tests/**"],
    "denied": ["package.json", "package-lock.json"]
  },
  "exec": {
    "allowed": true,
    "commands": ["npm test", "git diff", "git status"],
    "denied": ["rm -rf", "sudo", "chmod 777"]
  }
}

审计日志

每次操作都会被记录到审计日志中：

{
  "timestamp": "2026-08-03T10:30:00Z",
  "agent_id": "agent-abc-123",
  "action": "edit",
  "path": "src/index.ts",
  "old_text": "function hello()",
  "new_text": "function greet()",
  "backend": "isolate",
  "success": true
}

这种设计解决了 Agent 自主操作中的一个核心矛盾：既要给 Agent 足够的自由度来完成任务，又要确保它不会意外删除关键文件或执行危险命令。

2.4 从云存储、Git 仓库或自定义文件导入内容

@cloudflare/computer 支持三种方式导入初始工作区内容：

方式一：Git 仓库

const workspace = await Computer.create({
  import: { 
    type: 'git', 
    url: 'https://github.com/user/repo',
    branch: 'main',
    token: process.env.GITHUB_TOKEN  // 可选：私有仓库
  }
});

方式二：云存储（R2/S3）

const workspace = await Computer.create({
  import: {
    type: 'r2',
    bucket: 'my-agent-workspaces',
    key: 'templates/web-app.zip'
  }
});

方式三：自定义文件

const workspace = await Computer.create({
  import: {
    type: 'files',
    files: {
      'src/index.ts': 'console.log("hello")',
      'tests/index.test.ts': 'import { test } from "vitest"',
      'package.json': '{"name": "my-app"}'
    }
  }
});

第三章：代码实战——构建一个完整的代码审查 Agent

让我们用 @cloudflare/computer 构建一个真实的代码审查 Agent。这个 Agent 会自动拉取 PR、分析代码、运行测试、生成审查报告。

3.1 基础设置

import { Computer } from '@cloudflare/computer';
import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

// 创建 Agent 工作区
async function createReviewWorkspace(repoUrl: string, prBranch: string) {
  const workspace = await Computer.create({
    backend: 'container',  // 需要运行测试
    image: 'node:20-slim',
    import: {
      type: 'git',
      url: repoUrl,
      branch: prBranch
    },
    permissions: {
      read: { allowed: true, paths: ['**/*'] },
      write: { 
        allowed: true, 
        paths: ['review-report.md'],  // 只允许写入报告文件
        denied: ['src/**', 'tests/**']
      },
      exec: {
        allowed: true,
        commands: ['npm install', 'npm test', 'npm run lint', 'git diff main']
      }
    }
  });
  
  return workspace;
}

3.2 代码分析流程

async function reviewCode(workspace: any) {
  // Step 1: 获取变更文件列表
  const diffOutput = await workspace.exec('git diff main --stat');
  
  // Step 2: 获取详细 diff
  const fullDiff = await workspace.exec('git diff main');
  
  // Step 3: 获取项目配置（了解技术栈）
  const packageJson = await workspace.read('package.json');
  
  // Step 4: AI 分析代码
  const analysis = await generateText({
    model: openai('gpt-4o'),
    prompt: `你是一位资深代码审查专家。请分析以下代码变更：

## 项目配置
${packageJson}

## 变更统计
${diffOutput.stdout}

## 完整 Diff
${fullDiff.stdout}

请从以下维度进行审查：
1. 代码质量和可读性
2. 潜在 Bug 和边界情况
3. 性能问题
4. 安全隐患
5. 测试覆盖率

输出格式：Markdown，每个维度给出具体的改进建议。`
  });
  
  return analysis.text;
}

3.3 运行测试并生成报告

async function runTestsAndReport(workspace: any, analysis: string) {
  // 安装依赖
  await workspace.exec('npm install');
  
  // 运行测试
  const testResult = await workspace.exec('npm test 2>&1 || true');
  
  // 运行 lint
  const lintResult = await workspace.exec('npm run lint 2>&1 || true');
  
  // 生成最终报告
  const report = `# Code Review Report

## AI 分析结果
${analysis}

## 测试结果
\`\`\`
${testResult.stdout}
\`\`\`

## Lint 结果
\`\`\`
${lintResult.stdout}
\`\`\`

## 总结
${testResult.exitCode === 0 ? '✅ 测试全部通过' : '❌ 存在测试失败'}
${lintResult.exitCode === 0 ? '✅ Lint 检查通过' : '⚠️ Lint 存在警告'}
`;

  // 写入报告文件
  await workspace.write('review-report.md', report);
  
  return report;
}

3.4 完整的 Agent 循环

async function codeReviewAgent(repoUrl: string, prBranch: string) {
  // 创建工作区
  const workspace = await createReviewWorkspace(repoUrl, prBranch);
  
  try {
    // 执行代码审查
    const analysis = await reviewCode(workspace);
    
    // 运行测试并生成报告
    const report = await runTestsAndReport(workspace, analysis);
    
    // 获取审计日志
    const auditLog = await workspace.getAuditLog();
    console.log(`审计日志：${auditLog.length} 条操作记录`);
    
    return report;
  } finally {
    // 清理工作区
    await workspace.destroy();
  }
}

// 使用示例
const report = await codeReviewAgent(
  'https://github.com/user/project',
  'feature/new-api'
);

第四章：与竞品架构对比

4.1 沙箱技术路线之争

2026 年的 AI Agent 沙箱市场呈现出明显的技术路线分化：

4.2 Cloudflare 的独特优势

Cloudflare 选择 V8 Isolates 路线的核心逻辑是：面向 Web 的高并发 Agent 工作负载，更适合与请求一致的临时执行层。

这意味着：

1. 不需要持久化运行时：Agent 完成任务后立即销毁，无需保持容器热备
2. 极致的启动速度：毫秒级启动意味着可以按需创建，无需预热池
3. 全球分布式：运行在 Cloudflare 的 330+ 数据中心，天然低延迟
4. 成本优势：Isolate 的资源消耗远低于容器，适合大规模部署

但 Cloudflare 也坦承，Isolate 相比硬件虚拟机存在更复杂的攻击面。其防护策略包括：

• 数小时内将 V8 安全补丁自动部署至生产环境
• 自定义二级沙箱 + 动态风险租户隔离
• MPK（Memory Protection Keys）硬件级防护
• 与学术研究者合作研发的新型 Spectre 防御方案

4.3 与 Claude Code / Codex 的对比

目前主流的 AI 编码助手（如 Claude Code、OpenAI Codex）通常使用以下方式提供执行环境：

@cloudflare/computer 的核心差异在于：它不是一个本地开发工具，而是一个面向生产的 Agent 执行基础设施。 你可以用它来构建一个 SaaS 产品，让 100 万用户的 Agent 同时在 Cloudflare 边缘网络上执行代码。

第五章：深入 SQLite 虚拟文件系统

5.1 为什么选择 SQLite？

@cloudflare/computer 使用 SQLite 作为虚拟文件系统的存储引擎，这个选择背后有多层考量：

事务安全性：SQLite 支持完整的 ACID 事务。当 Agent 在编辑文件时如果发生崩溃，文件系统可以回滚到一致状态，不会出现半写入的损坏文件。

零配置部署：SQLite 是一个单文件数据库，无需安装、无需配置、无需网络连接。这完美适配了 Isolate 的临时性——创建 Isolate 时直接加载 SQLite 文件，销毁时直接丢弃。

高效的随机读写：Agent 的文件操作模式是典型的随机读写——读取一个文件、修改几行、写回。SQLite 的 B-tree 索引结构天然适合这种访问模式。

可移植性：SQLite 数据库是一个普通的文件，可以轻松地在 Isolate 和 Container 之间迁移，也可以备份到 R2 等对象存储。

5.2 虚拟文件系统实现

// @cloudflare/computer 内部的 SQLite 虚拟文件系统简化实现
import { SQLite } from 'workers-sqlite';

class VirtualFileSystem {
  private db: SQLite;
  
  constructor() {
    this.db = new SQLite();
    this.db.exec(`
      CREATE TABLE IF NOT EXISTS files (
        path TEXT PRIMARY KEY,
        content BLOB,
        size INTEGER,
        created_at INTEGER,
        modified_at INTEGER,
        mode INTEGER DEFAULT 0644
      );
      
      CREATE TABLE IF NOT EXISTS directories (
        path TEXT PRIMARY KEY,
        created_at INTEGER
      );
      
      CREATE INDEX IF NOT EXISTS idx_files_parent 
        ON files(path) WHERE path LIKE '%/%';
    `);
  }
  
  // 读取文件
  async read(path: string): Promise<string> {
    const stmt = this.db.prepare(
      'SELECT content FROM files WHERE path = ?'
    );
    const row = stmt.get(path);
    if (!row) throw new Error(`File not found: ${path}`);
    return new TextDecoder().decode(row.content);
  }
  
  // 写入文件（事务安全）
  async write(path: string, content: string): Promise<void> {
    const contentBytes = new TextEncoder().encode(content);
    const now = Date.now();
    
    this.db.exec('BEGIN TRANSACTION');
    try {
      // 自动创建父目录
      const dir = path.substring(0, path.lastIndexOf('/'));
      if (dir) {
        this.db.prepare(
          'INSERT OR IGNORE INTO directories (path, created_at) VALUES (?, ?)'
        ).run(dir, now);
      }
      
      // 写入文件
      this.db.prepare(`
        INSERT INTO files (path, content, size, created_at, modified_at)
        VALUES (?, ?, ?, ?, ?)
        ON CONFLICT(path) DO UPDATE SET
          content = excluded.content,
          size = excluded.size,
          modified_at = excluded.modified_at
      `).run(path, contentBytes, contentBytes.length, now, now);
      
      this.db.exec('COMMIT');
    } catch (e) {
      this.db.exec('ROLLBACK');
      throw e;
    }
  }
  
  // 精确编辑（只修改差异部分）
  async edit(path: string, oldText: string, newText: string): Promise<void> {
    const content = await this.read(path);
    if (!content.includes(oldText)) {
      throw new Error(`Text not found in ${path}`);
    }
    const updated = content.replace(oldText, newText);
    await this.write(path, updated);
  }
  
  // 列出目录
  async ls(path: string): Promise<string[]> {
    const prefix = path.endsWith('/') ? path : path + '/';
    const stmt = this.db.prepare(
      "SELECT path FROM files WHERE path LIKE ? || '%'"
    );
    return stmt.all(prefix).map((row: any) => {
      const relative = row.path.substring(prefix.length);
      return relative.split('/')[0];
    });
  }
}

5.3 与 R2 的持久化同步

工作区的 SQLite 数据库可以定期同步到 Cloudflare R2 对象存储，实现持久化：

// 工作区快照同步
async function snapshotWorkspace(workspace: any) {
  const dbPath = workspace.getDbPath();
  const dbContent = await workspace.readBinary(dbPath);
  
  // 上传到 R2
  await env.R2.put(
    `workspaces/${workspace.id}/snapshot.db`,
    dbContent,
    {
      httpMetadata: {
        contentType: 'application/x-sqlite3'
      }
    }
  );
}

// 恢复工作区
async function restoreWorkspace(env: any, workspaceId: string) {
  const obj = await env.R2.get(`workspaces/${workspaceId}/snapshot.db`);
  if (!obj) throw new Error('Workspace snapshot not found');
  
  const workspace = await Computer.create({
    backend: 'isolate',
    import: {
      type: 'sqlite',
      data: await obj.arrayBuffer()
    }
  });
  
  return workspace;
}

第六章：性能基准与成本分析

6.1 性能基准

基于公开数据和社区测试，@cloudflare/computer 的性能表现如下：

6.2 成本模型

// 成本计算示例
const costAnalysis = {
  // 假设场景：100 万用户，每个用户每天平均 10 次 Agent 交互
  users: 1_000_000,
  interactionsPerUserPerDay: 10,
  totalInteractionsPerDay: 10_000_000,
  
  // Dynamic Workers 定价
  dynamicWorkerCost: 0.002, // 每个加载的 Worker $0.002/天
  
  // Workers CPU 定价（假设每次交互平均 100ms CPU 时间）
  cpuCostPerMs: 0.000012, // $0.000012 / ms
  
  // 计算
  dailyWorkerCost: 10_000_000 * 0.002,  // $20,000/天
  dailyCpuCost: 10_000_000 * 100 * 0.000012, // $12,000/天
  totalDailyCost: 32_000,  // $32,000/天
  totalMonthlyCost: 960_000, // $960,000/月
  
  // 对比：使用容器
  containerMonthlyCost: '~$5,000,000/月（100万容器 × $5/月）',
};

即使在大规模部署场景下，@cloudflare/computer 的成本也远低于传统容器方案。更重要的是，它消除了容器池管理、预热、扩缩容等运维复杂度。

第七章：实战场景与最佳实践

7.1 场景一：在线代码编辑器

构建一个类似 CodeSandbox 的在线代码编辑器，但基于 Agent 驱动：

// 用户说 "帮我实现一个 TODO 应用"
// Agent 自动创建工作区、编写代码、运行预览

async function aiCodeEditor(userRequest: string) {
  const workspace = await Computer.create({
    backend: 'container',
    image: 'node:20-slim'
  });
  
  // Agent 根据用户需求生成代码
  const code = await generateCode(userRequest);
  
  // 写入项目文件
  await workspace.write('package.json', code.packageJson);
  await workspace.write('src/index.ts', code.main);
  await workspace.write('src/index.html', code.html);
  
  // 安装依赖
  await workspace.exec('npm install');
  
  // 启动开发服务器
  await workspace.exec('npm run dev &');
  
  // 获取预览 URL
  const previewUrl = workspace.getPreviewUrl();
  
  return { previewUrl, workspaceId: workspace.id };
}

7.2 场景二：自动化测试平台

// 接收 GitHub PR webhook，自动运行测试并评论

async function autoTestPR(prData: any) {
  const workspace = await Computer.create({
    backend: 'container',
    image: 'node:20-slim',
    import: {
      type: 'git',
      url: prData.repository.clone_url,
      ref: prData.head.ref
    }
  });
  
  try {
    // 安装依赖
    await workspace.exec('npm ci');
    
    // 运行所有测试
    const testResult = await workspace.exec('npm test 2>&1');
    
    // 运行类型检查
    const typeCheck = await workspace.exec('npx tsc --noEmit 2>&1');
    
    // 生成测试报告
    const report = formatTestReport(testResult, typeCheck);
    
    // 通过 GitHub API 评论到 PR
    await commentOnPR(prData.number, report);
    
  } finally {
    await workspace.destroy();
  }
}

7.3 场景三：数据管道 ETL

// 数据转换管道：读取 → 清洗 → 转换 → 写入

async function etlPipeline(config: any) {
  const workspace = await Computer.create({
    backend: 'isolate',  // 纯文件操作，用 Isolate 即可
    import: { type: 'r2', ...config.source }
  });
  
  // 读取原始数据
  const rawData = await workspace.read('data/raw.json');
  
  // AI 辅助数据清洗
  const cleanData = await generateText({
    model: openai('gpt-4o'),
    prompt: `清洗以下数据：${rawData}\n输出 JSON 格式的清洗结果。`
  });
  
  // 写入清洗后的数据
  await workspace.write('data/clean.json', cleanData.text);
  
  // 执行转换脚本
  await workspace.exec('node transform.js');
  
  // 读取转换结果并上传
  const result = await workspace.read('data/output.json');
  await uploadToR2(config.destination, result);
  
  await workspace.destroy();
}

第八章：局限性与未来展望

8.1 当前局限

1. 语言限制：Isolate 后端仅支持 JavaScript/TypeScript。虽然 Workers 理论上支持 Python 和 WebAssembly，但 JavaScript 因加载速度更快，成为按需执行的实用选择。

2. 安全权衡：V8 Isolate 的攻击面比硬件虚拟机更复杂。Cloudflare 通过多层防护缓解，但高安全场景仍需考虑 MicroVM 方案。

3. 持久化成本：工作区的 SQLite 数据需要定期同步到 R2，这会产生额外的存储和网络成本。

4. 早期预览阶段：目前 @cloudflare/computer 仍处于早期预览版，API 可能发生变化。

8.2 未来展望

Cloudflare 正在构建一个完整的 Agent 基础设施生态：

• @cloudflare/computer：Agent 的执行环境
• @cloudflare/codemode：AI 工具生成代码的运行
• @cloudflare/worker-bundler：运行时 npm 依赖解析与打包
• @cloudflare/shell：虚拟文件系统和命令执行
• Dynamic Workers：Isolate 沙箱
• Cloudflare Containers：完整 Linux 环境

这些组件共同构成了一个面向 Agent 时代的云基础设施。Cloudflare 的赌注是：未来大多数 AI Agent 的执行环境，不会在开发者的笔记本上，也不会在传统的云服务器上，而是运行在全球边缘网络的轻量级沙箱中。

总结

@cloudflare/computer 不只是一个开源库，它是 Cloudflare 对「AI Agent 执行基础设施」的一次系统性回答。从 Dynamic Workers 的 Isolate 沙箱，到 SQLite 虚拟文件系统，到双执行后端的智能路由，再到权限控制和审计追踪——每一个设计决策都在回答同一个问题：如何在保证安全和性能的前提下，为数十亿 Agent 提供可靠的执行环境？

对于开发者而言，@cloudflare/computer 带来的最大价值是：你不再需要自己搭建和维护 Agent 的执行环境。 几行代码就能为你的 Agent 创建一个安全、隔离、可持久化的工作区，而底层的扩展性、安全性和全球分布式部署，全部由 Cloudflare 处理。

Agent 时代已经到来。而 @cloudflare/computer 正在为这个时代铺设基础设施。

本文基于 Cloudflare 2026 年 8 月 3 日发布的 @cloudflare/computer 早期预览版撰写。文中涉及的性能数据和定价信息可能随产品迭代而变化。