diff --git a/.changeset/exec-tool-options.md b/.changeset/exec-tool-options.md
new file mode 100644
index 00000000..6dd792bd
--- /dev/null
+++ b/.changeset/exec-tool-options.md
@@ -0,0 +1,11 @@
+---
+"@cloudflare/computer": minor
+---
+
+`createAITools` takes an `exec` option that lists the backends the model can use, keyed by backend id: `exec: { "worker-javascript": { description: "Use for data work." } }`. Leave it out to use every backend the Workspace has. `{}` exposes a backend with nothing beyond its own description, and `exec: {}` means no exec tool. `createExecTool` takes the same map as `backends`, and `defaultBackend` goes away: with more than one backend the model must name one on every call.
+
+`WorkerShellBackend` and `CloudflareContainerBackend` now describe themselves to the model, as `WorkerJavaScriptBackend` does, so the default needs no descriptions. A backend that says nothing gets a one-line default instead of an error.
+
+`shell` still works and is deprecated. `shell: { backends }` becomes `exec: backends`, and its `defaultBackend` is ignored. Output limits stay on `createExecTool`.
+
+`createAITools` moves to its own entry point, `@cloudflare/computer/tools/ai-sdk`. `@cloudflare/computer/tools` keeps the individual `create*Tool` functions and `WorkspaceFileStore`. Change `import { createAITools } from "@cloudflare/computer/tools"` to `from "@cloudflare/computer/tools/ai-sdk"`.
diff --git a/.changeset/exec-tool-single-backend.md b/.changeset/exec-tool-single-backend.md
index 701465bc..a524ec8d 100644
--- a/.changeset/exec-tool-single-backend.md
+++ b/.changeset/exec-tool-single-backend.md
@@ -2,6 +2,6 @@
 "@cloudflare/computer": minor
 ---
 
-The `exec` tool offers only the arguments that can work. With one backend there is no `backend` argument, the tool always runs there, `defaultBackend` becomes optional, and the description talks about what that backend does rather than how to choose one. `input` appears only when a configured backend accepts it.
+The `exec` tool offers only the arguments that can work. With one backend there is no `backend` argument, the tool always runs there, and the description talks about what that backend does rather than how to choose one. `input` appears only when a configured backend accepts it.
 
-Each backend's entry now adds what the backend says about itself, read through `workspace.runtime.describe(id)`. For `WorkerJavaScriptBackend` that is its source language and every module code can import, so `shell: { backends: { "worker-javascript": {} } }` is enough and the module list the model reads cannot drift from `modules`. A backend `description` is required only for a backend that does not describe itself.
+Each backend's entry now adds what the backend says about itself, read through `workspace.runtime.describe(id)`. For `WorkerJavaScriptBackend` that is its source language and every module code can import, so the module list the model reads cannot drift from `modules`.
diff --git a/docs/09_tool_interface.md b/docs/09_tool_interface.md
index 181a2ba7..6a9543a7 100644
--- a/docs/09_tool_interface.md
+++ b/docs/09_tool_interface.md
@@ -1,11 +1,11 @@
 # 09. Tool interface (agents)
 
