diff --git a/apps/host-cloudflare/src/config.ts b/apps/host-cloudflare/src/config.ts
index 1976e3cc6..0a955bf01 100644
--- a/apps/host-cloudflare/src/config.ts
+++ b/apps/host-cloudflare/src/config.ts
@@ -1,11 +1,11 @@
 import type {
   D1Database,
   DurableObjectNamespace,
+  AiSearchInstance,
   KVNamespace,
   R2Bucket,
 } from "@cloudflare/workers-types";
 import type { AnalyticsEngineDataset } from "@executor-js/plugin-execution-metrics/cloudflare";
-import type { AiSearchInstance } from "@executor-js/plugin-semantic-search";
 
 import { isValidOrgSlug } from "@executor-js/api";
 import { missingPublicOriginWarning, resolvePublicOrigin } from "@executor-js/sdk/public-origin";
diff --git a/apps/host-cloudflare/src/plugins.ts b/apps/host-cloudflare/src/plugins.ts
index 8037491a9..9cda735c4 100644
--- a/apps/host-cloudflare/src/plugins.ts
+++ b/apps/host-cloudflare/src/plugins.ts
@@ -1,3 +1,4 @@
+import type { AiSearchInstance } from "@cloudflare/workers-types";
 import { openApiHttpPlugin } from "@executor-js/plugin-openapi/api";
 import { googleHttpPlugin } from "@executor-js/plugin-google/api";
 import { microsoftHttpPlugin } from "@executor-js/plugin-microsoft/api";
@@ -12,10 +13,7 @@ import {
 import { noopExecutionObserver } from "@executor-js/sdk";
 import { serviceTokensPlugin } from "@executor-js/plugin-service-tokens/server";
 import { semanticSearchHttpPlugin } from "@executor-js/plugin-semantic-search/api";
-import {
-  makeAiSearchToolSearchBackend,
-  type AiSearchInstance,
-} from "@executor-js/plugin-semantic-search";
+import { makeAiSearchToolSearchBackend } from "@executor-js/plugin-semantic-search";
 
 // ---------------------------------------------------------------------------
 // The Cloudflare host's plugin list — the same protocol/provider plugins as
diff --git a/apps/host-cloudflare/wrangler.jsonc b/apps/host-cloudflare/wrangler.jsonc
index 03bdc71bd..a7b8a0a4f 100644
--- a/apps/host-cloudflare/wrangler.jsonc
+++ b/apps/host-cloudflare/wrangler.jsonc
@@ -49,6 +49,8 @@
   // Cloudflare AI Search is the preferred backend for semantic `tools.search`.
   // Uncomment after creating the instance, otherwise deploy will fail because
   // the binding target is absent.
+  // Create with:
+  // `wrangler ai-search create executor-tool-search --embedding-model @cf/qwen/qwen3-embedding-0.6b`
   // "ai_search": [{ "binding": "AI_SEARCH", "instance_name": "executor-tool-search" }],
   // The MCP session Durable Object: one addressable isolate per MCP session (the
   // DO id IS the session id) so a session survives across the Worker's stateless
diff --git a/packages/plugins/semantic-search/src/api/group.ts b/packages/plugins/semantic-search/src/api/group.ts
index af47fa55d..9a36dadc4 100644
--- a/packages/plugins/semantic-search/src/api/group.ts
+++ b/packages/plugins/semantic-search/src/api/group.ts
@@ -10,8 +10,7 @@ import { InternalError } from "@executor-js/api";
 // execution-history/graphql convention — the per-request executor is already
 // owner-scoped at the host edge, so there is no `:scopeId` segment.
 //
-//   - reindex (POST) indexes the whole tool catalog for the scoped tenant
-//     through the same index refresh/chunk/embed pipeline.
+//   - reindex (POST) uploads changed tool documents into Cloudflare AI Search.
 //   - search (GET) runs a live `tools.search` through the SAME provider the
 //     engine uses, so the operator console sees what the agent would.
 //   - status (GET) reports index population (vector fingerprints + lexical docs).
@@ -20,13 +19,16 @@ import { InternalError } from "@executor-js/api";
 // `capture` downgrades it to `InternalError`.
 // ---------------------------------------------------------------------------
 
-/** Result of an index run: counts for each category of tool processed. */
+/** Result of submitting changed documents to the backend index. */
 export const ReindexResponse = Schema.Struct({
   namespace: Schema.String,
   total: Schema.Number,
   indexed: Schema.Number,
   skipped: Schema.Number,
   removed: Schema.Number,
+  offset: Schema.optional(Schema.Number),
+  pageSize: Schema.optional(Schema.Number),
+  nextOffset: Schema.optional(Schema.NullOr(Schema.Number)),
 });
 
 /** One live `tools.search` match (fused vector/lexical score; higher is better). */
diff --git a/packages/plugins/semantic-search/src/api/handlers.ts b/packages/plugins/semantic-search/src/api/handlers.ts
index 10a8dd1c9..688298287 100644
--- a/packages/plugins/semantic-search/src/api/handlers.ts
+++ b/packages/plugins/semantic-search/src/api/handlers.ts
@@ -15,8 +15,7 @@ import { SemanticSearchGroup } from "./group";
 // `Layer.succeed(SemanticSearchExtensionService, executor.semanticSearch)`.
 // The handler also yields the per-request `ExecutorService` (the scoped
 // executor) and hands it to `reindex`, since the catalog lives on the executor,
-// not the plugin ctx. `reindex` is a index run, not a legacy page
-// reconciler.
+// not the plugin ctx.
 // ---------------------------------------------------------------------------
 
 export class SemanticSearchExtensionService extends Context.Service<
diff --git a/packages/plugins/semantic-search/src/react/SearchPage.tsx b/packages/plugins/semantic-search/src/react/SearchPage.tsx
index cfab0fa6c..7affaf484 100644
--- a/packages/plugins/semantic-search/src/react/SearchPage.tsx
+++ b/packages/plugins/semantic-search/src/react/SearchPage.tsx
@@ -1,5 +1,6 @@
 import { useState } from "react";
 import { useAtomRefresh, useAtomSet, useAtomValue } from "@effect/atom-react";
+import * as Cause from "effect/Cause";
 import * as Exit from "effect/Exit";
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
 import { RefreshCw, Search } from "lucide-react";
@@ -13,16 +14,18 @@ import {
   TableHeader,
   TableRow,
 } from "@executor-js/react/components/table";
+import type { InternalError } from "@executor-js/sdk/core";
 
 import type { SearchResponseType, StatusResponseType } from "../api/group";
 import { reindexMutation, searchAtom, statusAtom } from "./atoms";
 
 const SEARCH_LIMIT = 25;
 
+const internalErrorMessage = (cause: Cause.Cause<InternalError>): string => Cause.pretty(cause);
+
 // Operator/debug page for the semantic-search plugin: a live `tools.search` box
-// over the engine's discovery provider (Vectorize + FTS5/BM25 hybrid), an index
-// status line, and an explicit reindex trigger. Read-only against the catalog —
-// the only mutation is reindex.
+// over the engine's discovery provider, an index status line, and an explicit
+// reindex trigger. Read-only against the catalog, except for reindex.
 export function SearchPage() {
   const [input, setInput] = useState("");
   const [submitted, setSubmitted] = useState("");
@@ -31,10 +34,10 @@ export function SearchPage() {
 
   const searchResult = useAtomValue(
     searchAtom({ q: submitted, limit: SEARCH_LIMIT }),
-  ) as AsyncResult.AsyncResult<SearchResponseType, unknown>;
+  ) as AsyncResult.AsyncResult<SearchResponseType, InternalError>;
   const statusResult = useAtomValue(statusAtom) as AsyncResult.AsyncResult<
     StatusResponseType,
-    unknown
+    InternalError
   >;
   const refreshStatus = useAtomRefresh(statusAtom);
   const doReindex = useAtomSet(reindexMutation, { mode: "promiseExit" });
@@ -54,6 +57,11 @@ export function SearchPage() {
     onFailure: () => true,
     onSuccess: () => false,
   });
+  const searchError = AsyncResult.match(searchResult, {
+    onInitial: () => null,
+    onFailure: ({ cause }) => internalErrorMessage(cause),
+    onSuccess: () => null,
+  });
   const status = AsyncResult.match(statusResult, {
     onInitial: () => null,
     onFailure: () => null,
@@ -67,12 +75,12 @@ export function SearchPage() {
     setNotice(null);
     const exit = await doReindex({ reactivityKeys: [] });
     setReindexing(false);
+    refreshStatus();
     if (Exit.isFailure(exit)) {
-      setNotice("Reindex failed — a full-catalog index run can exceed the Worker CPU limit.");
+      setNotice("Reindex failed. Check server logs for the trace id.");
       return;
     }
-    setNotice("Reindex complete.");
-    refreshStatus();
+    setNotice("Reindex submitted.");
   };
 
   return (
@@ -85,8 +93,8 @@ export function SearchPage() {
             </h1>
             <p className="mt-2 text-sm text-muted-foreground leading-relaxed">
               Run a live <span className="font-mono text-[12px]">tools.search</span> through the
-              engine's discovery provider — semantic (Vectorize) fused with lexical (FTS5/BM25) when
-              both are indexed. This is what the agent sees.
+              engine's configured discovery provider. On Cloudflare this uses the bound AI Search
+              instance. This is what the agent sees.
             </p>
           </div>
           <Button
@@ -122,9 +130,15 @@ export function SearchPage() {
         <div className="mb-6 text-[12px] text-muted-foreground">
           {status ? (
             <>
-              namespace <span className="font-mono">{status.namespace}</span> · indexed{" "}
+              namespace <span className="font-mono">{status.namespace}</span> · documents{" "}
               {status.indexed.toLocaleString()}
               {status.lexical !== null ? ` · lexical ${status.lexical.toLocaleString()}` : ""}
+              {status.queued !== undefined ? ` · queued ${status.queued.toLocaleString()}` : ""}
+              {status.running !== undefined ? ` · running ${status.running.toLocaleString()}` : ""}
+              {status.completed !== undefined
+                ? ` · completed ${status.completed.toLocaleString()}`
+                : ""}
+              {status.error !== undefined ? ` · error ${status.error.toLocaleString()}` : ""}
             </>
           ) : (
             "index status unavailable"
@@ -134,7 +148,7 @@ export function SearchPage() {
 
         {searchFailed ? (
           <div className="rounded-md border border-border px-4 py-8 text-center text-sm text-muted-foreground">
-            Search failed.
+            Search failed{searchError ? `: ${searchError}` : "."}
           </div>
         ) : submitted.length === 0 ? (
           <div className="rounded-md border border-dashed border-border px-4 py-10 text-center text-sm text-muted-foreground">
@@ -144,8 +158,8 @@ export function SearchPage() {
           <div className="px-4 py-10 text-center text-sm text-muted-foreground">Searching…</div>
         ) : items.length === 0 ? (
           <div className="rounded-md border border-dashed border-border px-4 py-10 text-center text-sm text-muted-foreground">
-            No tools matched <span className="font-mono">{submitted}</span>. The index may be empty
-            — run a reindex.
+            No tools matched <span className="font-mono">{submitted}</span>. The AI Search index may
+            be empty. Run a reindex.
           </div>
         ) : (
           <Table>
diff --git a/packages/plugins/semantic-search/src/sdk/ai-search.test.ts b/packages/plugins/semantic-search/src/sdk/ai-search.test.ts
index 23f6f82e9..d7423dafd 100644
--- a/packages/plugins/semantic-search/src/sdk/ai-search.test.ts
+++ b/packages/plugins/semantic-search/src/sdk/ai-search.test.ts
@@ -1,13 +1,15 @@
 import { describe, expect, it } from "@effect/vitest";
+import type { AiSearchInstance } from "@cloudflare/workers-types";
 import { type PluginStorageCollectionFacade, type PluginStorageEntry } from "@executor-js/sdk/core";
 import { Effect } from "effect";
 
 import {
   makeAiSearchToolDiscoveryProvider,
   reindexAiSearch,
-  type AiSearchInstance,
+  reindexAiSearchBatch,
 } from "./ai-search";
 import { type aiSearchItems, type AiSearchItemRow } from "./collections";
+import { cyrb53 } from "./fingerprint";
 
 type ItemsCollection = PluginStorageCollectionFacade<typeof aiSearchItems>;
 
@@ -59,16 +61,26 @@ const makeItemsCollection = (overrides: Partial<ItemsCollection>): ItemsCollecti
   ...overrides,
 });
 
-const makeAiSearch = (): AiSearchInstance => ({
-  items: {
-    upload: async (name) => ({ id: `item:${name}`, key: name }),
-    list: async () => ({ result: [], result_info: { total_count: 0, page: 1, per_page: 50 } }),
+const makeAiSearchItems = () =>
+  ({
+    upload: async (name) => ({ id: `item:${name}`, key: name, status: "queued" }),
+    list: async () => ({
+      result: [],
+      result_info: { count: 0, total_count: 0, page: 1, per_page: 50 },
+    }),
     delete: async () => {},
-  },
+    uploadAndPoll: async (name) => ({ id: `item:${name}`, key: name, status: "queued" }),
+    get: () => expect.unreachable("Unexpected AI Search item lookup"),
+  }) satisfies Pick<AiSearchInstance, "items">["items"];
+
+const makeAiSearch = (): Pick<AiSearchInstance, "items" | "search"> => ({
+  items: makeAiSearchItems(),
   search: async () => ({
+    search_query: "create repo",
     chunks: [
       {
         id: "chunk-1",
+        type: "text",
         score: 0.7,
         text: "create a repository",
         item: {
@@ -83,6 +95,7 @@ const makeAiSearch = (): AiSearchInstance => ({
       },
       {
         id: "chunk-2",
+        type: "text",
         score: 0.9,
         text: "github repository creation",
         item: {
@@ -97,6 +110,7 @@ const makeAiSearch = (): AiSearchInstance => ({
       },
       {
         id: "chunk-3",
+        type: "text",
         score: 0.8,
         text: "send a message",
         item: {
@@ -182,6 +196,27 @@ describe("makeAiSearchToolDiscoveryProvider", () => {
       expect(page.total).toBe(1);
     }),
   );
+
+  it.effect("returns an empty page without querying AI Search when local rows are empty", () =>
+    Effect.gen(function* () {
+      const provider = makeAiSearchToolDiscoveryProvider({
+        aiSearch: {
+          ...makeAiSearch(),
+          search: () => expect.unreachable("AI Search should not be queried"),
+        },
+        items: makeItemsCollection({ list: () => Effect.succeed([]) }),
+      });
+
+      const page = yield* provider!.searchTools({
+        executor: undefined as never,
+        query: "tool",
+        limit: 10,
+        offset: 0,
+      });
+
+      expect(page).toMatchObject({ items: [], total: 0, hasMore: false, nextOffset: null });
+    }),
+  );
 });
 
 describe("reindexAiSearch", () => {
@@ -210,19 +245,18 @@ describe("reindexAiSearch", () => {
         aiSearch: {
           ...makeAiSearch(),
           items: {
-            ...makeAiSearch().items,
+            ...makeAiSearchItems(),
             upload: async (name, content) => {
               uploadedContent = String(content);
-              return { id: `item:${name}`, key: name };
+              return { id: `item:${name}`, key: name, status: "queued" };
             },
           },
         },
         items: makeItemsCollection({
           list: () => Effect.succeed([]),
-          put: ({ data }) =>
+          putMany: ({ entries }) =>
             Effect.sync(() => {
-              stored.push(data);
-              return { ...githubRow, data };
+              stored.push(...entries.map((entry) => entry.data));
             }),
         }),
         owner: "org",
@@ -249,7 +283,7 @@ describe("reindexAiSearch", () => {
         aiSearch: {
           ...makeAiSearch(),
           items: {
-            ...makeAiSearch().items,
+            ...makeAiSearchItems(),
             delete: async () => {
               // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: test double for rejected AI Search delete promise
               throw new Error("delete failed");
@@ -258,9 +292,9 @@ describe("reindexAiSearch", () => {
         },
         items: makeItemsCollection({
           list: () => Effect.succeed([githubRow]),
-          remove: ({ key }) =>
+          removeMany: ({ keys }) =>
             Effect.sync(() => {
-              removed.push(key);
+              removed.push(...keys);
             }),
         }),
         owner: "org",
@@ -271,4 +305,316 @@ describe("reindexAiSearch", () => {
       expect(removed).toEqual(["github.default.main.repos.create"]);
     }),
   );
+
+  it.effect("batches local row writes before deleting replaced remote items", () =>
+    Effect.gen(function* () {
+      const deleted: string[] = [];
+      const stored: AiSearchItemRow[] = [];
+      const result = yield* reindexAiSearch({
+        executor: {
+          tools: {
+            manifest: () =>
+              Effect.succeed([
+                {
+                  path: "github.default.main.repos.create",
+                  name: "repos.create",
+                  description: "Create a repository",
+                  integration: "github",
+                  fingerprintVersion: "v1",
+                  indexFingerprint: "new-fingerprint",
+                },
+              ]),
+            schema: () => Effect.fail("schema unavailable"),
+          },
+        } as never,
+        aiSearch: {
+          ...makeAiSearch(),
+          items: {
+            ...makeAiSearchItems(),
+            upload: async (name) => ({ id: `new:${name}`, key: name, status: "queued" }),
+            delete: async (id) => {
+              deleted.push(id);
+            },
+          },
+        },
+        items: makeItemsCollection({
+          list: () => Effect.succeed([githubRow]),
+          putMany: ({ entries }) =>
+            Effect.sync(() => {
+              stored.push(...entries.map((entry) => entry.data));
+            }),
+        }),
+        owner: "org",
+        namespace: "org",
+      });
+
+      expect(result).toMatchObject({ indexed: 1, skipped: 0, removed: 0 });
+      expect(stored[0]?.itemId).toMatch(/^new:tool-[a-z0-9]+\.md$/);
+      expect(stored[0]?.key).toBe(stored[0]?.itemId.replace(/^new:/, ""));
+      expect(deleted).toEqual(["item:github.repos.create.md"]);
+    }),
+  );
+
+  it.effect("records uploaded rows in bounded batches", () =>
+    Effect.gen(function* () {
+      const putManySizes: number[] = [];
+      const manifests = Array.from({ length: 55 }, (_, index) => ({
+        path: `github.default.main.repos.tool${index}`,
+        name: `repos.tool${index}`,
+        description: "Repository tool",
+        integration: "github",
+        fingerprintVersion: "v1",
+        indexFingerprint: `fingerprint-${index}`,
+      }));
+
+      const result = yield* reindexAiSearch({
+        executor: {
+          tools: {
+            manifest: () => Effect.succeed(manifests),
+            schema: () => Effect.fail("schema unavailable"),
+          },
+        } as never,
+        aiSearch: {
+          ...makeAiSearch(),
+          items: {
+            ...makeAiSearchItems(),
+            upload: async (name) => ({ id: `item:${name}`, key: name, status: "queued" }),
+          },
+        },
+        items: makeItemsCollection({
+          list: () => Effect.succeed([]),
+          putMany: ({ entries }) =>
+            Effect.sync(() => {
+              putManySizes.push(entries.length);
+            }),
+        }),
+        owner: "org",
+        namespace: "org",
+      });
+
+      expect(result.indexed).toBe(55);
+      expect(putManySizes).toEqual([25, 25, 5]);
+    }),
+  );
+
+  it.effect("records existing remote rows when a retry sees an orphaned AI Search item", () =>
+    Effect.gen(function* () {
+      const stored: AiSearchItemRow[] = [];
+      const manifest = {
+        path: "github.default.main.repos.create",
+        name: "repos.create",
+        description: "Create a repository",
+        integration: "github",
+        fingerprintVersion: "v1",
+        indexFingerprint: "fingerprint",
+      };
+      const fingerprint = "github.default.main.repos.create:v1:fingerprint:";
+      const itemName = `tool-${cyrb53(`${manifest.path}\u0000${fingerprint}`).toString(36)}.md`;
+
+      const result = yield* reindexAiSearchBatch({
+        executor: {
+          tools: {
+            manifest: () => Effect.succeed([manifest]),
+            schema: () => Effect.fail("schema unavailable"),
+          },
+        } as never,
+        aiSearch: {
+          ...makeAiSearch(),
+          items: {
+            ...makeAiSearchItems(),
+            list: async () => ({
+              result: [{ id: `remote:${itemName}`, key: itemName, status: "completed" }],
+              result_info: { count: 1, total_count: 1, page: 1, per_page: 50 },
+            }),
+            upload: async () => expect.unreachable("Existing remote item should be reused"),
+          },
+        },
+        items: makeItemsCollection({
+          list: () => Effect.succeed([]),
+          putMany: ({ entries }) =>
+            Effect.sync(() => {
+              stored.push(...entries.map((entry) => entry.data));
+            }),
+        }),
+        owner: "org",
+        namespace: "org",
+        offset: 0,
+        pageSize: 128,
+      });
+
+      expect(result.indexed).toBe(1);
+      expect(stored).toMatchObject([
+        {
+          path: manifest.path,
+          itemId: `remote:${itemName}`,
+          key: itemName,
+          fingerprint,
+          status: "completed",
+        },
+      ]);
+    }),
+  );
+
+  it.effect("indexes one requested batch and returns the next offset", () =>
+    Effect.gen(function* () {
+      const stored: string[] = [];
+      const manifests = Array.from({ length: 130 }, (_, index) => ({
+        path: `github.default.main.repos.tool${index}`,
+        name: `repos.tool${index}`,
+        description: "Repository tool",
+        integration: "github",
+        fingerprintVersion: "v1",
+        indexFingerprint: `fingerprint-${index}`,
+      }));
+
+      const result = yield* reindexAiSearchBatch({
+        executor: {
+          tools: {
+            manifest: () => Effect.succeed(manifests),
+            schema: () => Effect.fail("schema unavailable"),
+          },
+        } as never,
+        aiSearch: {
+          ...makeAiSearch(),
+          items: {
+            ...makeAiSearchItems(),
+            upload: async (name) => ({ id: `item:${name}`, key: name, status: "queued" }),
+          },
+        },
+        items: makeItemsCollection({
+          list: () => Effect.succeed([]),
+          putMany: ({ entries }) =>
+            Effect.sync(() => {
+              stored.push(...entries.map((entry) => entry.key));
+            }),
+        }),
+        owner: "org",
+        namespace: "org",
+        offset: 0,
+        pageSize: 128,
+      });
+
+      expect(result).toMatchObject({
+        total: 130,
+        indexed: 128,
+        skipped: 0,
+        removed: 0,
+        offset: 0,
+        pageSize: 128,
+        nextOffset: 128,
+      });
+      expect(stored).toHaveLength(128);
+    }),
+  );
+
+  it.effect("retries rows whose remote AI Search item is errored", () =>
+    Effect.gen(function* () {
+      let uploadCount = 0;
+      const manifest = {
+        path: "github.default.main.repos.create",
+        name: "repos.create",
+        description: "Create a repository",
+        integration: "github",
+        fingerprintVersion: "v1",
+        indexFingerprint: "fingerprint",
+      };
+      const existing = {
+        ...githubRow,
+        data: {
+          ...githubRow.data,
+          fingerprint: "github.default.main.repos.create:v1:fingerprint:",
+        },
+      };
+
+      const result = yield* reindexAiSearch({
+        executor: {
+          tools: {
+            manifest: () => Effect.succeed([manifest]),
+            schema: () => Effect.fail("schema unavailable"),
+          },
+        } as never,
+        aiSearch: {
+          ...makeAiSearch(),
+          items: {
+            ...makeAiSearchItems(),
+            list: async () => ({
+              result: [
+                {
+                  id: existing.data.itemId,
+                  key: existing.data.key,
+                  status: "error",
+                },
+              ],
+              result_info: { count: 1, total_count: 1, page: 1, per_page: 50 },
+            }),
+            upload: async (name) => {
+              uploadCount += 1;
+              return { id: `retry:${name}`, key: name, status: "queued" };
+            },
+          },
+        },
+        items: makeItemsCollection({
+          list: () => Effect.succeed([existing]),
+          putMany: () => Effect.void,
+        }),
+        owner: "org",
+        namespace: "org",
+      });
+
+      expect(result).toMatchObject({ indexed: 1, skipped: 0 });
+      expect(uploadCount).toBe(1);
+    }),
+  );
+
+  it.effect("uses a bounded AI Search item name for long tool paths", () =>
+    Effect.gen(function* () {
+      const uploadedNames: string[] = [];
+      const longPath = [
+        "cloudflare_api",
+        "org",
+        "aryalabs",
+        "accessBookmarkApplicationsDeprecated",
+        "accessBookmarkApplicationsDeprecatedCreateABookmarkApplication",
+      ].join(".");
+
+      yield* reindexAiSearch({
+        executor: {
+          tools: {
+            manifest: () =>
+              Effect.succeed([
+                {
+                  path: longPath,
+                  name: "Create a bookmark application",
+                  description: "Create a bookmark application",
+                  integration: "cloudflare_api",
+                  fingerprintVersion: "v1",
+                  indexFingerprint: "fingerprint",
+                },
+              ]),
+            schema: () => Effect.fail("schema unavailable"),
+          },
+        } as never,
+        aiSearch: {
+          ...makeAiSearch(),
+          items: {
+            ...makeAiSearchItems(),
+            upload: async (name) => {
+              uploadedNames.push(name);
+              return { id: `item:${name}`, key: name, status: "queued" };
+            },
+          },
+        },
+        items: makeItemsCollection({
+          list: () => Effect.succeed([]),
+          putMany: () => Effect.void,
+        }),
+        owner: "org",
+        namespace: "org",
+      });
+
+      expect(uploadedNames).toHaveLength(1);
+      expect(uploadedNames[0]).toMatch(/^tool-[a-z0-9]+\.md$/);
+      expect(uploadedNames[0]?.length).toBeLessThan(64);
+    }),
+  );
 });
diff --git a/packages/plugins/semantic-search/src/sdk/ai-search.ts b/packages/plugins/semantic-search/src/sdk/ai-search.ts
index 9ac29a9f6..6b7ec42f0 100644
--- a/packages/plugins/semantic-search/src/sdk/ai-search.ts
+++ b/packages/plugins/semantic-search/src/sdk/ai-search.ts
@@ -1,3 +1,8 @@
+import type {
+  AiSearchInstance,
+  AiSearchItemInfo,
+  AiSearchSearchResponse,
+} from "@cloudflare/workers-types";
 import {
   ExecutionToolError,
   type Executor,
@@ -16,7 +21,10 @@ import {
   type ToolSearchDocument,
 } from "./documents";
 import { SemanticSearchError } from "./errors";
+import { cyrb53 } from "./fingerprint";
 import type {
+  SemanticSearchReindexBatchInput,
+  SemanticSearchReindexBatchResult,
   SemanticSearchRefreshResult,
   SemanticSearchResultPage,
   SemanticSearchStatus,
@@ -24,74 +32,8 @@ import type {
 } from "./tool-search-backend";
 import type { ToolSearchIndex } from "./tool-search-index";
 
-export interface AiSearchUploadedItem {
-  readonly id: string;
-  readonly key: string;
-}
-
-export interface AiSearchListedItem {
-  readonly id: string;
-  readonly key: string;
-  readonly status: string;
-  readonly metadata?: Readonly<Record<string, string>>;
-}
-
-export interface AiSearchInstance {
-  readonly items: {
-    readonly upload: (
-      name: string,
-      content: string | ArrayBuffer | ReadableStream,
-      options?: { readonly metadata?: Readonly<Record<string, string>> },
-    ) => Promise<AiSearchUploadedItem>;
-    readonly list: (input?: {
-      readonly page?: number;
-      readonly per_page?: number;
-      readonly status?: string;
-      readonly sort_by?: string;
-      readonly search?: string;
-      readonly source?: string;
-    }) => Promise<{
-      readonly result: readonly AiSearchListedItem[];
-      readonly result_info?: {
-        readonly count?: number;
-        readonly total_count?: number;
-        readonly page?: number;
-        readonly per_page?: number;
-      };
-    }>;
-    readonly delete: (itemId: string) => Promise<void>;
-  };
-  readonly search: (input: {
-    readonly messages: readonly [{ readonly role: "user"; readonly content: string }];
-    readonly ai_search_options?: {
-      readonly retrieval?: {
-        readonly retrieval_type?: "vector" | "keyword" | "hybrid";
-        readonly max_num_results?: number;
-        readonly metadata_only?: boolean;
-        readonly return_on_failure?: boolean;
-      };
-      readonly reranking?: { readonly enabled?: boolean };
-    };
-  }) => Promise<AiSearchSearchResponse>;
-}
-
-export interface AiSearchChunk {
-  readonly id: string;
-  readonly score: number;
-  readonly text?: string;
-  readonly item?: {
-    readonly key?: string;
-    readonly metadata?: Readonly<Record<string, string>>;
-  };
-}
-
-export interface AiSearchSearchResponse {
-  readonly search_query?: string;
-  readonly chunks?: readonly AiSearchChunk[];
-}
-
 export interface AiSearchToolSearchBackendOptions {
-  readonly aiSearch: AiSearchInstance | undefined;
+  readonly aiSearch: Pick<AiSearchInstance, "items" | "search"> | undefined;
   readonly namespace?: string;
 }
 
@@ -103,6 +45,8 @@ export interface AiSearchToolSearchBackendStorage {
 }
 
 const DEFAULT_SEARCH_LIMIT = 20;
+const AI_SEARCH_UPLOAD_CONCURRENCY = 2;
+const AI_SEARCH_UPLOAD_BATCH_SIZE = 25;
 
 const nowIso = (): string => new Date().toISOString();
 
@@ -111,7 +55,16 @@ const toStatus = (status: string | undefined): AiSearchItemStatus =>
     ? status
     : "queued";
 
-const toItemName = (document: ToolSearchDocument): string => `${document.path}.md`;
+const toItemName = (document: ToolSearchDocument): string =>
+  `tool-${cyrb53(`${document.path}\u0000${document.fingerprint}`).toString(36)}.md`;
+
+const normalizeBatchInput = (
+  input: SemanticSearchReindexBatchInput,
+): SemanticSearchReindexBatchInput => ({
+  offset: Math.max(0, Math.floor(input.offset)),
+  pageSize: Math.max(1, Math.floor(input.pageSize)),
+  ...(input.maxTools === undefined ? {} : { maxTools: Math.max(0, Math.floor(input.maxTools)) }),
+});
 
 const mapStorageError =
   (message: string) =>
@@ -146,7 +99,7 @@ const unavailableIndex: ToolSearchIndex.Service = {
 };
 
 const deleteItem = (
-  aiSearch: AiSearchInstance,
+  aiSearch: Pick<AiSearchInstance, "items">,
   itemId: string,
 ): Effect.Effect<void, SemanticSearchError> =>
   Effect.tryPromise({
@@ -156,118 +109,262 @@ const deleteItem = (
   }).pipe(Effect.asVoid);
 
 const deleteItemBestEffort = (
-  aiSearch: AiSearchInstance,
+  aiSearch: Pick<AiSearchInstance, "items">,
   itemId: string,
 ): Effect.Effect<void, never> => deleteItem(aiSearch, itemId).pipe(Effect.catch(() => Effect.void));
 
-const putIndexedItem = (
-  items: ItemsCollection,
-  owner: "user" | "org",
+function listAiSearchItems(
+  aiSearch: Pick<AiSearchInstance, "items">,
+): Effect.Effect<readonly AiSearchItemInfo[], SemanticSearchError> {
+  return Effect.gen(function* () {
+    const all: AiSearchItemInfo[] = [];
+    let page = 1;
+    while (true) {
+      const result = yield* Effect.tryPromise({
+        try: () => aiSearch.items.list({ page, per_page: 50 }),
+        catch: (cause) =>
+          new SemanticSearchError({ message: "Failed to list AI Search items.", cause }),
+      });
+      all.push(...result.result);
+      const info = result.result_info;
+      const total = info?.total_count;
+      const perPage = info?.per_page ?? 50;
+      if (total !== undefined ? all.length >= total : result.result.length < perPage) break;
+      page += 1;
+    }
+    return all;
+  });
+}
+
+const toIndexedItemRow = (
   document: ToolSearchDocument,
-  uploaded: AiSearchUploadedItem,
-): Effect.Effect<void, SemanticSearchError> =>
-  items
-    .put({
-      owner,
+  uploaded: AiSearchItemInfo,
+): AiSearchItemRow => ({
+  path: document.path,
+  key: uploaded.key,
+  itemId: uploaded.id,
+  name: document.name,
+  description: document.description,
+  integration: document.integration,
+  connection: document.connection,
+  plugin: document.plugin,
+  fingerprint: document.fingerprint,
+  status: toStatus(uploaded.status),
+  updatedAt: nowIso(),
+});
+
+interface UploadedDocument {
+  readonly deleteOnStorageFailure: boolean;
+  readonly previousItemId?: string;
+  readonly uploadedItemId: string;
+  readonly key: string;
+  readonly row: AiSearchItemRow;
+}
+
+const uploadDocument = (
+  aiSearch: Pick<AiSearchInstance, "items">,
+  document: ToolSearchDocument,
+  previous: AiSearchItemRow | undefined,
+  remote: AiSearchItemInfo | undefined,
+): Effect.Effect<UploadedDocument, SemanticSearchError> =>
+  Effect.gen(function* () {
+    const itemName = toItemName(document);
+    if (remote !== undefined && remote.status !== "error") {
+      return {
+        deleteOnStorageFailure: false,
+        uploadedItemId: remote.id,
+        key: document.path,
+        row: toIndexedItemRow(document, remote),
+      };
+    }
+
+    if (remote !== undefined) {
+      yield* deleteItemBestEffort(aiSearch, remote.id);
+    }
+
+    const uploaded = yield* Effect.tryPromise({
+      try: () =>
+        aiSearch.items.upload(itemName, document.content, {
+          metadata: document.metadata,
+        }),
+      catch: mapUploadError(document),
+    });
+
+    return {
+      deleteOnStorageFailure: true,
+      ...(previous !== undefined && previous.key !== itemName
+        ? { previousItemId: previous.itemId }
+        : {}),
+      uploadedItemId: uploaded.id,
       key: document.path,
-      data: {
-        path: document.path,
-        key: uploaded.key,
-        itemId: uploaded.id,
-        name: document.name,
-        description: document.description,
-        integration: document.integration,
-        connection: document.connection,
-        plugin: document.plugin,
-        fingerprint: document.fingerprint,
-        status: "queued",
-        updatedAt: nowIso(),
-      },
-    })
-    .pipe(Effect.asVoid, Effect.mapError(mapStorageError("Failed to record AI Search item.")));
+      row: toIndexedItemRow(document, uploaded),
+    };
+  });
 
-export const reindexAiSearch = (input: {
+export const reindexAiSearchBatch = (input: {
   readonly executor: Executor;
-  readonly aiSearch: AiSearchInstance | undefined;
+  readonly aiSearch: Pick<AiSearchInstance, "items"> | undefined;
   readonly items: ItemsCollection;
   readonly owner: "user" | "org";
   readonly namespace: string;
+  readonly offset: number;
+  readonly pageSize: number;
   readonly maxTools?: number;
-}): Effect.Effect<SemanticSearchRefreshResult, SemanticSearchError> => {
+}): Effect.Effect<SemanticSearchReindexBatchResult, SemanticSearchError> => {
   if (!input.aiSearch) return notConfigured();
   const aiSearch = input.aiSearch;
   return Effect.gen(function* () {
-    const manifests = yield* listToolManifests(input.executor, { maxTools: input.maxTools });
+    const batch = normalizeBatchInput(input);
+    const manifests = yield* listToolManifests(input.executor, { maxTools: batch.maxTools });
+    const page = manifests.slice(batch.offset, batch.offset + batch.pageSize);
+    const nextOffset =
+      batch.offset + page.length < manifests.length ? batch.offset + page.length : null;
     const livePaths = new Set(manifests.map((manifest) => manifest.path));
     const existingEntries = yield* input.items
       .list()
       .pipe(Effect.mapError(mapStorageError("Failed to list AI Search item rows.")));
     const existingByPath = new Map(existingEntries.map((entry) => [entry.key, entry.data]));
-    let indexed = 0;
+    const remoteByKey = new Map(
+      (yield* listAiSearchItems(aiSearch)).map((item) => [item.key, item]),
+    );
     let skipped = 0;
+    const changed: {
+      readonly manifest: (typeof manifests)[number];
+      readonly previous?: AiSearchItemRow;
+    }[] = [];
 
-    for (const manifest of manifests) {
+    for (const manifest of page) {
       const previous = existingByPath.get(manifest.path);
       const fingerprint = toolItemKey(manifest);
-      if (previous?.fingerprint === fingerprint) {
+      const remote = previous === undefined ? undefined : remoteByKey.get(previous.key);
+      if (
+        previous?.fingerprint === fingerprint &&
+        remote !== undefined &&
+        remote.status !== "error"
+      ) {
         skipped += 1;
         continue;
       }
-      const document = yield* collectToolSearchDocument(input.executor, manifest);
-      const uploaded = yield* Effect.tryPromise({
-        try: () =>
-          aiSearch.items.upload(toItemName(document), document.content, {
-            metadata: document.metadata,
-          }),
-        catch: mapUploadError(document),
+      changed.push({
+        manifest,
+        ...(previous === undefined ? {} : { previous }),
       });
-      yield* putIndexedItem(input.items, input.owner, document, uploaded).pipe(
-        Effect.tapError(() => deleteItemBestEffort(aiSearch, uploaded.id)),
+    }
+
+    const uploaded = yield* Effect.forEach(
+      changed,
+      ({ manifest, previous }) =>
+        collectToolSearchDocument(input.executor, manifest).pipe(
+          Effect.flatMap((document) =>
+            uploadDocument(aiSearch, document, previous, remoteByKey.get(toItemName(document))),
+          ),
+        ),
+      { concurrency: AI_SEARCH_UPLOAD_CONCURRENCY },
+    );
+
+    if (uploaded.length > 0) {
+      yield* input.items
+        .putMany({
+          owner: input.owner,
+          entries: uploaded.map((entry) => ({
+            key: entry.key,
+            data: entry.row,
+          })),
+        })
+        .pipe(
+          Effect.tapError(() =>
+            Effect.forEach(
+              uploaded.filter((entry) => entry.deleteOnStorageFailure),
+              (entry) => deleteItemBestEffort(aiSearch, entry.uploadedItemId),
+              {
+                concurrency: AI_SEARCH_UPLOAD_CONCURRENCY,
+                discard: true,
+              },
+            ),
+          ),
+          Effect.mapError(mapStorageError("Failed to record AI Search item rows.")),
+        );
+
+      yield* Effect.forEach(
+        uploaded,
+        (entry) =>
+          entry.previousItemId === undefined
+            ? Effect.void
+            : deleteItemBestEffort(aiSearch, entry.previousItemId),
+        { concurrency: AI_SEARCH_UPLOAD_CONCURRENCY, discard: true },
       );
-      if (previous) {
-        yield* deleteItemBestEffort(aiSearch, previous.itemId);
-      }
-      indexed += 1;
     }
 
-    let removed = 0;
-    for (const entry of existingEntries) {
-      if (livePaths.has(entry.key)) continue;
+    const removedEntries =
+      batch.maxTools === undefined && nextOffset === null
+        ? existingEntries.filter((entry) => !livePaths.has(entry.key))
+        : [];
+    if (removedEntries.length > 0) {
       yield* input.items
-        .remove({ owner: input.owner, key: entry.key })
-        .pipe(Effect.mapError(mapStorageError("Failed to remove stale AI Search item row.")));
-      yield* deleteItemBestEffort(aiSearch, entry.data.itemId);
-      removed += 1;
+        .removeMany({
+          owner: input.owner,
+          keys: removedEntries.map((entry) => entry.key),
+        })
+        .pipe(Effect.mapError(mapStorageError("Failed to remove stale AI Search item rows.")));
+      yield* Effect.forEach(
+        removedEntries,
+        (entry) => deleteItemBestEffort(aiSearch, entry.data.itemId),
+        { concurrency: AI_SEARCH_UPLOAD_CONCURRENCY, discard: true },
+      );
     }
 
-    return { namespace: input.namespace, total: manifests.length, indexed, skipped, removed };
+    return {
+      namespace: input.namespace,
+      total: manifests.length,
+      indexed: uploaded.length,
+      skipped,
+      removed: removedEntries.length,
+      offset: batch.offset,
+      pageSize: batch.pageSize,
+      nextOffset,
+    };
   });
 };
 
-const listAiSearchItems = (
-  aiSearch: AiSearchInstance,
-): Effect.Effect<readonly AiSearchListedItem[], SemanticSearchError> =>
+export const reindexAiSearch = (input: {
+  readonly executor: Executor;
+  readonly aiSearch: Pick<AiSearchInstance, "items"> | undefined;
+  readonly items: ItemsCollection;
+  readonly owner: "user" | "org";
+  readonly namespace: string;
+  readonly maxTools?: number;
+}): Effect.Effect<SemanticSearchRefreshResult, SemanticSearchError> =>
   Effect.gen(function* () {
-    const all: AiSearchListedItem[] = [];
-    let page = 1;
-    while (true) {
-      const result = yield* Effect.tryPromise({
-        try: () => aiSearch.items.list({ page, per_page: 50 }),
-        catch: (cause) =>
-          new SemanticSearchError({ message: "Failed to list AI Search items.", cause }),
+    let nextOffset: number | null = 0;
+    let total = 0;
+    let indexed = 0;
+    let skipped = 0;
+    let removed = 0;
+
+    while (nextOffset !== null) {
+      const result: SemanticSearchReindexBatchResult = yield* reindexAiSearchBatch({
+        ...input,
+        offset: nextOffset,
+        pageSize: AI_SEARCH_UPLOAD_BATCH_SIZE,
       });
-      all.push(...result.result);
-      const info = result.result_info;
-      const total = info?.total_count;
-      const perPage = info?.per_page ?? 50;
-      if (total !== undefined ? all.length >= total : result.result.length < perPage) break;
-      page += 1;
+      total = result.total;
+      indexed += result.indexed;
+      skipped += result.skipped;
+      removed += result.removed;
+      nextOffset = result.nextOffset;
     }
-    return all;
+
+    return {
+      namespace: input.namespace,
+      total,
+      indexed,
+      skipped,
+      removed,
+    };
   });
 
 export const statusAiSearch = (input: {
-  readonly aiSearch: AiSearchInstance;
+  readonly aiSearch: Pick<AiSearchInstance, "items">;
   readonly items: ItemsCollection;
   readonly namespace: string;
 }): Effect.Effect<SemanticSearchStatus, SemanticSearchError> =>
@@ -321,23 +418,33 @@ const rowToResult = (row: AiSearchItemRow, score: number): ToolDiscoveryResult =
   score,
 });
 
-const chunkToResult = (chunk: AiSearchChunk): ToolDiscoveryResult | null => {
+const getStringMetadata = (
+  metadata: Readonly<Record<string, unknown>> | undefined,
+  key: string,
+) => {
+  const value = metadata?.[key];
+  return typeof value === "string" ? value : undefined;
+};
+
+const chunkToResult = (
+  chunk: AiSearchSearchResponse["chunks"][number],
+): ToolDiscoveryResult | null => {
   const metadata = chunk.item?.metadata;
-  const path = metadata?.path;
-  const name = metadata?.name;
-  const integration = metadata?.integration;
+  const path = getStringMetadata(metadata, "path");
+  const name = getStringMetadata(metadata, "name");
+  const integration = getStringMetadata(metadata, "integration");
   if (!path || !name || !integration) return null;
   return {
     path,
     name,
-    description: metadata.description,
+    description: getStringMetadata(metadata, "description"),
     integration,
     score: chunk.score,
   };
 };
 
 export const makeAiSearchToolDiscoveryProvider = (deps: {
-  readonly aiSearch: AiSearchInstance | undefined;
+  readonly aiSearch: Pick<AiSearchInstance, "search"> | undefined;
   readonly items: ItemsCollection | undefined;
 }): ToolDiscoveryProvider | undefined => {
   if (!deps.aiSearch) return undefined;
@@ -350,6 +457,23 @@ export const makeAiSearchToolDiscoveryProvider = (deps: {
           return { items: [], total: 0, hasMore: false, nextOffset: null };
         }
         const limit = Math.min(50, Math.max(1, input.limit + input.offset));
+        const hasLocalRows = deps.items !== undefined;
+        const rowsByKey =
+          deps.items === undefined
+            ? undefined
+            : yield* deps.items.list().pipe(
+                Effect.map((rows) => new Map(rows.map((row) => [row.data.key, row.data]))),
+                Effect.mapError(
+                  (cause) =>
+                    new ExecutionToolError({
+                      message: "AI Search tool search failed.",
+                      cause,
+                    }),
+                ),
+              );
+        if (hasLocalRows && rowsByKey?.size === 0) {
+          return { items: [], total: 0, hasMore: false, nextOffset: null };
+        }
         const response = yield* Effect.tryPromise({
           try: () =>
             aiSearch.search({
@@ -367,20 +491,6 @@ export const makeAiSearchToolDiscoveryProvider = (deps: {
             new ExecutionToolError({ message: "AI Search tool search failed.", cause }),
         });
 
-        const hasLocalRows = deps.items !== undefined;
-        const rowsByKey =
-          deps.items === undefined
-            ? undefined
-            : yield* deps.items.list().pipe(
-                Effect.map((rows) => new Map(rows.map((row) => [row.data.key, row.data]))),
-                Effect.mapError(
-                  (cause) =>
-                    new ExecutionToolError({
-                      message: "AI Search tool search failed.",
-                      cause,
-                    }),
-                ),
-              );
         const bestByPath = new Map<string, ToolDiscoveryResult>();
         for (const chunk of response.chunks ?? []) {
           const row = chunk.item?.key ? rowsByKey?.get(chunk.item.key) : undefined;
@@ -438,6 +548,15 @@ export const makeAiSearchToolSearchBackend = (
             owner: storage.owner,
             namespace,
           }),
+        reindexBatch: (executor, input) =>
+          reindexAiSearchBatch({
+            executor,
+            aiSearch: options.aiSearch,
+            items: storage.aiSearchItems,
+            owner: storage.owner,
+            namespace,
+            ...input,
+          }),
         sweep: () =>
           Effect.succeed({
             namespace,
diff --git a/packages/plugins/semantic-search/src/sdk/documents.ts b/packages/plugins/semantic-search/src/sdk/documents.ts
index c0c149dac..b3ccf3df5 100644
--- a/packages/plugins/semantic-search/src/sdk/documents.ts
+++ b/packages/plugins/semantic-search/src/sdk/documents.ts
@@ -330,9 +330,10 @@ export const collectToolSearchDocument = (
         metadata: {
           path,
           name,
-          description: description.slice(0, 1_000),
+          description: description.slice(0, 500),
           integration: manifest.integration,
           connection: manifest.connection ?? "",
+          plugin: manifest.pluginId ?? "",
         },
       };
     }),
diff --git a/packages/plugins/semantic-search/src/sdk/embedder-cloudflare.test.ts b/packages/plugins/semantic-search/src/sdk/embedder-cloudflare.test.ts
new file mode 100644
index 000000000..b932b58fd
--- /dev/null
+++ b/packages/plugins/semantic-search/src/sdk/embedder-cloudflare.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it } from "@effect/vitest";
+import type {
+  Ai,
+  Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input,
+  Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Output,
+} from "@cloudflare/workers-types";
+import { Effect, Exit } from "effect";
+
+import {
+  DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_DIMENSIONS,
+  DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL,
+  makeCloudflareWorkersAiEmbedder,
+} from "./embedder-cloudflare";
+
+describe("makeCloudflareWorkersAiEmbedder", () => {
+  it.effect("embeds documents and queries with the qwen model by default", () =>
+    Effect.gen(function* () {
+      const mutableCalls: unknown[] = [];
+      const ai = {
+        run: (async (
+          model: typeof DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL,
+          input: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input,
+        ): Promise<Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Output> => {
+          mutableCalls.push({ model, input });
+          const values = input.documents ?? input.queries ?? input.text ?? [];
+          const count = Array.isArray(values) ? values.length : 1;
+          return {
+            data: Array.from({ length: count }, (_, index) => [index + 1, index + 2]),
+            shape: [count, 2],
+          };
+        }) as Ai<{
+          readonly "@cf/qwen/qwen3-embedding-0.6b": {
+            readonly inputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input;
+            readonly postProcessedOutputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Output;
+          };
+        }>["run"],
+      } satisfies Pick<
+        Ai<{
+          readonly "@cf/qwen/qwen3-embedding-0.6b": {
+            readonly inputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input;
+            readonly postProcessedOutputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Output;
+          };
+        }>,
+        "run"
+      >;
+      const embedder = makeCloudflareWorkersAiEmbedder({ ai, dimensions: 2 });
+
+      const docs = yield* embedder.embedDocuments(["alpha", "beta"]);
+      const query = yield* embedder.embedQuery("alpha");
+
+      expect(embedder.model).toBe(DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL);
+      expect(embedder.dimensions).toBe(2);
+      expect(docs).toEqual([
+        [1, 2],
+        [2, 3],
+      ]);
+      expect(query).toEqual([1, 2]);
+      expect(mutableCalls).toEqual([
+        {
+          model: DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL,
+          input: { documents: ["alpha", "beta"] },
+        },
+        {
+          model: DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL,
+          input: { queries: ["alpha"] },
+        },
+      ]);
+      expect(DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_DIMENSIONS).toBe(1024);
+    }),
+  );
+
+  it.effect("rejects vectors whose dimensions do not match the embedder", () =>
+    Effect.gen(function* () {
+      const ai = {
+        run: (async (
+          _model: typeof DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL,
+          _input: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input,
+        ): Promise<Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Output> => ({
+          data: [[1, 2, 3]],
+          shape: [1, 3],
+        })) as Ai<{
+          readonly "@cf/qwen/qwen3-embedding-0.6b": {
+            readonly inputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input;
+            readonly postProcessedOutputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Output;
+          };
+        }>["run"],
+      } satisfies Pick<
+        Ai<{
+          readonly "@cf/qwen/qwen3-embedding-0.6b": {
+            readonly inputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input;
+            readonly postProcessedOutputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Output;
+          };
+        }>,
+        "run"
+      >;
+      const embedder = makeCloudflareWorkersAiEmbedder({ ai, dimensions: 2 });
+
+      const exit = yield* Effect.exit(embedder.embedDocuments(["alpha"]));
+
+      expect(Exit.isFailure(exit)).toBe(true);
+    }),
+  );
+});
diff --git a/packages/plugins/semantic-search/src/sdk/embedder-cloudflare.ts b/packages/plugins/semantic-search/src/sdk/embedder-cloudflare.ts
new file mode 100644
index 000000000..29858070e
--- /dev/null
+++ b/packages/plugins/semantic-search/src/sdk/embedder-cloudflare.ts
@@ -0,0 +1,93 @@
+import type {
+  Ai,
+  Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input,
+  Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Output,
+} from "@cloudflare/workers-types";
+import { Effect } from "effect";
+
+import type { ToolEmbedder } from "./embedder";
+import { SemanticSearchError } from "./errors";
+
+export const DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL = "@cf/qwen/qwen3-embedding-0.6b";
+export const DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_DIMENSIONS = 1024;
+
+export interface CloudflareWorkersAiEmbedderOptions {
+  readonly ai: Pick<
+    Ai<{
+      readonly "@cf/qwen/qwen3-embedding-0.6b": {
+        readonly inputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input;
+        readonly postProcessedOutputs: Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Output;
+      };
+    }>,
+    "run"
+  >;
+  readonly dimensions?: number;
+  readonly batchSize?: number;
+  readonly documentInstruction?: string;
+  readonly queryInstruction?: string;
+}
+
+const DEFAULT_BATCH_SIZE = 32;
+
+const chunk = <A>(items: readonly A[], size: number): A[][] => {
+  const safe = Math.max(1, Math.floor(size));
+  const out: A[][] = [];
+  for (let i = 0; i < items.length; i += safe) out.push(items.slice(i, i + safe));
+  return out;
+};
+
+export const makeCloudflareWorkersAiEmbedder = (
+  options: CloudflareWorkersAiEmbedderOptions,
+): ToolEmbedder => {
+  const model = DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL;
+  const dimensions = options.dimensions ?? DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_DIMENSIONS;
+  const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+
+  const embedBatch = (
+    kind: "documents" | "queries",
+    texts: readonly string[],
+    instruction: string | undefined,
+  ): Effect.Effect<readonly (readonly number[])[], SemanticSearchError> => {
+    if (texts.length === 0) return Effect.succeed([]);
+    return Effect.gen(function* () {
+      const response = yield* Effect.tryPromise({
+        try: () =>
+          options.ai.run(model, {
+            [kind]: [...texts],
+            ...(instruction ? { instruction } : {}),
+          } satisfies Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input),
+        catch: (cause) =>
+          new SemanticSearchError({
+            message: `Cloudflare Workers AI embedding failed for ${model}.`,
+            cause,
+          }),
+      });
+      const embeddings = response.data;
+      if (
+        embeddings === undefined ||
+        embeddings.length !== texts.length ||
+        !embeddings.every((vector) => vector.length === dimensions)
+      ) {
+        return yield* new SemanticSearchError({
+          message: `Cloudflare Workers AI returned ${embeddings?.length ?? 0} vectors for ${texts.length} inputs with expected dimension ${dimensions}.`,
+        });
+      }
+      return embeddings;
+    });
+  };
+
+  return {
+    model,
+    dimensions,
+    embedDocuments: (texts) =>
+      Effect.forEach(
+        chunk(texts, batchSize),
+        (group) => embedBatch("documents", group, options.documentInstruction),
+        { concurrency: 1 },
+      ).pipe(Effect.map((groups) => groups.flat())),
+    embedQuery: (text) =>
+      embedBatch("queries", [text], options.queryInstruction).pipe(
+        Effect.map((vectors) => vectors[0] ?? []),
+      ),
+  };
+};
diff --git a/packages/plugins/semantic-search/src/sdk/embedding-service.ts b/packages/plugins/semantic-search/src/sdk/embedding-service.ts
index 7daad9fd4..05eaea87b 100644
--- a/packages/plugins/semantic-search/src/sdk/embedding-service.ts
+++ b/packages/plugins/semantic-search/src/sdk/embedding-service.ts
@@ -1,6 +1,10 @@
 import { Context, Layer } from "effect";
 
 import { makeHashEmbedder } from "./embedder-hash";
+import {
+  makeCloudflareWorkersAiEmbedder,
+  type CloudflareWorkersAiEmbedderOptions,
+} from "./embedder-cloudflare";
 import {
   makeOpenAiCompatibleEmbedder,
   type OpenAiCompatibleEmbedderOptions,
@@ -26,5 +30,10 @@ export const openAiCompatibleEmbedderLayer = (
 ): Layer.Layer<EmbedderService> =>
   Layer.succeed(EmbedderService)(makeOpenAiCompatibleEmbedder(options));
 
+export const cloudflareWorkersAiEmbedderLayer = (
+  options: CloudflareWorkersAiEmbedderOptions,
+): Layer.Layer<EmbedderService> =>
+  Layer.succeed(EmbedderService)(makeCloudflareWorkersAiEmbedder(options));
+
 export const hashEmbedderLayer = (dimensions?: number): Layer.Layer<EmbedderService> =>
   Layer.succeed(EmbedderService)(makeHashEmbedder(dimensions));
diff --git a/packages/plugins/semantic-search/src/sdk/index.ts b/packages/plugins/semantic-search/src/sdk/index.ts
index 9b0c50a7f..5015d0bae 100644
--- a/packages/plugins/semantic-search/src/sdk/index.ts
+++ b/packages/plugins/semantic-search/src/sdk/index.ts
@@ -7,6 +7,8 @@ export {
   ToolSearchBackend,
   makeVectorToolSearchBackend,
   type SemanticSearchRefreshResult,
+  type SemanticSearchReindexBatchInput,
+  type SemanticSearchReindexBatchResult,
   type SemanticSearchResultPage,
   type SemanticSearchStatus,
   type ToolSearchBackend as ToolSearchBackendType,
@@ -18,14 +20,10 @@ export {
   makeAiSearchToolDiscoveryProvider,
   makeAiSearchToolSearchBackend,
   reindexAiSearch,
+  reindexAiSearchBatch,
   statusAiSearch,
-  type AiSearchChunk,
-  type AiSearchInstance,
-  type AiSearchListedItem,
-  type AiSearchSearchResponse,
   type AiSearchToolSearchBackendOptions,
   type AiSearchToolSearchBackendStorage,
-  type AiSearchUploadedItem,
 } from "./ai-search";
 export { makeVectorToolDiscoveryProvider } from "./provider";
 export {
@@ -35,6 +33,11 @@ export {
   type ToolEmbedder,
   type GeminiEmbedderOptions,
 } from "./embedder";
+export {
+  makeCloudflareWorkersAiEmbedder,
+  DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_DIMENSIONS,
+  DEFAULT_CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL,
+} from "./embedder-cloudflare";
 export { type VectorStore, type VectorMatch, type VectorMatches, type VectorInput } from "./store";
 export { makeVectorizeStore, type VectorizeIndex, MAX_TOP_K } from "./store-cloudflare";
 export {
diff --git a/packages/plugins/semantic-search/src/sdk/plugin.test.ts b/packages/plugins/semantic-search/src/sdk/plugin.test.ts
index cd3b4d752..4079cbabd 100644
--- a/packages/plugins/semantic-search/src/sdk/plugin.test.ts
+++ b/packages/plugins/semantic-search/src/sdk/plugin.test.ts
@@ -29,6 +29,7 @@ const extensionWith = (provider: ToolDiscoveryProvider) =>
       provider,
       index: () => undefined as never,
       reindex: () => Effect.die("unused"),
+      reindexBatch: () => Effect.die("unused"),
       sweep: () => Effect.die("unused"),
       search: (executor, input) =>
         provider
@@ -110,6 +111,7 @@ describe("semanticSearchPlugin — backend storage", () => {
       namespace: "default",
       index: () => undefined as never,
       reindex: () => Effect.die("unused"),
+      reindexBatch: () => Effect.die("unused"),
       sweep: () => Effect.die("unused"),
       search: () => Effect.die("unused"),
       status: () => Effect.die("unused"),
diff --git a/packages/plugins/semantic-search/src/sdk/plugin.ts b/packages/plugins/semantic-search/src/sdk/plugin.ts
index 442788d9e..5cb4098c5 100644
--- a/packages/plugins/semantic-search/src/sdk/plugin.ts
+++ b/packages/plugins/semantic-search/src/sdk/plugin.ts
@@ -20,6 +20,10 @@ export const makeSemanticSearchExtension = (deps: {
 }) => ({
   index: (executor: Executor) => deps.backend?.index(executor) ?? unconfiguredIndex,
   reindex: (executor: Executor) => deps.backend?.reindex(executor) ?? notConfigured(),
+  reindexBatch: (
+    executor: Executor,
+    input: Parameters<NonNullable<ToolSearchBackend["reindexBatch"]>>[1],
+  ) => deps.backend?.reindexBatch(executor, input) ?? notConfigured(),
   sweep: (executor: Executor) => deps.backend?.sweep(executor) ?? notConfigured(),
   search: (
     executor: Executor,
diff --git a/packages/plugins/semantic-search/src/sdk/tool-search-backend.ts b/packages/plugins/semantic-search/src/sdk/tool-search-backend.ts
index 00fc6be78..d28917318 100644
--- a/packages/plugins/semantic-search/src/sdk/tool-search-backend.ts
+++ b/packages/plugins/semantic-search/src/sdk/tool-search-backend.ts
@@ -11,6 +11,10 @@ import { Effect } from "effect";
 
 import { type Chunker, makeFacetChunker } from "./chunker";
 import { indexChunks, indexJobs, indexRuns, toolFingerprints } from "./collections";
+import {
+  makeCloudflareWorkersAiEmbedder,
+  type CloudflareWorkersAiEmbedderOptions,
+} from "./embedder-cloudflare";
 import { makeGeminiEmbedder, type GeminiEmbedderOptions, type ToolEmbedder } from "./embedder";
 import { SemanticSearchError } from "./errors";
 import { makeHybridToolDiscoveryProvider } from "./hybrid";
@@ -51,6 +55,18 @@ export interface SemanticSearchRefreshResult {
   readonly removed: number;
 }
 
+export interface SemanticSearchReindexBatchInput {
+  readonly offset: number;
+  readonly pageSize: number;
+  readonly maxTools?: number;
+}
+
+export interface SemanticSearchReindexBatchResult extends SemanticSearchRefreshResult {
+  readonly offset: number;
+  readonly pageSize: number;
+  readonly nextOffset: number | null;
+}
+
 export interface ToolSearchBackend {
   readonly namespace: string;
   readonly provider?: ToolDiscoveryProvider;
@@ -58,6 +74,10 @@ export interface ToolSearchBackend {
   readonly reindex: (
     executor: Executor,
   ) => Effect.Effect<SemanticSearchRefreshResult, SemanticSearchError>;
+  readonly reindexBatch: (
+    executor: Executor,
+    input: SemanticSearchReindexBatchInput,
+  ) => Effect.Effect<SemanticSearchReindexBatchResult, SemanticSearchError>;
   readonly sweep: (executor: Executor) => Effect.Effect<
     {
       readonly namespace: string;
@@ -94,6 +114,7 @@ export interface ToolSearchBackendFactory<TStorage = unknown> {
 export interface VectorToolSearchBackendOptions {
   readonly namespace?: string;
   readonly store: VectorStore;
+  readonly workersAi?: CloudflareWorkersAiEmbedderOptions["ai"];
   readonly geminiApiKey?: string;
   readonly model?: string;
   readonly dimensions?: number;
@@ -125,6 +146,13 @@ export const unconfiguredIndex: ToolSearchIndex.Service = {
 
 const makeVectorEmbedder = (options: VectorToolSearchBackendOptions): ToolEmbedder | undefined =>
   options.embedder ??
+  (options.workersAi
+    ? makeCloudflareWorkersAiEmbedder({
+        ai: options.workersAi,
+        dimensions: options.dimensions,
+        batchSize: options.embedderBatchSize,
+      })
+    : undefined) ??
   (options.geminiApiKey
     ? makeGeminiEmbedder({
         apiKey: options.geminiApiKey,
@@ -225,6 +253,7 @@ export const makeVectorToolSearchBackend = (
                 partitionCount: DEFAULT_IN_PROCESS_PARTITIONS,
               })
             : notConfigured(),
+        reindexBatch: () => notConfigured(),
         sweep: (executor) =>
           sweepRemoved({
             namespace,