-`@cloudflare/computer/tools` ships ready-made [AI SDK](https://github.com/vercel/ai) tools for agents that use a `Workspace`.
+`@cloudflare/computer/tools/ai-sdk` ships `createAITools()`, a ready-made [AI SDK](https://github.com/vercel/ai) tool set for agents that use a `Workspace`. The individual `create*Tool` functions and `WorkspaceFileStore` come from `@cloudflare/computer/tools`.
 
 The tools wrap three Workspace surfaces:
 
 - `workspace.fs` for file reads, writes, edits, searches, listings, and deletion;
-- `workspace.runtime.exec` for command execution when the caller opts in;
+- `workspace.runtime.exec` for running commands and code on the Workspace's backends;
 - `workspace.assets` for publishing generated files when an assets publisher is configured.
 
 ## What ships
@@ -24,13 +24,13 @@ The tools wrap three Workspace surfaces:
 | `createPublishTool` | Publish a workspace file through `workspace.assets`. |
 | `WorkspaceFileStore` | Adapt `workspace.fs` to the store used by file tools. |
 
-`createAITools()` always names its tools `read`, `ls`, `find`, `grep`, `write`, `edit`, and `delete`. `exec` appears when the caller supplies `shell` options. `publish` appears when assets are configured. In read-only mode the set is `read`, `ls`, `find`, and `grep`.
+`createAITools()` always names its tools `read`, `ls`, `find`, `grep`, `write`, `edit`, and `delete`. `exec` appears when the Workspace has a backend, unless you pass `exec: {}`. `publish` appears when assets are configured. In read-only mode the set is `read`, `ls`, `find`, and `grep`.
 
 ## Wiring up
 
 ```ts
 import { Workspace } from "@cloudflare/computer";
-import { createAITools } from "@cloudflare/computer/tools";
+import { createAITools } from "@cloudflare/computer/tools/ai-sdk";
 
 export class Agent {
   workspace: Workspace;
@@ -55,29 +55,18 @@ export class Agent {
 
 Pass the returned AI SDK `ToolSet` to `generateText`, `streamText`, or an agent framework hook such as `getTools()`.
 
-Pass `shell` only when the Workspace has matching backend ids. With one backend, `exec` has no `backend` argument and always runs there:
+`exec` lists the backends the model can use, keyed by backend id. Leave it out to use every backend.
 
 ```ts
-const tools = createAITools({
+createAITools({ workspace });                                                       // every backend
+createAITools({ workspace, exec: { "worker-javascript": {} } });                     // just this one
+createAITools({
   workspace,
-  shell: { backends: { "worker-javascript": {} } },
+  exec: { "worker-javascript": { description: "Use for data work." } },             // with your own text
 });
 ```
 
-With more than one, pass `defaultBackend` and the model picks a backend per call:
-
-```ts
-const tools = createAITools({
-  workspace,
-  shell: {
-    defaultBackend: "shell",
-    backends: {
-      shell: { description: "Fast Worker shell with built-in text commands." },
-      container: { description: "Full Linux userland in a Cloudflare Container." },
-    },
-  },
-});
-```
+Each backend describes itself, and a `description` you pass comes first. `exec: {}` means no exec tool. With one backend, `exec` has no `backend` argument and always runs there. With several, the model must name a backend on every call; there is no default.
 
 ## `createAITools`
 
@@ -89,7 +78,7 @@ createAITools({
   read?,
   write?,
   edit?,
-  shell?,
+  exec?,
 });
 ```
 
@@ -101,7 +90,8 @@ createAITools({
 | `read` | default caps | Options passed to `createReadTool`. |
 | `write` | default caps | Options passed to `createWriteTool`. |
 | `edit` | default caps | Options passed to `createEditTool`. |
-| `shell` | omitted | Options passed to `createExecTool`. |
+| `exec` | every backend | Backend id to `{ description? }`. `{}` omits `exec`. |
+| `shell` | omitted | Deprecated. `{ backends }` becomes `exec: backends`; `defaultBackend` is ignored. |
 
 ## `read`
 
@@ -253,9 +243,9 @@ The tool uses forced removal, so deleting a missing path succeeds. Set `recursiv
 
 ## `exec`
 
-`exec` is opt-in. It calls `workspace.runtime.exec` with the configured backend and streams bounded output.
+`exec` calls `workspace.runtime.exec` on the chosen backend and streams bounded output. `createExecTool({ workspace, backends?, maxBytes?, streamMaxBytes? })` takes the same `backends` as the `exec` option, plus output limits.
 
-Each backend's entry in the tool description joins two parts: the `description` you pass, and what the backend says about itself (`backend.description`, read through `workspace.runtime.describe(id)`). `WorkerJavaScriptBackend` describes its source language and every module code can import, so `{ "worker-javascript": {} }` is enough and the list stays in step with `modules`. A backend that does not describe itself needs a `description`. Describe capabilities and startup cost in plain language.
+Each backend's entry in the tool description joins two parts: your text, if any, and what the backend says about itself (`backend.description`, read through `workspace.runtime.describe(id)`). `WorkerJavaScriptBackend` describes its source language and every module code can import, so the list stays in step with `modules`. `WorkerShellBackend` and `CloudflareContainerBackend` describe their command sets and startup cost. A backend that says nothing gets a one-line default, so add text for a custom backend.
 
 The tool offers only the arguments that can work:
 
@@ -263,11 +253,11 @@ The tool offers only the arguments that can work:
 | --- | --- |
 | One shell backend | `command`, `cwd`, `env` |
 | One callable backend | `command`, `cwd`, `env`, `input` |
-| More than one | `command`, `cwd`, `backend`, `env`, plus `input` when any is callable. `defaultBackend` is required. |
+| More than one | `command`, `cwd`, `backend` (required), `env`, plus `input` when any is callable |
 
 A `backend` value the model sends anyway is dropped when only one backend is configured. The output still names the backend that ran.
 
-Wire this tool carefully: it executes arbitrary shell commands inside the configured backend. Treat its output as untrusted text when including it in later model input. Omit `shell` or use `readonly: true` when command execution is not part of the agent's job.
+Wire this tool carefully: it executes arbitrary shell commands inside the configured backend. Treat its output as untrusted text when including it in later model input. Pass `exec: {}` or `readonly: true` when command execution is not part of the agent's job, and list backends explicitly when the Workspace has one the model should not use directly.
 
 ## `publish`
 
diff --git a/docs/10_project_layout.md b/docs/10_project_layout.md
index 8718132f..eb558b43 100644
--- a/docs/10_project_layout.md
+++ b/docs/10_project_layout.md
@@ -175,9 +175,10 @@ produces the Node SEA single-file binary at
 
 ## Tools
 
-AI SDK tools (`read`, `write`, `edit`, `ls`, optional `exec`, and
-optional `publish`) ship from the `@cloudflare/computer/tools` subpath
-rather than a separate package, under
+AI SDK tools (`read`, `write`, `edit`, `ls`, `exec`, and optional
+`publish`) ship from the package rather than a separate one:
+`createAITools()` from `@cloudflare/computer/tools/ai-sdk`, and the
+individual `create*Tool` functions from `@cloudflare/computer/tools`. They live under
 [`packages/computer/src/tools/`](../packages/computer/src/tools/). See
 [09. Tool Interface (Agents)](./09_tool_interface.md).
 
diff --git a/docs/17_isolate_javascript.md b/docs/17_isolate_javascript.md
index 89a68ce4..6e3f351d 100644
--- a/docs/17_isolate_javascript.md
+++ b/docs/17_isolate_javascript.md
@@ -264,10 +264,8 @@ this.workspace = new Workspace({
   ],
 });
 
-const tools = createAITools({
-  workspace: this.workspace,
-  shell: { backends: { "worker-javascript": {} } },
-});
+// Offer only the JavaScript backend; the container is reached through ws:container.
+const tools = createAITools({ workspace: this.workspace, exec: { "worker-javascript": {} } });
 ```
 
 ```js
diff --git a/docs/README.md b/docs/README.md
index 29b0acbf..fca2cb88 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -22,7 +22,7 @@ It provides:
  - Pluggable execution backends selected through `workspace.runtime`: a Cloudflare Container shell, a just-bash Dynamic Worker, or an isolated ECMAScript-module Dynamic Worker.
  - Isolated JavaScript with structured input/results, durable relative imports, configured libraries, durable `node:fs/promises`, host modules such as `ws:git` and `ws:container`, and managed execution records.
  - Workspace constructable without a backend, for filesystem-only use cases.
- - Out-of-the-box AI SDK tools for `@cloudflare/agents` through `@cloudflare/computer/tools`.
+ - Out-of-the-box AI SDK tools for `@cloudflare/agents` through `createAITools()` in `@cloudflare/computer/tools/ai-sdk`.
 
 It comes with the following limitations:
 
@@ -52,6 +52,7 @@ The package ships several entrypoints:
 | `@cloudflare/computer/modules/git` | `createGitModule()` for `ws:git`: confined Git from isolate JavaScript. |
 | `@cloudflare/computer/modules/artifacts` | `createArtifactsModule()` for `ws:artifacts`: Artifacts from isolate JavaScript. |
 | `@cloudflare/computer/tools` | AI SDK tools for agents: read, write, edit, ls, optional exec, and optional publish. |
+| `@cloudflare/computer/tools/ai-sdk` | `createAITools()`: the AI SDK tool set for a Workspace. |
 
 A consumer that only uses the container backend never imports the
 worker subpath, so the just-bash payload tree-shakes away.
diff --git a/examples/celld/README.md b/examples/celld/README.md
index 7eec14a0..5d2d2220 100644
--- a/examples/celld/README.md
+++ b/examples/celld/README.md
@@ -128,7 +128,7 @@ the message or `CELLD_EXPECT` to use a different expected phrase.
 
 ## Workspace tools
 
-The agent receives these tools from `@cloudflare/computer/tools`:
+The agent receives these tools from `createAITools()` in `@cloudflare/computer/tools/ai-sdk`:
 
 | Tool | Purpose |
 | --- | --- |
diff --git a/examples/celld/src/index.ts b/examples/celld/src/index.ts
index fbcf24bd..ab9d23f1 100644
--- a/examples/celld/src/index.ts
+++ b/examples/celld/src/index.ts
@@ -5,7 +5,7 @@ import {
   type WorkspaceRuntimeLoader,
   withWorkspace,
 } from "@cloudflare/computer";
-import { createAITools } from "@cloudflare/computer/tools";
+import { createAITools } from "@cloudflare/computer/tools/ai-sdk";
 import { routeAgentRequest } from "agents";
 import { convertToModelMessages, isStepCount, streamText } from "ai";
 import { createWorkersAI } from "workers-ai-provider";
@@ -49,24 +49,21 @@ export class CelldAgent extends withWorkspace(CelldAgentBase, (self) => {
       assets: false,
       ...(this.bindings.LOADER
         ? {
-            shell: {
-              defaultBackend: CELLD_JAVASCRIPT_BACKEND_ID,
-              backends: {
-                [CELLD_JAVASCRIPT_BACKEND_ID]: {
-                  description: [
-                    "Runs a complete JavaScript module in a celld Dynamic Worker with structured input and output.",
-                    "Pass module source, not a filename or bare script. The module must have a default export. Export a function to receive `(input, ctx)` and return structured output.",
-                    "",
-                    "```js",
-                    "export default async function main(input, ctx) {",
-                    '  console.log("cwd:", ctx.cwd);',
-                    "  return { received: input };",
-                    "}",
-                    "```",
-                    "",
-                    "The loaded worker cannot access the Workspace filesystem. Use read, write, edit, ls, find, grep, and delete outside exec.",
-                  ].join("\n"),
-                },
+            exec: {
+              [CELLD_JAVASCRIPT_BACKEND_ID]: {
+                description: [
+                  "Runs a complete JavaScript module in a celld Dynamic Worker with structured input and output.",
+                  "Pass module source, not a filename or bare script. The module must have a default export. Export a function to receive `(input, ctx)` and return structured output.",
+                  "",
+                  "```js",
+                  "export default async function main(input, ctx) {",
+                  '  console.log("cwd:", ctx.cwd);',
+                  "  return { received: input };",
+                  "}",
+                  "```",
+                  "",
+                  "The loaded worker cannot access the Workspace filesystem. Use read, write, edit, ls, find, grep, and delete outside exec.",
+                ].join("\n"),
               },
             },
           }
diff --git a/examples/mcp/src/index.test.ts b/examples/mcp/src/index.test.ts
index 189e062e..57d4035c 100644
--- a/examples/mcp/src/index.test.ts
+++ b/examples/mcp/src/index.test.ts
@@ -85,8 +85,11 @@ describe("Computer Code Mode MCP", () => {
           });
           const file = await codemode.read({ path: "/workspace/message.txt" });
           const listing = await codemode.ls({ path: "/workspace" });
-          const shell = await codemode.exec({ command: "pwd" });
-          const git = await codemode.exec({ command: "git init && git status --short" });
+          const shell = await codemode.exec({ command: "pwd", backend: "worker-shell" });
+          const git = await codemode.exec({
+            command: "git init && git status --short",
+            backend: "worker-shell",
+          });
           return {
             content: file.content,
             listed: listing.entries.some((entry) => entry.name === "message.txt"),
diff --git a/examples/mcp/src/server.ts b/examples/mcp/src/server.ts
index 090275db..52774350 100644
--- a/examples/mcp/src/server.ts
+++ b/examples/mcp/src/server.ts
@@ -1,7 +1,7 @@
 import { DynamicWorkerExecutor } from "@cloudflare/codemode";
 import { codeMcpServer } from "@cloudflare/codemode/mcp";
 import type { WorkspaceClient } from "@cloudflare/computer";
-import { createAITools } from "@cloudflare/computer/tools";
+import { createAITools } from "@cloudflare/computer/tools/ai-sdk";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { ToolSet } from "ai";
 
@@ -11,29 +11,26 @@ export async function createComputerMCPServer(workspace: WorkspaceClient, loader
   const tools = createAITools({
     workspace,
     assets: false,
-    shell: {
-      backends: {
-        "worker-shell": {
-          description:
-            "just-bash in an isolated Dynamic Worker. Starts quickly, " +
-            "does not boot a container, and has no ambient outbound network. " +
-            "Use it for common shell commands, quick file inspection, and " +
-            "text transformations. Its built-in git command supports clone, " +
-            "status, diff, and log; clone accepts HTTPS URLs through the " +
-            "durable workspace. Prefer the dedicated read, write, and edit " +
-            "tools for file operations. Cannot run npm, Node.js, Python, " +
-            "package managers, or arbitrary native binaries.",
-        },
-        "container-shell": {
-          description:
-            "Full Debian Linux in a Cloudflare Container with Node.js, npm, " +
-            "git, package management, native binaries, and outbound network. " +
-            "Use it for dependency installation, builds, tests, or commands " +
-            "that worker-shell cannot run. Cold starts more slowly because " +
-            "the container must boot; prefer worker-shell for simple tasks.",
-        },
+    exec: {
+      "worker-shell": {
+        description:
+          "just-bash in an isolated Dynamic Worker. Starts quickly, " +
+          "does not boot a container, and has no ambient outbound network. " +
+          "Use it for common shell commands, quick file inspection, and " +
+          "text transformations. Its built-in git command supports clone, " +
+          "status, diff, and log; clone accepts HTTPS URLs through the " +
+          "durable workspace. Prefer the dedicated read, write, and edit " +
+          "tools for file operations. Cannot run npm, Node.js, Python, " +
+          "package managers, or arbitrary native binaries.",
+      },
+      "container-shell": {
+        description:
+          "Full Debian Linux in a Cloudflare Container with Node.js, npm, " +
+          "git, package management, native binaries, and outbound network. " +
+          "Use it for dependency installation, builds, tests, or commands " +
+          "that worker-shell cannot run. Cold starts more slowly because " +
+          "the container must boot; prefer worker-shell for simple tasks.",
       },
-      defaultBackend: "worker-shell",
     },
   });
 
diff --git a/examples/rlm/worker/executor-tool.ts b/examples/rlm/worker/executor-tool.ts
index 07921ea9..ec5e53dd 100644
--- a/examples/rlm/worker/executor-tool.ts
+++ b/examples/rlm/worker/executor-tool.ts
@@ -19,7 +19,6 @@ export function createExecutorTool(
           "Callable isolated JavaScript. The command must be a complete ES module with a default async function.",
       },
     },
-    defaultBackend: backend,
     maxBytes: 16 * 1024,
     streamMaxBytes: 16 * 1024,
   });
diff --git a/examples/think/README.md b/examples/think/README.md
index 523b082a..32d88c28 100644
--- a/examples/think/README.md
+++ b/examples/think/README.md
@@ -24,7 +24,7 @@ would use, so no bespoke HTTP route or transport is involved.
 
 [think]: https://www.npmjs.com/package/@cloudflare/think
 [workspace]: ../../packages/computer
-[tools]: ../../packages/computer/src/tools
+[tools]: ../../packages/computer/src/tools/ai-sdk.ts
 [aisdk7]: https://vercel.com/blog/ai-sdk-7
 
 ## Shape
@@ -53,9 +53,10 @@ model, a Workspace, and the workspace tools.
 ## Tools
 
 The tools come from `createAITools()` in
-[`@cloudflare/computer/tools`][tools]. This example enables the file
-tools and opts into `exec` by passing a shell backend description; it
-does not configure the assets publisher, so `publish` is not offered.
+[`@cloudflare/computer/tools/ai-sdk`][tools]. This example offers the
+file tools and an `exec` tool over both backends, each of which
+describes itself to the model. It does not configure the assets
+publisher, so `publish` is not offered.
 
 | Tool    | What it does                                              |
 | ------- | --------------------------------------------------------- |
diff --git a/examples/think/src/agent.ts b/examples/think/src/agent.ts
index 624af906..c706d3f4 100644
--- a/examples/think/src/agent.ts
+++ b/examples/think/src/agent.ts
@@ -37,7 +37,7 @@ import {
   withWorkspaceContainer,
 } from "@cloudflare/computer/backends/container";
 import { WorkerShellBackend } from "@cloudflare/computer/backends/worker-shell";
-import { createAITools } from "@cloudflare/computer/tools";
+import { createAITools } from "@cloudflare/computer/tools/ai-sdk";
 import { Think } from "@cloudflare/think";
 import type { ToolSet } from "ai";
 import { createWorkersAI } from "workers-ai-provider";
@@ -154,35 +154,8 @@ export class Assistant extends withWorkspaceContainer(AssistantBase) {
   }
 
   override getTools(): ToolSet {
-    return createAITools({
-      workspace: this.workspace,
-      shell: {
-        defaultBackend: "shell",
-        backends: {
-          shell: {
-            description:
-              "just-bash in a Dynamic Worker. Cold-start fast, no " +
-              "container, no public network. Good for cat / grep / sed / " +
-              "awk / jq / head / tail / sort / find, quick file " +
-              "inspection, text transformations, and `git` (clone / " +
-              "status / diff / log) — the shell registers a built-in " +
-              "`git` command that forwards to the host workspace, so " +
-              "network-bound subcommands like `git clone` work even " +
-              "though the isolate itself has no public network. Only " +
-              "https:// URLs are supported. Cannot run npm, node, python, " +
-              "or any binary outside just-bash's built-in command set.",
-          },
-          container: {
-            description:
-              "Cloudflare Container running computerd over capnweb. Full Linux " +
-              "userland: npm, node, python, package managers, test " +
-              "runners, real binaries on $PATH, and public network. Cold " +
-              "start is much slower because the container must boot; " +
-              "reach for it when the shell backend can't run the command. " +
-              "For git itself, prefer the shell backend.",
-          },
-        },
-      },
-    });
+    // Every backend the Workspace has, "shell" first. Both describe
+    // themselves to the model.
+    return createAITools({ workspace: this.workspace });
   }
 }
diff --git a/packages/computer/README.md b/packages/computer/README.md
index 3f0115b8..0908b242 100644
--- a/packages/computer/README.md
+++ b/packages/computer/README.md
@@ -265,31 +265,27 @@ to a named one — see [Multiple backends](#multiple-backends).
 
 ## Tools for agents
 
-`@cloudflare/computer/tools` ships AI SDK tools that wrap the Workspace
+`@cloudflare/computer/tools/ai-sdk` ships `createAITools()`, AI SDK tools that wrap the Workspace
 surfaces, ready to hand to `generateText`, `streamText`, or an agent
 framework's `getTools()`. The default set is `read`, `ls`, `find`,
-`grep`, `write`, `edit`, and `delete`; `exec` and `publish` are added
-when you configure them. Read-only mode keeps `read`, `ls`, `find`, and
+`grep`, `write`, `edit`, and `delete`, plus `exec` when the Workspace
+has a backend and `publish` when assets are configured. Read-only mode keeps `read`, `ls`, `find`, and
 `grep`.
 
 ```ts
-import { createAITools } from "@cloudflare/computer/tools";
+import { createAITools } from "@cloudflare/computer/tools/ai-sdk";
 
 const tools = createAITools({
   workspace,
   read: { maxBytes: 32 * 1024, maxLines: 800 },
-  shell: {
-    defaultBackend: "shell",
-    backends: {
-      shell: { description: "Fast Worker shell with built-in text commands." },
-      container: { description: "Full Linux userland in a Cloudflare Container." },
-    },
-  },
+  // The backends the model can use. Omit for every backend.
+  exec: { shell: { description: "Try this first." }, container: {} },
 });
 ```
 
-The model reads each backend's `description` when deciding where a
-command should run, so write them in plain language. Truncated text
+Each backend describes itself to the model, and the text you give in
+`exec` comes first. The model reads both when deciding where a command
+should run, so write yours in plain language. Truncated text
 model output keeps both line and byte continuations; pass both to the
 next call to avoid transferring the same bytes again. Eligible image and
 PDF bytes are captured once during the bounded tool execution and returned
@@ -422,6 +418,7 @@ on a computerd instance.
 | `@cloudflare/computer/modules/git` | `createGitModule()` for `ws:git`: confined Git from isolate JavaScript. |
 | `@cloudflare/computer/modules/artifacts` | `createArtifactsModule()` for `ws:artifacts`: Artifacts from isolate JavaScript. |
 | `@cloudflare/computer/tools` | AI SDK tools for agents: `read`, `ls`, `find`, `grep`, `write`, `edit`, `delete`, and optional `exec` and `publish`. |
+| `@cloudflare/computer/tools/ai-sdk` | `createAITools()`: the AI SDK tool set for a Workspace. |
 | `@cloudflare/computer/git` | Opt-in `isomorphic-git` glue for checkouts inside the workspace. |
 | `@cloudflare/computer/assets` | `createAssets` — share a workspace file to R2 as a presigned URL. |
 | `@cloudflare/computer/artifacts` | `createArtifact` and its CLI, an optionally session-scoped wrapper over the Cloudflare Artifacts binding. |
diff --git a/packages/computer/package.json b/packages/computer/package.json
index 8bbac49d..d62c738e 100644
--- a/packages/computer/package.json
+++ b/packages/computer/package.json
@@ -47,6 +47,10 @@
       "types": "./dist/tools/index.d.ts",
       "import": "./dist/tools/index.js"
     },
+    "./tools/ai-sdk": {
+      "types": "./dist/tools/ai-sdk.d.ts",
+      "import": "./dist/tools/ai-sdk.js"
+    },
     "./backends/container": {
       "types": "./dist/backends/container/index.d.ts",
       "import": "./dist/backends/container/index.js"
diff --git a/packages/computer/rolldown.config.ts b/packages/computer/rolldown.config.ts
index 7179b638..67d5d7b9 100644
--- a/packages/computer/rolldown.config.ts
+++ b/packages/computer/rolldown.config.ts
@@ -31,6 +31,7 @@ export default defineConfig({
     "artifacts/index": "src/artifacts/index.ts",
     "assets/index": "src/assets/index.ts",
     "tools/index": "src/tools/index.ts",
+    "tools/ai-sdk": "src/tools/ai-sdk.ts",
     "modules/container": "src/modules/container.ts",
     "modules/git": "src/modules/git.ts",
     "modules/artifacts": "src/modules/artifacts.ts",
diff --git a/packages/computer/src/backends/container/cloudflare-container.ts b/packages/computer/src/backends/container/cloudflare-container.ts
index fc7445b6..29862b23 100644
--- a/packages/computer/src/backends/container/cloudflare-container.ts
+++ b/packages/computer/src/backends/container/cloudflare-container.ts
@@ -180,6 +180,9 @@ function bearerMatches(header: string | null, expected: string | undefined): boo
 
 export class CloudflareContainerBackend implements WorkspaceBackend {
   readonly type = "cloudflare-container";
+  /** What this backend tells a model: a full Linux shell that is slower to start. */
+  readonly description =
+    "A shell in a full Linux container: npm, node, python, package managers, test runners, native binaries, and network access. Starts much more slowly than an in-Worker backend because the container must boot.";
   readonly id: string;
 
   readonly #options: Required<
diff --git a/packages/computer/src/backends/worker-shell/worker-shell.ts b/packages/computer/src/backends/worker-shell/worker-shell.ts
index 981059d1..1fe4a1b2 100644
--- a/packages/computer/src/backends/worker-shell/worker-shell.ts
+++ b/packages/computer/src/backends/worker-shell/worker-shell.ts
@@ -139,6 +139,9 @@ const DEFAULT_COMPAT_FLAGS = ["nodejs_compat"];
 
 export class WorkerShellBackend implements WorkspaceBackend {
   readonly type = "worker-shell";
+  /** What this backend tells a model: a fast shell with a fixed command set. */
+  readonly description =
+    "A just-bash shell in a Dynamic Worker. Starts fast, with no container and no direct network. Good for cat, grep, sed, awk, jq, head, tail, sort, find, text transformations, and a built-in `git` (clone, status, diff, log) that works through the workspace. Cannot run npm, node, python, or binaries outside its built-in command set.";
   readonly id: string;
   readonly #options: WorkerShellBackendOptions;
   readonly #egress: WorkspaceEgressPolicy;
diff --git a/packages/computer/src/runtime/runtime.ts b/packages/computer/src/runtime/runtime.ts
index f74965f8..64842597 100644
--- a/packages/computer/src/runtime/runtime.ts
+++ b/packages/computer/src/runtime/runtime.ts
@@ -43,6 +43,13 @@ export class WorkspaceRuntime {
     return this.#options.backends.get(id)?.callable === true;
   }
 
+  // Every registered backend id, in registration order. The first is
+  // the default. The exec tool uses this when the caller does not pick
+  // backends itself.
+  backendIds(): string[] {
+    return [...this.#options.backends.keys()];
+  }
+
   // What the named backend says about itself for a model: its source
   // language and, for the JavaScript backend, the modules code can
   // import. The exec tool adds it to the backend's entry so a caller
diff --git a/packages/computer/src/tools/ai.test.ts b/packages/computer/src/tools/ai-sdk.test.ts
similarity index 95%
rename from packages/computer/src/tools/ai.test.ts
rename to packages/computer/src/tools/ai-sdk.test.ts
index 146c7c83..66bed393 100644
--- a/packages/computer/src/tools/ai.test.ts
+++ b/packages/computer/src/tools/ai-sdk.test.ts
@@ -5,8 +5,8 @@ import { WorkerJavaScriptBackend } from "../backends/worker-javascript/worker-ja
 import { createGitModule } from "../modules/git.js";
 import type { WorkspaceRuntimeExecHandle, WorkspaceRuntimeResult } from "../runtime/types.js";
 import { Workspace } from "../workspace.js";
+import { createAITools } from "./ai-sdk.js";
 import {
-  createAITools,
   createDeleteTool,
   createEditTool,
   createFindTool,
@@ -1330,19 +1330,56 @@ describe("createAITools filesystem tools", () => {
 });
 
 describe("createAITools exec tool", () => {
-  it("adds exec only when shell options are provided", () => {
-    const workspace = makeWorkspace();
+  it("offers exec by default only when the workspace has a backend", () => {
+    const withBackend = new Workspace({
+      storage: new SQLiteTestStorage(),
+      backends: [streamingCommandBackend([]) as never],
+    });
 
-    expect(createAITools({ workspace }).exec).toBeUndefined();
-    expect(
-      createAITools({
-        workspace,
-        shell: {
-          defaultBackend: "shell",
-          backends: { shell: { description: "test shell" } },
-        },
-      }).exec,
-    ).toBeDefined();
+    expect(createAITools({ workspace: makeWorkspace() }).exec).toBeUndefined();
+    expect(createAITools({ workspace: withBackend }).exec).toBeDefined();
+    expect(createAITools({ workspace: withBackend, exec: {} }).exec).toBeUndefined();
+    expect(createAITools({ workspace: withBackend, readonly: true }).exec).toBeUndefined();
+  });
+
+  it("offers every workspace backend by default", () => {
+    const workspace = new Workspace({
+      storage: new SQLiteTestStorage(),
+      backends: [
+        streamingCommandBackend([]) as never,
+        new WorkerJavaScriptBackend({ loader: { load: () => ({ getEntrypoint: () => ({}) }) } }),
+      ],
+    });
+    const tools = createAITools({ workspace });
+    const schema = z.toJSONSchema(inputSchema(tools.exec)) as {
+      properties: { backend?: { enum?: string[] } };
+      required?: string[];
+    };
+
+    expect(schema.properties.backend?.enum).toEqual(["shell", "worker-javascript"]);
+    expect(schema.required).toContain("backend");
+    expect(toolDescription(tools.exec)).not.toMatch(/default backend/i);
+    expect(toolDescription(tools.exec)).toContain('- "shell": Runs shell commands.');
+    expect(toolDescription(tools.exec)).toContain("ECMAScript module source");
+  });
+
+  it("takes the backends to offer, each with a note for the model", () => {
+    const workspace = new Workspace({
+      storage: new SQLiteTestStorage(),
+      backends: [
+        streamingCommandBackend([]) as never,
+        new WorkerJavaScriptBackend({ loader: { load: () => ({ getEntrypoint: () => ({}) }) } }),
+      ],
+    });
+    const listed = createAITools({ workspace, exec: { "worker-javascript": {} } });
+    const mapped = createAITools({
+      workspace,
+      exec: { "worker-javascript": { description: "Use for data work." }, shell: {} },
+    });
+
+    expect(inputProperties(listed.exec)).not.toContain("backend");
+    expect(toolDescription(listed.exec)).not.toContain('"shell"');
+    expect(toolDescription(mapped.exec)).toContain("Use for data work.\n\n`command` is ECMAScript");
   });
 
   it("runs shell commands on the selected backend and truncates output", async () => {
@@ -1528,15 +1565,10 @@ describe("createAITools exec tool", () => {
     });
   });
 
-  it("rejects invalid shell backend configuration", () => {
-    const workspace = makeWorkspace();
-
-    expect(() =>
-      createAITools({
-        workspace,
-        shell: { defaultBackend: "missing", backends: { shell: { description: "test" } } },
-      }),
-    ).toThrow(/defaultBackend/);
+  it("rejects a backend the workspace does not have", () => {
+    expect(() => createAITools({ workspace: makeWorkspace(), exec: { missing: {} } })).toThrow(
+      /unknown backend "missing"/,
+    );
   });
 });
 
@@ -1739,7 +1771,7 @@ describe("createAITools callable exec", () => {
     expect(toolDescription(withBackendOnly.exec)).toContain("`ws:weather` exports `forecast`");
   });
 
-  it("requires a description for a backend that does not describe itself", () => {
+  it("falls back to a short description for a backend that does not describe itself", () => {
     const workspace = {
       runtime: {
         async exec() {
@@ -1747,10 +1779,9 @@ describe("createAITools callable exec", () => {
         },
       },
     };
+    const tools = createAITools({ workspace, exec: { shell: {} } });
 
-    expect(() => createAITools({ workspace, shell: { backends: { shell: {} } } })).toThrow(
-      /does not describe itself/,
-    );
+    expect(toolDescription(tools.exec)).toContain("Runs shell commands.");
   });
 });
 
@@ -1859,17 +1890,19 @@ describe("createAITools exec with one backend", () => {
     expect(inputProperties(tools.exec)).toEqual(["backend", "command", "cwd", "env", "input"]);
   });
 
-  it("requires defaultBackend when more than one backend is configured", () => {
-    const { workspace } = recordingWorkspace(false);
+  it("requires the model to name a backend when there is a choice", async () => {
+    const { calls, workspace } = recordingWorkspace(false);
+    const tools = createAITools({
+      workspace,
+      exec: { container: { description: "Linux." }, shell: { description: "Fast." } },
+    });
 
-    expect(() =>
-      createAITools({
-        workspace,
-        shell: {
-          backends: { shell: { description: "Fast shell." }, container: { description: "Linux." } },
-        },
-      }),
-    ).toThrow(/defaultBackend/);
+    expect(() => inputSchema(tools.exec).parse({ command: "ls" })).toThrow();
+    await expect(executeTool(tools.exec, { command: "ls" })).resolves.toMatchObject({
+      error: "Name a backend to run on.",
+    });
+    await executeTool(tools.exec, { command: "ls", backend: "shell" });
+    expect(calls.map((call) => call.backend)).toEqual(["shell"]);
   });
 });
 
diff --git a/packages/computer/src/tools/ai-sdk.ts b/packages/computer/src/tools/ai-sdk.ts
new file mode 100644
index 00000000..f0593dac
--- /dev/null
+++ b/packages/computer/src/tools/ai-sdk.ts
@@ -0,0 +1,93 @@
+import type { ToolSet } from "ai";
+import {
+  createExecTool,
+  type ExecBackends,
+  type ExecToolOptions,
+  type ExecWorkspaceLike,
+} from "./exec.js";
+import { createDeleteTool } from "./fs/delete.js";
+import { createEditTool, type EditToolOptions } from "./fs/edit.js";
+import { createFindTool } from "./fs/find.js";
+import { createGrepTool } from "./fs/grep.js";
+import { createListTool } from "./fs/list.js";
+import { createReadTool, type ReadToolOptions } from "./fs/read.js";
+import { type WorkspaceLike as FileWorkspaceLike, WorkspaceFileStore } from "./fs/store.js";
+import { createWriteTool, type WriteToolOptions } from "./fs/write.js";
+import { createPublishTool, type PublishWorkspaceLike } from "./publish.js";
+
+/** Options for {@link createAITools}. */
+export interface CreateAIToolsOptions {
+  workspace: FileWorkspaceLike & Partial<ExecWorkspaceLike> & Partial<PublishWorkspaceLike>;
+  readonly?: boolean;
+  assets?: boolean;
+  read?: Omit<ReadToolOptions, "store">;
+  write?: Omit<WriteToolOptions, "store">;
+  edit?: Omit<EditToolOptions, "store">;
+  // The backends `exec` may run on, keyed by id, each with an optional
+  // description for the model. Omit to offer
+  // every backend the Workspace has; `{}` means no exec tool.
+  exec?: ExecBackends;
+  /**
+   * @deprecated Use `exec`. `{ backends }` becomes `exec: backends`;
+   * `defaultBackend` is ignored, because the model names a backend
+   * whenever there is a choice. Output limits move to `createExecTool`.
+   */
+  shell?: LegacyShellOptions;
+}
+
+interface LegacyShellOptions extends Omit<ExecToolOptions, "workspace" | "backends"> {
+  backends: ExecBackends;
+  defaultBackend?: string;
+}
+
+/**
+ * Build the AI SDK tool set for a Workspace: `read`, `ls`, `find`, and
+ * `grep`, plus `write`, `edit`, `delete`, `exec`, and `publish` unless
+ * the set is read-only. `exec` offers every backend the Workspace has
+ * unless `exec` picks them.
+ *
+ * @param options - The Workspace and per-tool options.
+ * @returns An AI SDK `ToolSet` for `generateText`, `streamText`, or an agent's `getTools()`.
+ */
+export function createAITools(options: CreateAIToolsOptions): ToolSet {
+  const store = new WorkspaceFileStore(options.workspace);
+  const tools: ToolSet = {
+    read: createReadTool({ store, ...options.read }),
+    ls: createListTool({ workspace: options.workspace }),
+    find: createFindTool({ workspace: options.workspace }),
+    grep: createGrepTool({ workspace: options.workspace }),
+  };
+
+  if (options.readonly === true) return tools;
+
+  tools.write = createWriteTool({ store, ...options.write });
+  tools.edit = createEditTool({ store, ...options.edit });
+  tools.delete = createDeleteTool({ store });
+
+  const runtime = options.workspace.runtime;
+  if (runtime !== undefined) {
+    const exec = execOptions(options, runtime);
+    if (Object.keys(exec.backends).length > 0) {
+      tools.exec = createExecTool({ workspace: { runtime }, ...exec });
+    }
+  }
+
+  if (options.assets !== false && options.workspace.assets !== undefined) {
+    tools.publish = createPublishTool({ workspace: options.workspace as PublishWorkspaceLike });
+  }
+
+  return tools;
+}
+
+// Turn `exec`, or the deprecated `shell`, into createExecTool options.
+function execOptions(
+  options: CreateAIToolsOptions,
+  runtime: ExecWorkspaceLike["runtime"],
+): Omit<ExecToolOptions, "workspace"> & { backends: ExecBackends } {
+  if (options.shell !== undefined) {
+    const { backends, defaultBackend: _ignored, ...limits } = options.shell;
+    return { ...limits, backends };
+  }
+  if (options.exec !== undefined) return { backends: options.exec };
+  return { backends: Object.fromEntries((runtime.backendIds?.() ?? []).map((id) => [id, {}])) };
+}
diff --git a/packages/computer/src/tools/ai.ts b/packages/computer/src/tools/ai.ts
deleted file mode 100644
index 78cc8358..00000000
--- a/packages/computer/src/tools/ai.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import type { ToolSet } from "ai";
-import { createExecTool, type ExecToolOptions, type ExecWorkspaceLike } from "./exec.js";
-import { createDeleteTool } from "./fs/delete.js";
-import { createEditTool, type EditToolOptions } from "./fs/edit.js";
-import { createFindTool } from "./fs/find.js";
-import { createGrepTool } from "./fs/grep.js";
-import { createListTool } from "./fs/list.js";
-import { createReadTool, type ReadToolOptions } from "./fs/read.js";
-import { type WorkspaceLike as FileWorkspaceLike, WorkspaceFileStore } from "./fs/store.js";
-import { createWriteTool, type WriteToolOptions } from "./fs/write.js";
-import { createPublishTool, type PublishWorkspaceLike } from "./publish.js";
-
-export interface CreateAIToolsOptions {
-  workspace: FileWorkspaceLike & Partial<ExecWorkspaceLike> & Partial<PublishWorkspaceLike>;
-  readonly?: boolean;
-  assets?: boolean;
-  read?: Omit<ReadToolOptions, "store">;
-  write?: Omit<WriteToolOptions, "store">;
-  edit?: Omit<EditToolOptions, "store">;
-  shell?: Omit<ExecToolOptions, "workspace">;
-}
-
-export function createAITools(options: CreateAIToolsOptions): ToolSet {
-  const store = new WorkspaceFileStore(options.workspace);
-  const tools: ToolSet = {
-    read: createReadTool({ store, ...options.read }),
-    ls: createListTool({ workspace: options.workspace }),
-    find: createFindTool({ workspace: options.workspace }),
-    grep: createGrepTool({ workspace: options.workspace }),
-  };
-
-  if (options.readonly === true) return tools;
-
-  tools.write = createWriteTool({ store, ...options.write });
-  tools.edit = createEditTool({ store, ...options.edit });
-  tools.delete = createDeleteTool({ store });
-
-  if (options.shell !== undefined) {
-    tools.exec = createExecTool({
-      workspace: options.workspace as ExecWorkspaceLike,
-      ...options.shell,
-    });
-  }
-
-  if (options.assets !== false && options.workspace.assets !== undefined) {
-    tools.publish = createPublishTool({ workspace: options.workspace as PublishWorkspaceLike });
-  }
-
-  return tools;
-}
diff --git a/packages/computer/src/tools/exec.ts b/packages/computer/src/tools/exec.ts
index 620d8e56..08eb864a 100644
--- a/packages/computer/src/tools/exec.ts
+++ b/packages/computer/src/tools/exec.ts
@@ -67,27 +67,34 @@ export interface ExecWorkspaceLike {
     isCallable?(id: string): boolean;
     // What a backend says about itself for a model, such as the
     // language it runs and the modules that code can import. The tool
-    // shows it after the caller's own description.
+    // shows it after the caller's own text.
     describe?(id: string): string | undefined;
+    // Every registered backend id. Used when the caller does not pick
+    // backends, and to reject an unknown id up front.
+    backendIds?(): string[];
   };
 }
 
-export interface ExecBackendDescription {
-  // Guidance for the model about this backend, shown before whatever
-  // the backend says about itself. Required only when the backend does
-  // not describe itself.
-  description?: string;
+/** Options for one backend the exec tool may run on. */
+export interface ExecBackendOptions {
+  /** Shown to the model before the backend's own description. */
+  readonly description?: string;
 }
 
+/**
+ * The backends the exec tool may run on, keyed by backend id:
+ * `{ "worker-javascript": { description: "Use for data work." } }`.
+ * Pass `{}` for a backend that needs nothing beyond its own
+ * description.
+ */
+export type ExecBackends = Readonly<Record<string, ExecBackendOptions>>;
+
 export interface ExecToolOptions {
   workspace: ExecWorkspaceLike;
-  // Backends the model may run on. With exactly one, the tool has no
-  // `backend` argument and always runs there, so the model never has
-  // to reason about backends.
-  backends: Record<string, ExecBackendDescription>;
-  // Backend used when the model omits `backend`. Required when more
-  // than one backend is configured; with one it defaults to that one.
-  defaultBackend?: string;
+  // Omit to offer every backend the Workspace has. With one backend
+  // the tool has no `backend` argument; with several the model must
+  // name one on every call.
+  backends?: ExecBackends;
   // Per-snapshot display cap for each of stdout and stderr, in bytes.
   // Output past it is shown as a truncation marker. Defaults to 64 KiB.
   maxBytes?: number;
@@ -135,32 +142,22 @@ export function createExecTool(options: ExecToolOptions): Tool<ExecToolInput, Ex
   const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
   const streamMaxBytes = options.streamMaxBytes ?? DEFAULT_STREAM_MAX_BYTES;
   const now = options.now ?? Date.now;
-  const backendIds = Object.keys(options.backends);
-  if (backendIds.length === 0) {
-    throw new Error("createExecTool: pass at least one backend in `backends`");
-  }
-  const single = backendIds.length === 1;
-  const defaultBackend = options.defaultBackend ?? (single ? backendIds[0] : undefined);
-  if (defaultBackend === undefined || !backendIds.includes(defaultBackend)) {
-    throw new Error(
-      `createExecTool: pass a defaultBackend that is one of ${backendIds.map((id) => JSON.stringify(id)).join(", ")}`,
-    );
-  }
-
   const runtime = options.workspace.runtime;
-  const backends = backendIds.map((id) => {
-    const text = [options.backends[id]?.description, runtime.describe?.(id)]
-      .filter((part) => part !== undefined && part !== "")
-      .join("\n\n");
-    if (text === "") {
-      throw new Error(
-        `createExecTool: backend ${JSON.stringify(id)} does not describe itself; pass a description`,
-      );
-    }
-    return { id, text, callable: runtime.isCallable?.(id) === true };
+  const selected = selectBackends(options.backends, runtime);
+  const [first] = selected;
+  if (first === undefined) throw new Error("createExecTool: no backends to run on");
+  const backendIds = selected.map((backend) => backend.id);
+  const single = backendIds.length === 1;
+  const backends = selected.map(({ id, guidance }) => {
+    const callable = runtime.isCallable?.(id) === true;
+    const own = runtime.describe?.(id);
+    const text =
+      [guidance, own].filter((part) => part !== undefined && part !== "").join("\n\n") ||
+      (callable ? "Runs `command` as module source." : "Runs shell commands.");
+    return { id, text, callable };
   });
   const callableBackendIds = new Set(backends.filter((b) => b.callable).map((b) => b.id));
-  const description = describeTool(backends, defaultBackend);
+  const description = describeTool(backends);
   // Offer only the fields that can work: `backend` when there is a
   // choice, `input` when some backend accepts it.
   const shape: Record<string, z.ZodType> = {
@@ -177,9 +174,8 @@ export function createExecTool(options: ExecToolOptions): Tool<ExecToolInput, Ex
     shape.backend = z
       // SAFETY: createExecTool checked that backendIds has at least one entry.
       .enum(backendIds as [string, ...string[]])
-      .optional()
       .describe(
-        `Which backend to run on. Omit to use the default (${JSON.stringify(defaultBackend)}). If a command fails because the backend lacks that tool, retry on a backend whose description covers it.`,
+        "Which backend to run on. If a command fails because the backend lacks that tool, retry on a backend whose description covers it.",
       );
   }
   if (callableBackendIds.size > 0) {
@@ -198,7 +194,14 @@ export function createExecTool(options: ExecToolOptions): Tool<ExecToolInput, Ex
     description,
     inputSchema,
     execute: async function* ({ command, cwd, backend, env, input }, { abortSignal }) {
-      const selectedBackend = backend ?? defaultBackend;
+      // With one backend there is nothing to choose. With several the
+      // schema requires `backend`; a caller that skips the schema gets
+      // the same answer as an error.
+      const selectedBackend = single ? first.id : backend;
+      if (selectedBackend === undefined) {
+        yield { command, cwd: cwd ?? null, backend: "", error: "Name a backend to run on." };
+        return;
+      }
       const base = { command, cwd: cwd ?? null, backend: selectedBackend };
       if (input !== undefined && !callableBackendIds.has(selectedBackend)) {
         yield { ...base, error: notCallableMessage(selectedBackend) };
@@ -315,7 +318,7 @@ interface DescribedBackend {
 
 // With one backend the description is about what it does. With several
 // it lists them and explains how to choose.
-function describeTool(backends: readonly DescribedBackend[], defaultBackend: string): string {
+function describeTool(backends: readonly DescribedBackend[]): string {
   const [only, ...others] = backends;
   if (only !== undefined && others.length === 0) {
     return only.callable
@@ -338,7 +341,7 @@ function describeTool(backends: readonly DescribedBackend[], defaultBackend: str
       (b) => `- ${JSON.stringify(b.id)}${b.callable ? " (callable)" : ""}: ${b.text}`,
     ),
     "",
-    `Default backend: ${JSON.stringify(defaultBackend)}. Try this first for any command you're not sure about; if it fails with a "command not found" or a similar capability error, retry on a backend whose description covers the missing tool.`,
+    'Name a backend on every call. If a command fails with a "command not found" or a similar capability error, retry on a backend whose description covers the missing tool.',
     `${SHELL_HINT} ${FILE_TOOLS_HINT}`,
     ...(callable.length === 0
       ? []
@@ -349,6 +352,33 @@ function describeTool(backends: readonly DescribedBackend[], defaultBackend: str
   ].join("\n");
 }
 
+// Resolve the caller's choice to a list of backends.
+function selectBackends(
+  backends: ExecBackends | undefined,
+  runtime: ExecWorkspaceLike["runtime"],
+): Array<{ id: string; guidance: string | undefined }> {
+  const known = runtime.backendIds?.();
+  let selected: Array<{ id: string; guidance: string | undefined }>;
+  if (backends === undefined) {
+    if (known === undefined) {
+      throw new Error("createExecTool: pass `backends`; this workspace cannot list its backends");
+    }
+    selected = known.map((id) => ({ id, guidance: undefined }));
+  } else {
+    selected = Object.entries(backends).map(([id, backend]) => ({
+      id,
+      guidance: backend.description,
+    }));
+  }
+  const unknown = known === undefined ? [] : selected.filter((b) => !known.includes(b.id));
+  if (unknown.length > 0) {
+    throw new Error(
+      `createExecTool: unknown backend ${unknown.map((b) => JSON.stringify(b.id)).join(", ")}; the workspace has ${known?.map((id) => JSON.stringify(id)).join(", ") || "none"}`,
+    );
+  }
+  return selected;
+}
+
 function commandHint(backends: readonly DescribedBackend[]): string {
   if (backends.every((backend) => backend.callable)) return "Module source to run.";
   if (backends.every((backend) => !backend.callable)) {
diff --git a/packages/computer/src/tools/index.ts b/packages/computer/src/tools/index.ts
index 9bad4745..8bd6f739 100644
--- a/packages/computer/src/tools/index.ts
+++ b/packages/computer/src/tools/index.ts
@@ -1,7 +1,7 @@
-export { type CreateAIToolsOptions, createAITools } from "./ai.js";
 export {
   createExecTool,
-  type ExecBackendDescription,
+  type ExecBackendOptions,
+  type ExecBackends,
   type ExecRuntimeHandle,
   type ExecStreamEvent,
   type ExecToolOptions,