diff --git a/README.md b/README.md
index e5a8853..c45a9d5 100644
--- a/README.md
+++ b/README.md
@@ -136,6 +136,7 @@ await sandbox.destroy();
 | `AskUser` | Ask user clarifying questions | `askUser: true` |
 | `EnterPlanMode` | Enter planning/exploration mode | `planMode: true` |
 | `ExitPlanMode` | Exit planning mode with a plan | `planMode: true` |
+| `codemode` | Write code to orchestrate selected tools via Cloudflare Codemode | `codemode: { executor }` |
 | `Skill` | Execute skills | `skill: { skills }` |
 | `WebSearch` | Search the web | `webSearch: { apiKey }` |
 | `WebFetch` | Fetch URL and process with AI | `webFetch: { apiKey, model }` |
@@ -233,6 +234,10 @@ const { tools, planModeState } = createAgentTools(sandbox, {
     apiKey: process.env.PARALLEL_API_KEY,
     model: anthropic('claude-haiku-4'),
   },
+  codemode: {
+    executor: new DynamicWorkerExecutor({ loader: env.LOADER }),
+    includeTools: ['Read', 'Glob', 'Grep'], // Opt into write tools explicitly
+  },
 
   // Tool-specific config
   tools: {
@@ -251,6 +256,49 @@ const { tools, planModeState } = createAgentTools(sandbox, {
 });
 ```
 
+### Codemode
+
+BashKit can expose a Cloudflare Codemode tool so the model writes code that orchestrates BashKit tools instead of making many individual tool calls. Install `@cloudflare/codemode`, provide an executor, and enable `codemode`:
+
+Cloudflare Codemode currently targets AI SDK v6. BashKit's codemode adapter follows that path; AI SDK v5 support is intentionally not a compatibility goal for codemode.
+
+```typescript
+import { DynamicWorkerExecutor } from '@cloudflare/codemode';
+import { createAgentTools, createPrepareStep } from 'bashkit';
+import { streamText } from 'ai';
+
+const { tools, planModeState } = await createAgentTools(sandbox, {
+  planMode: true,
+  context: { executionPolicy: {} },
+  codemode: {
+    executor: new DynamicWorkerExecutor({ loader: env.LOADER }),
+    includeTools: ['Read', 'Glob', 'Grep', 'Bash'],
+    tools: {
+      // Extra AI SDK tools exposed inside the default bashkit.* namespace
+    },
+    providers: [
+      {
+        name: 'repo',
+        tools: {
+          // Extra tools exposed as repo.*
+        },
+      },
+    ],
+  },
+});
+
+await streamText({
+  model,
+  tools,
+  messages,
+  prepareStep: createPrepareStep({ planModeState }),
+});
+```
+
+By default, generated code calls BashKit tools through BashKit's `bashkit.*` namespace, for example `await bashkit.Grep(...)`. Use `providers` when you want additional named tool groups such as `repo.SummarizeFile(...)`.
+
+Client-intervention tools are excluded from codemode automatically: `AskUser`, `EnterPlanMode`, `ExitPlanMode`, tools without `execute`, and tools with `needsApproval`. Top-level `includeTools` narrows the default `bashkit.*` namespace. Named providers can define their own `includeTools` or `excludeTools`.
+
 ### Configuration Options
 
 #### Global Config
@@ -1003,6 +1051,7 @@ Creates a set of agent tools bound to a sandbox instance.
 ### Optional Tools (also available via config)
 
 - `createAskUserTool(config?)` - Emit a deferred AskUser tool call for the client
+- `createCodemodeTool(tools, config)` - Create a Cloudflare Codemode tool from a filtered tool set
 - `createEnterPlanModeTool(state)` - Enter planning/exploration mode
 - `createExitPlanModeTool(state, onPlanSubmit?)` - Exit planning mode with a plan
 - `createSkillTool(skills)` - Execute loaded skills
diff --git a/bun.lockb b/bun.lockb
index 97fe9ca..a289903 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/docs/src/app/MobileNav.tsx b/docs/src/app/MobileNav.tsx
index 9601b18..c607732 100644
--- a/docs/src/app/MobileNav.tsx
+++ b/docs/src/app/MobileNav.tsx
@@ -10,6 +10,7 @@ const links = [
   { href: "/", label: "Overview" },
   { href: "/getting-started", label: "Getting Started" },
   { href: "/tools", label: "Tools" },
+  { href: "/codemode", label: "Codemode" },
   { href: "/sandboxes", label: "Sandboxes" },
   { href: "/context", label: "Context" },
   { href: "/api-reference", label: "API Reference" },
diff --git a/docs/src/app/SideNav.tsx b/docs/src/app/SideNav.tsx
index 28a7807..4bdb61f 100644
--- a/docs/src/app/SideNav.tsx
+++ b/docs/src/app/SideNav.tsx
@@ -53,6 +53,17 @@ const links: {
       { id: "todowrite", text: "TodoWrite" },
     ],
   },
+  {
+    href: "/codemode",
+    label: "Codemode",
+    items: [
+      { id: "overview", text: "Overview" },
+      { id: "setup", text: "Setup" },
+      { id: "batched-workflows", text: "Batched Workflows" },
+      { id: "tool-selection", text: "Tool Selection" },
+      { id: "policy", text: "Policy" },
+    ],
+  },
   {
     href: "/sandboxes",
     label: "Sandboxes",
diff --git a/docs/src/app/api-reference/page.tsx b/docs/src/app/api-reference/page.tsx
index 15cf511..f9e8cff 100644
--- a/docs/src/app/api-reference/page.tsx
+++ b/docs/src/app/api-reference/page.tsx
@@ -98,6 +98,13 @@ const { tools, budget } = await createAgentTools(sandbox, {
               Web search configuration. Presence enables WebSearch and WebFetch
               tools.
             </Prop>
+            <Prop name="codemode" type="CodemodeConfig">
+              Cloudflare Codemode adapter. Adds a single <code>codemode</code>{" "}
+              tool that can orchestrate selected executable tools. Excludes
+              client-intervention tools and tools with{" "}
+              <code>needsApproval</code>. Supports extra default-namespace tools
+              and named providers.
+            </Prop>
             <Prop name="cache" type="boolean | CacheConfig">
               Enable tool result caching. Pass <code>true</code> for defaults or
               an object for fine-grained control.
diff --git a/docs/src/app/codemode/page.tsx b/docs/src/app/codemode/page.tsx
new file mode 100644
index 0000000..1a0e050
--- /dev/null
+++ b/docs/src/app/codemode/page.tsx
@@ -0,0 +1,289 @@
+"use client";
+
+import { CodeBlock } from "../components/CodeBlock";
+import { Footer } from "../Footer";
+
+export default function Codemode() {
+  return (
+    <>
+      <article className="article">
+        <header>
+          <h1>Codemode</h1>
+          <p className="tagline">
+            Let the model write code that orchestrates BashKit tools in batches.
+          </p>
+        </header>
+
+        <section>
+          <h2 id="overview">Overview</h2>
+          <p>
+            Codemode wraps selected BashKit tools behind one Cloudflare Codemode
+            tool. Instead of asking the model to call <code>Glob</code>, then{" "}
+            <code>Grep</code>, then <code>Read</code> one turn at a time, the
+            model can write a small JavaScript async arrow function that calls
+            those tools with loops, branches, and parallel work.
+          </p>
+          <p>
+            BashKit does not run the code itself. It delegates to Cloudflare
+            Codemode&apos;s executor, while the code still calls BashKit&apos;s
+            policy-wrapped tools. That means context layers, plan-mode gates,
+            output policy, and sandbox restrictions keep applying.
+          </p>
+        </section>
+
+        <section>
+          <h2 id="setup">Setup</h2>
+          <p>
+            Install Cloudflare Codemode alongside BashKit, then provide an
+            executor through <code>codemode</code> config.
+          </p>
+          <p>
+            Cloudflare Codemode currently targets AI SDK v6, so BashKit&apos;s
+            codemode adapter follows that path.
+          </p>
+          <CodeBlock
+            language="bash"
+            copyable
+            code={`npm install @cloudflare/codemode`}
+          />
+          <CodeBlock
+            language="typescript"
+            copyable
+            code={`import { DynamicWorkerExecutor } from '@cloudflare/codemode';
+import { createAgentTools, createPrepareStep } from 'bashkit';
+import { streamText } from 'ai';
+
+const { tools, planModeState } = await createAgentTools(sandbox, {
+  planMode: true,
+  context: {
+    executionPolicy: {}, // plan-mode gating with defaults
+    outputPolicy: { maxOutputLength: 30_000 },
+  },
+  codemode: {
+    executor: new DynamicWorkerExecutor({ loader: env.LOADER }),
+    includeTools: ['Read', 'Glob', 'Grep', 'Bash'],
+  },
+});
+
+await streamText({
+  model,
+  tools,
+  messages,
+  prepareStep: createPrepareStep({ planModeState }),
+});`}
+          />
+        </section>
+
+        <section>
+          <h2 id="batched-workflows">Batched Workflows</h2>
+          <p>
+            Codemode is useful when the model needs to fan out across files,
+            combine results, or retry/narrow a search. The generated code can
+            batch those steps into one tool call.
+          </p>
+          <CodeBlock
+            language="typescript"
+            copyable
+            code={`// Example of code the model can write inside codemode:
+async () => {
+  const files = await bashkit.Glob({
+    pattern: 'src/**/*.ts',
+    path: null,
+  });
+
+  const planModeMatches = await Promise.all(
+    files.matches.map((file) =>
+      bashkit.Grep({
+        pattern: 'PlanMode|planModeState|ExitPlanMode',
+        path: file,
+        glob: null,
+        type: null,
+        output_mode: 'content',
+        '-i': null,
+        '-n': true,
+        '-B': null,
+        '-A': null,
+        '-C': 2,
+        head_limit: 20,
+        offset: null,
+        multiline: null,
+      }),
+    ),
+  );
+
+  const interestingFiles = planModeMatches
+    .filter((result) => 'matches' in result && result.matches.length > 0)
+    .map((result) => result.matches[0].file);
+
+  const snippets = await Promise.all(
+    interestingFiles.slice(0, 5).map((file_path) =>
+      bashkit.Read({
+        file_path,
+        offset: 1,
+        limit: 120,
+      }),
+    ),
+  );
+
+  return {
+    scanned: files.count,
+    matchedFiles: interestingFiles,
+    snippets,
+  };
+};`}
+          />
+          <p>
+            That would normally take many model/tool turns. With Codemode, the
+            model can express the workflow as code and return a structured
+            result.
+          </p>
+        </section>
+
+        <section>
+          <h2 id="tool-selection">Tool Selection</h2>
+          <p>
+            Keep the inner tool set narrow. <code>includeTools</code> is the
+            safest default because generated code can loop and fan out calls.
+          </p>
+          <CodeBlock
+            language="typescript"
+            copyable
+            code={`const { tools } = await createAgentTools(sandbox, {
+  codemode: {
+    executor,
+    includeTools: ['Read', 'Glob', 'Grep'],
+    tools: {
+      // Optional AI SDK tools exposed only inside codemode
+      SummarizeFile,
+    },
+  },
+});`}
+          />
+          <p>
+            BashKit always excludes client-intervention tools from Codemode:
+            <code>AskUser</code>, <code>EnterPlanMode</code>,{" "}
+            <code>ExitPlanMode</code>, tools without an <code>execute</code>{" "}
+            function, and tools with <code>needsApproval</code>.
+          </p>
+        </section>
+
+        <section>
+          <h2 id="namespaces">Namespaces</h2>
+          <p>
+            The tool exposed to the model is named <code>codemode</code> by
+            default. Inside the generated JavaScript, selected BashKit tools are
+            exposed under BashKit&apos;s <code>bashkit.*</code> namespace. Tool
+            methods keep BashKit&apos;s public tool names, so the grep tool is{" "}
+            <code>bashkit.Grep(...)</code>.
+          </p>
+          <CodeBlock
+            language="typescript"
+            copyable
+            code={`// Direct model tool call:
+tools.codemode({
+  code: \`async () => {
+    const files = await bashkit.Glob({
+      pattern: 'src/**/*.ts',
+      path: null,
+    });
+
+    return files.matches;
+  }\`,
+});`}
+          />
+          <p>
+            Use <code>providers</code> when you want separate namespaces for
+            custom tool groups. Each provider gets its own object inside the
+            generated code, which keeps domain-specific helpers easier to scan.
+          </p>
+          <CodeBlock
+            language="typescript"
+            copyable
+            code={`const { tools } = await createAgentTools(sandbox, {
+  codemode: {
+    executor,
+    includeTools: ['Read', 'Glob', 'Grep'],
+    providers: [
+      {
+        name: 'github',
+        tools: {
+          ListIssues,
+          FetchPullRequest,
+        },
+      },
+    ],
+  },
+});
+
+// Generated code can do this in one codemode call:
+async () => {
+  const todos = await bashkit.Grep({
+    pattern: 'TODO|FIXME',
+    path: 'src',
+    glob: '*.ts',
+    type: null,
+    output_mode: 'content',
+    '-i': null,
+    '-n': true,
+    '-B': null,
+    '-A': null,
+    '-C': 2,
+    head_limit: 20,
+    offset: null,
+    multiline: null,
+  });
+
+  const issues = await github.ListIssues({
+    labels: ['tech-debt'],
+    state: 'open',
+  });
+
+  return { todos, issues };
+};`}
+          />
+          <p>
+            Executable-only and <code>needsApproval</code> filtering applies to
+            every namespace. Top-level <code>includeTools</code> narrows the
+            default <code>bashkit.*</code> namespace; providers can define their
+            own <code>includeTools</code> or <code>excludeTools</code>.
+          </p>
+        </section>
+
+        <section>
+          <h2 id="policy">Policy</h2>
+          <p>
+            Codemode receives the same wrapped tools that normal model tool
+            calls receive. If plan mode is active, <code>Bash</code>,{" "}
+            <code>Write</code>, and <code>Edit</code> are still blocked by the
+            execution policy even when generated code calls them.
+          </p>
+          <CodeBlock
+            language="typescript"
+            copyable
+            code={`const { tools, planModeState } = await createAgentTools(sandbox, {
+  planMode: true,
+  context: {
+    executionPolicy: {
+      planModeBlockedTools: ['Bash', 'Write', 'Edit'],
+    },
+  },
+  codemode: {
+    executor,
+    includeTools: ['Read', 'Glob', 'Grep', 'Bash'],
+  },
+});
+
+if (planModeState) {
+  planModeState.isActive = true;
+}
+
+// A codemode-generated call to bashkit.Bash(...) returns the same
+// "Bash is not available in plan mode" error as a direct Bash tool call.`}
+          />
+        </section>
+      </article>
+
+      <Footer />
+    </>
+  );
+}
diff --git a/docs/src/app/components/NavIcons.tsx b/docs/src/app/components/NavIcons.tsx
index 27282cf..8c050b8 100644
--- a/docs/src/app/components/NavIcons.tsx
+++ b/docs/src/app/components/NavIcons.tsx
@@ -31,6 +31,18 @@ export const navIcons: Record<string, React.ReactNode> = {
       <path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z" />
     </svg>
   ),
+  "/codemode": (
+    <svg {...iconProps}>
+      <path d="M12.25 3.75H6.95c-1.12 0-1.68 0-2.11.22a2 2 0 0 0-.87.87c-.22.43-.22.99-.22 2.11v10.1c0 1.12 0 1.68.22 2.11.19.38.5.68.87.87.43.22.99.22 2.11.22h10.1c1.12 0 1.68 0 2.11-.22.38-.19.68-.5.87-.87.22-.43.22-.99.22-2.11v-5.3" />
+      <path d="M10.5 10 8 12.5l2.5 2.5" />
+      <path d="m14 10 2.5 2.5L14 15" />
+      <path
+        d="M18.5 2.25 19.25 4.75 21.75 5.5 19.25 6.25 18.5 8.75 17.75 6.25 15.25 5.5 17.75 4.75 18.5 2.25Z"
+        fill="currentColor"
+        stroke="none"
+      />
+    </svg>
+  ),
   "/sandboxes": (
     <svg {...iconProps}>
       <path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z" />
diff --git a/package.json b/package.json
index 522fc81..7069976 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "bashkit",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Agentic coding tools for the Vercel AI SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
   "scripts": {
     "dev": "bun run src/index.ts",
     "build": "bun run build:js && bun run build:cli && bun run build:types",
-    "build:js": "bun build src/index.ts --outdir dist --target node --format esm --external ai --external zod --external @ai-sdk/* --external @vercel/sandbox --external @e2b/code-interpreter --external parallel-web --external @vscode/ripgrep",
+    "build:js": "bun build src/index.ts --outdir dist --target node --format esm --external ai --external zod --external @ai-sdk/* --external @vercel/sandbox --external @e2b/code-interpreter --external parallel-web --external @cloudflare/codemode --external @vscode/ripgrep",
     "build:cli": "bun build src/cli/init.ts --outdir dist/cli --target node --format esm --external @clack/prompts && chmod +x dist/cli/init.js",
     "build:types": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
@@ -77,7 +77,8 @@
     "zod": "^4.1.8",
     "@vercel/sandbox": "^1.0.0",
     "@e2b/code-interpreter": "^1.0.0",
-    "parallel-web": "^0.2.4"
+    "parallel-web": "^0.2.4",
+    "@cloudflare/codemode": "^0.4.0"
   },
   "peerDependenciesMeta": {
     "@vercel/sandbox": {
@@ -88,6 +89,9 @@
     },
     "parallel-web": {
       "optional": true
+    },
+    "@cloudflare/codemode": {
+      "optional": true
     }
   }
 }
diff --git a/src/context/tool-guidance.ts b/src/context/tool-guidance.ts
index 5b1ac47..634a0f0 100644
--- a/src/context/tool-guidance.ts
+++ b/src/context/tool-guidance.ts
@@ -18,6 +18,10 @@ const DEFAULT_HINTS: Record<string, string> = {
   Grep: "Search file contents with regex. Faster than bash grep.",
   WebSearch: "Search the web. Use for current information.",
   WebFetch: "Fetch and analyze a URL.",
+  codemode:
+    "Run generated JavaScript once to batch and orchestrate selected BashKit/provider tools.",
+  Codemode:
+    "Run generated JavaScript once to batch and orchestrate selected BashKit/provider tools.",
   Task: "Spawn sub-agents for complex parallel work.",
   TodoWrite: "Track multi-step task progress.",
 };
diff --git a/src/index.ts b/src/index.ts
index edfa14e..5c3d46d 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -47,6 +47,15 @@ export type {
   // Sandbox tools
   BashError,
   BashOutput,
+  CodemodeConfig,
+  CodemodeConnectorBinding,
+  CodemodeExecuteOptions,
+  CodemodeExecuteResult,
+  CodemodeExecutor,
+  CodemodeResolvedProvider,
+  CodemodeToolProvider,
+  CodemodeToolExclusionReason,
+  CreateCodeTool,
   EditError,
   EditOutput,
   // Plan mode tools
@@ -100,6 +109,7 @@ export {
   createAgentTools,
   createAskUserTool,
   createBashTool,
+  createCodemodeTool,
   createEditTool,
   createEnterPlanModeTool,
   createExitPlanModeTool,
@@ -113,6 +123,7 @@ export {
   createWebFetchTool,
   createWebSearchTool,
   createWriteTool,
+  selectCodemodeTools,
 } from "./tools";
 // Configuration types
 export type {
diff --git a/src/tools/AGENTS.md b/src/tools/AGENTS.md
index b2dbb8f..3a757d1 100644
--- a/src/tools/AGENTS.md
+++ b/src/tools/AGENTS.md
@@ -16,6 +16,7 @@ Most tools are a single file. **Tools with non-trivial internals live in their o
 | `glob.ts` | Pattern-based file discovery using find command |
 | `grep.ts` | Ripgrep-powered content search with context and filtering |
 | `ask-user.ts` | Deferred structured user Q&A rendered by the client |
+| `codemode.ts` | Cloudflare Codemode adapter and safe tool-selection helper |
 | `enter-plan-mode.ts` | Enter planning mode for explore-then-execute workflows |
 | `exit-plan-mode.ts` | Exit planning mode and submit plan for approval |
 | `skill.ts` | Activate pre-loaded skills from SKILL.md files |
@@ -37,6 +38,7 @@ Most tools are a single file. **Tools with non-trivial internals live in their o
 - `createGlobTool(sandbox, config?)` -- File pattern matching
 - `createGrepTool(sandbox, config?)` -- Content search with ripgrep
 - `createAskUserTool(config?)` -- Deferred user interaction tool
+- `createCodemodeTool(tools, config)` -- Create a Cloudflare Codemode tool from a filtered AI SDK tool set
 - `createEnterPlanModeTool(state, onEnter?)` -- Planning mode entry
 - `createExitPlanModeTool(onPlanSubmit?)` -- Planning mode exit
 - `createSkillTool(config)` -- Skill activation
@@ -58,6 +60,7 @@ Each tool exports `<Name>Output` for success and `<Name>Error` for errors:
 - `AskUserConfig` -- AskUser AI SDK tool options
 - `SkillConfig` -- Skill metadata and sandbox
 - `TaskToolConfig` -- Sub-agent configuration (includes optional `budget` for auto-wiring cost tracking)
+- `CodemodeConfig` -- Optional Cloudflare Codemode adapter config (executor, tool filters, extra tools). Executor typing follows Cloudflare Codemode / AI SDK v6.
 - `ModelRegistryConfig` -- Model registry config (provider, apiKey) for fetching model info
 - `BudgetConfig` -- Budget tracking config (maxUsd, modelPricing; pricing provider via top-level `modelRegistry`)
 - `WebSearchConfig` / `WebFetchConfig` -- Web tool API keys and providers
@@ -77,6 +80,9 @@ Each tool exports `<Name>Output` for success and `<Name>Error` for errors:
 - EnterPlanMode, ExitPlanMode -- Plan-then-execute workflow
 - Skill -- Load specialized instructions from SKILL.md files
 
+**Code Orchestration** (opt-in via config):
+- codemode -- A Cloudflare Codemode tool that lets the model write code to orchestrate a filtered set of BashKit tools, codemode-only extra tools, and optional named providers. Client-intervention tools (`AskUser`, `EnterPlanMode`, `ExitPlanMode`), tools without `execute`, and tools with `needsApproval` are excluded from every inner tool set. Thrown codemode execution failures are converted to `{ error }` tool results like other BashKit tools.
+
 **Workflow Tools** (require Task tool config):
 - Task -- Spawn sub-agents with custom system prompts and tool restrictions
 - TodoWrite -- Shared state management for task tracking
@@ -110,6 +116,7 @@ Each tool exports `<Name>Output` for success and `<Name>Error` for errors:
 - `ai` -- tool(), zodSchema(), generateText(), streamText() from Vercel AI SDK
 - `zod` -- Schema validation for all tool inputs
 - `parallel-web` -- Dynamic import for WebSearch and WebFetch (peer dependency)
+- `@cloudflare/codemode` -- Dynamic import for Codemode when `codemode` config is enabled (optional peer dependency)
 
 ## Design Patterns
 
diff --git a/src/tools/codemode.ts b/src/tools/codemode.ts
new file mode 100644
index 0000000..6790361
--- /dev/null
+++ b/src/tools/codemode.ts
@@ -0,0 +1,264 @@
+import type { Tool, ToolSet } from "ai";
+
+// Intentionally lowercase to match Cloudflare Codemode's public examples.
+const DEFAULT_CODEMODE_TOOL_NAME = "codemode";
+const DEFAULT_CODEMODE_TOOL_NAMESPACE = "bashkit";
+const DEFAULT_EXCLUDED_TOOL_NAMES = new Set([
+  "AskUser",
+  "EnterPlanMode",
+  "ExitPlanMode",
+]);
+
+export type CodemodeToolExclusionReason =
+  | "excluded-by-default"
+  | "excluded-by-config"
+  | "not-included-by-config"
+  | "no-execute"
+  | "needs-approval";
+
+export interface CodemodeToolProvider {
+  /** Namespace exposed inside generated code. Defaults to BashKit's "bashkit". */
+  name?: string;
+  /** Tools exposed as namespace.toolName() inside generated code. */
+  tools: ToolSet;
+  /** Optional prebuilt type declarations for this provider. */
+  types?: string;
+  /** Only expose these provider tool names, after safety exclusions. */
+  includeTools?: string[];
+  /** Exclude these provider tool names. */
+  excludeTools?: string[];
+}
+
+export interface CodemodeExecuteResult {
+  /** Generated codemode JavaScript can return any value; BashKit does not inspect it. */
+  result: unknown;
+  error?: string;
+  logs?: string[];
+}
+
+export interface CodemodeResolvedProvider {
+  name: string;
+  fns: Record<string, (...args: unknown[]) => Promise<unknown>>;
+  prelude?: string;
+}
+
+export interface CodemodeConnectorBinding {
+  name: string;
+  binding: {
+    callTool(method: string, args: unknown): Promise<unknown>;
+  };
+}
+
+export interface CodemodeExecuteOptions {
+  connectors?: CodemodeConnectorBinding[];
+}
+
+export interface CodemodeExecutor {
+  execute(
+    code: string,
+    providersOrFns:
+      | CodemodeResolvedProvider[]
+      | Record<string, (...args: unknown[]) => Promise<unknown>>,
+    options?: CodemodeExecuteOptions,
+  ): Promise<CodemodeExecuteResult>;
+}
+
+export type CreateCodeTool = (options: {
+  tools: ToolSet | CodemodeToolProvider[];
+  executor: CodemodeExecutor;
+  description?: string;
+}) => Tool | Promise<Tool>;
+
+export interface CodemodeConfig {
+  /**
+   * Executor passed through to @cloudflare/codemode's createCodeTool().
+   * Cloudflare Codemode currently targets AI SDK v6.
+   */
+  executor: CodemodeExecutor;
+  /** Tool name added to the returned ToolSet. Defaults to "codemode" to match Cloudflare examples. */
+  toolName?: string;
+  /** Namespace for BashKit and codemode-only tools inside generated code. Defaults to "bashkit". */
+  namespace?: string;
+  /** Extra tools exposed only inside codemode. */
+  tools?: ToolSet;
+  /** Additional named tool groups exposed inside codemode. */
+  providers?: CodemodeToolProvider[];
+  /** Custom Cloudflare Codemode tool description. Use {{types}} for generated type declarations. */
+  description?: string;
+  /** Only expose these tool names to codemode, after safety exclusions. */
+  includeTools?: string[];
+  /** Exclude these tool names from codemode. */
+  excludeTools?: string[];
+  /** Test hook / advanced override. Defaults to @cloudflare/codemode/ai createCodeTool. */
+  createCodeTool?: CreateCodeTool;
+  /** Observability hook for tools filtered out of the codemode inner tool set. */
+  onToolExcluded?: (
+    toolName: string,
+    reason: CodemodeToolExclusionReason,
+  ) => void;
+}
+
+function hasClientIntervention(tool: Tool): boolean {
+  return Boolean(tool.needsApproval);
+}
+
+export function selectCodemodeTools(
+  tools: ToolSet,
+  config: Pick<
+    CodemodeConfig,
+    "includeTools" | "excludeTools" | "onToolExcluded"
+  > = {},
+): ToolSet {
+  const include = config.includeTools ? new Set(config.includeTools) : null;
+  const exclude = new Set(config.excludeTools ?? []);
+  const selected: ToolSet = {};
+
+  for (const [toolName, tool] of Object.entries(tools)) {
+    let exclusion: CodemodeToolExclusionReason | null = null;
+
+    if (DEFAULT_EXCLUDED_TOOL_NAMES.has(toolName)) {
+      exclusion = "excluded-by-default";
+    } else if (exclude.has(toolName)) {
+      exclusion = "excluded-by-config";
+    } else if (include && !include.has(toolName)) {
+      exclusion = "not-included-by-config";
+    } else if (!tool.execute) {
+      exclusion = "no-execute";
+    } else if (hasClientIntervention(tool)) {
+      exclusion = "needs-approval";
+    }
+
+    if (exclusion) {
+      config.onToolExcluded?.(toolName, exclusion);
+      continue;
+    }
+
+    selected[toolName] = tool;
+  }
+
+  return selected;
+}
+
+function selectProviderTools(
+  provider: CodemodeToolProvider,
+  config: Pick<CodemodeConfig, "excludeTools" | "onToolExcluded">,
+): CodemodeToolProvider | null {
+  const tools = selectCodemodeTools(provider.tools, {
+    excludeTools: provider.excludeTools ?? config.excludeTools,
+    includeTools: provider.includeTools,
+    onToolExcluded: config.onToolExcluded,
+  });
+  if (Object.keys(tools).length === 0) return null;
+
+  return {
+    ...provider,
+    tools,
+  };
+}
+
+async function loadCreateCodeTool(): Promise<CreateCodeTool> {
+  const dynamicImport = new Function(
+    "specifier",
+    "return import(specifier)",
+  ) as (specifier: string) => Promise<unknown>;
+  let mod: { createCodeTool?: unknown };
+
+  try {
+    mod = (await dynamicImport("@cloudflare/codemode/ai")) as {
+      createCodeTool?: unknown;
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `[bashkit] codemode requires the optional peer dependency @cloudflare/codemode. ` +
+        `Install it with "npm install @cloudflare/codemode". Original error: ${message}`,
+    );
+  }
+
+  if (typeof mod.createCodeTool !== "function") {
+    throw new Error(
+      "[bashkit] @cloudflare/codemode/ai does not export createCodeTool.",
+    );
+  }
+
+  return mod.createCodeTool as CreateCodeTool;
+}
+
+function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+function wrapCodemodeTool(tool: Tool): Tool {
+  if (!tool.execute) return tool;
+
+  const execute = tool.execute;
+
+  return {
+    ...tool,
+    execute: async (input, options) => {
+      try {
+        return await execute(input, options);
+      } catch (error) {
+        return {
+          error: `[bashkit] Codemode execution failed: ${getErrorMessage(error)}`,
+        };
+      }
+    },
+  };
+}
+
+export async function createCodemodeTool(
+  tools: ToolSet,
+  config: CodemodeConfig,
+): Promise<{
+  name: string;
+  tool: Tool;
+  innerTools: ToolSet;
+  providers: CodemodeToolProvider[];
+}> {
+  const defaultProviderTools = {
+    ...tools,
+    ...(config.tools ?? {}),
+  };
+  const innerTools = selectCodemodeTools(defaultProviderTools, config);
+  const providers = [
+    ...(Object.keys(innerTools).length > 0
+      ? [
+          {
+            name: config.namespace ?? DEFAULT_CODEMODE_TOOL_NAMESPACE,
+            tools: innerTools,
+          },
+        ]
+      : []),
+    ...(config.providers ?? [])
+      .map((provider) => selectProviderTools(provider, config))
+      .filter(
+        (provider): provider is CodemodeToolProvider => provider !== null,
+      ),
+  ];
+  const createCodeTool = config.createCodeTool ?? (await loadCreateCodeTool());
+  const createOptions: {
+    tools: ToolSet | CodemodeToolProvider[];
+    executor: CodemodeExecutor;
+    description?: string;
+  } = {
+    tools: providers,
+    executor: config.executor,
+  };
+
+  if (config.description !== undefined) {
+    createOptions.description = config.description;
+  }
+
+  const tool = await createCodeTool({
+    ...createOptions,
+  });
+
+  return {
+    name: config.toolName ?? DEFAULT_CODEMODE_TOOL_NAME,
+    tool: wrapCodemodeTool(tool),
+    innerTools,
+    providers,
+  };
+}
diff --git a/src/tools/index.ts b/src/tools/index.ts
index 058184e..4213e66 100644
--- a/src/tools/index.ts
+++ b/src/tools/index.ts
@@ -16,6 +16,7 @@ import {
 } from "../utils/budget-tracking";
 import { createAskUserTool } from "./ask-user";
 import { createBashTool } from "./bash";
+import { createCodemodeTool } from "./codemode";
 import { createEditTool } from "./edit";
 import { createEnterPlanModeTool, type PlanModeState } from "./enter-plan-mode";
 import { createExitPlanModeTool } from "./exit-plan-mode";
@@ -292,6 +293,45 @@ export async function createAgentTools(
     }
   }
 
+  // Add Cloudflare Codemode tool after cache/context wrapping so generated code
+  // orchestrates the same policy-wrapped tools a model would call directly.
+  if (config?.codemode) {
+    const codemodeOnlyTools =
+      config.codemode.tools && contextLayers.length > 0
+        ? applyContextLayers(config.codemode.tools, contextLayers)
+        : (config.codemode.tools ?? {});
+    const codemodeProviders = config.codemode.providers?.map((provider) => ({
+      ...provider,
+      tools:
+        contextLayers.length > 0
+          ? applyContextLayers(provider.tools, contextLayers)
+          : provider.tools,
+    }));
+    const codemodeConfig = {
+      ...config.codemode,
+      tools: codemodeOnlyTools,
+      providers: codemodeProviders,
+    };
+
+    const { name, tool: rawCodemodeTool } = await createCodemodeTool(
+      tools,
+      codemodeConfig,
+    );
+
+    if (tools[name]) {
+      throw new Error(
+        `[bashkit] Codemode tool name "${name}" conflicts with an existing tool.`,
+      );
+    }
+
+    const codemodeTool =
+      contextLayers.length > 0
+        ? applyContextLayers({ [name]: rawCodemodeTool }, contextLayers)[name]
+        : rawCodemodeTool;
+
+    tools[name] = codemodeTool;
+  }
+
   // Fetch model info from provider (hoisted before budget so both can share the data)
   let openRouterModels: Map<string, ModelInfo> | undefined;
 
@@ -361,6 +401,18 @@ export { createAskUserTool } from "./ask-user";
 export type { BashError, BashOutput } from "./bash";
 // Sandbox-based tool factories (for custom configurations)
 export { createBashTool } from "./bash";
+export type {
+  CodemodeConfig,
+  CodemodeConnectorBinding,
+  CodemodeExecuteOptions,
+  CodemodeExecuteResult,
+  CodemodeExecutor,
+  CodemodeResolvedProvider,
+  CodemodeToolProvider,
+  CodemodeToolExclusionReason,
+  CreateCodeTool,
+} from "./codemode";
+export { createCodemodeTool, selectCodemodeTools } from "./codemode";
 export type { EditError, EditOutput } from "./edit";
 export { createEditTool } from "./edit";
 // --- Plan Mode Tools ---
diff --git a/src/types.ts b/src/types.ts
index 27347f5..0889f12 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -4,6 +4,7 @@ import type { ContextLayer } from "./context/index";
 import type { ExecutionPolicyConfig } from "./context/execution-policy";
 import type { OutputPolicyConfig } from "./context/output-policy";
 import type { SkillMetadata } from "./skills/types";
+import type { CodemodeConfig } from "./tools/codemode";
 import type { ModelPricing } from "./utils/budget-tracking";
 
 /**
@@ -205,6 +206,8 @@ export type AgentConfig = {
   webSearch?: WebSearchConfig;
   /** Include WebFetch tool with this config */
   webFetch?: WebFetchConfig;
+  /** Include a Cloudflare Codemode tool that can orchestrate selected tools */
+  codemode?: CodemodeConfig;
   /** Enable tool result caching */
   cache?: CacheConfig;
   /** Fetch model info (pricing + context lengths) from a provider.
diff --git a/tests/context/build-context.test.ts b/tests/context/build-context.test.ts
index 2b72d1e..efc712d 100644
--- a/tests/context/build-context.test.ts
+++ b/tests/context/build-context.test.ts
@@ -345,6 +345,13 @@ describe("buildToolGuidance", () => {
     expect(text).toContain("file additions/deletions, and renames");
   });
 
+  it("includes default codemode guidance when codemode is registered", () => {
+    const text = buildToolGuidance({ tools: ["codemode"] });
+    expect(text).toContain("**codemode**");
+    expect(text).toContain("generated JavaScript");
+    expect(text).toContain("BashKit/provider tools");
+  });
+
   it("includes custom guidelines", () => {
     const text = buildToolGuidance({
       tools: ["Bash"],
diff --git a/tests/tools/codemode.test.ts b/tests/tools/codemode.test.ts
new file mode 100644
index 0000000..9117676
--- /dev/null
+++ b/tests/tools/codemode.test.ts
@@ -0,0 +1,479 @@
+import { describe, it, expect, vi } from "vitest";
+import { tool, zodSchema, type Tool, type ToolSet } from "ai";
+import { z } from "zod";
+import { createAgentTools } from "@/tools/index";
+import {
+  createCodemodeTool,
+  selectCodemodeTools,
+  type CodemodeExecutor,
+  type CreateCodeTool,
+} from "@/tools/codemode";
+import { applyContextLayers } from "@/context/index";
+import { createExecutionPolicy } from "@/context/execution-policy";
+import { executeTool, assertError, assertSuccess } from "@test/helpers";
+import { createMockSandbox } from "@test/helpers";
+
+function createExecutableTool(output: unknown = { output: "ok" }): Tool {
+  return tool({
+    description: "Executable test tool",
+    inputSchema: zodSchema(z.object({})),
+    execute: async () => output,
+  });
+}
+
+function createDeferredTool(): Tool {
+  return tool({
+    description: "Deferred test tool",
+    inputSchema: zodSchema(z.object({})),
+  });
+}
+
+function createApprovalTool(): Tool {
+  return Object.assign(createExecutableTool(), { needsApproval: true });
+}
+
+function createExecutor(): CodemodeExecutor {
+  return {
+    execute: async () => ({ result: null }),
+  };
+}
+
+function createCapturingCodeTool(captured: ToolSet[]): CreateCodeTool {
+  return async ({ tools }) => {
+    const availableTools = Array.isArray(tools)
+      ? Object.assign({}, ...tools.map((provider) => provider.tools))
+      : tools;
+    captured.push(availableTools);
+
+    return tool({
+      description: "Mock codemode tool",
+      inputSchema: zodSchema(
+        z.object({
+          toolName: z.string(),
+          params: z.record(z.string(), z.unknown()),
+        }),
+      ),
+      execute: async ({
+        toolName,
+        params,
+      }: {
+        toolName: string;
+        params: Record<string, unknown>;
+      }) => {
+        const selected = availableTools[toolName];
+        if (!selected?.execute) return { error: `Missing tool: ${toolName}` };
+        return await executeTool(selected, params);
+      },
+    });
+  };
+}
+
+describe("selectCodemodeTools", () => {
+  it("excludes client-intervention and deferred tools", () => {
+    const excluded: Array<[string, string]> = [];
+    const tools: ToolSet = {
+      Read: createExecutableTool(),
+      AskUser: createDeferredTool(),
+      EnterPlanMode: createExecutableTool(),
+      ExitPlanMode: createExecutableTool(),
+      Deferred: createDeferredTool(),
+      NeedsApproval: createApprovalTool(),
+    };
+
+    const selected = selectCodemodeTools(tools, {
+      onToolExcluded: (toolName, reason) => excluded.push([toolName, reason]),
+    });
+
+    expect(Object.keys(selected)).toEqual(["Read"]);
+    expect(excluded).toEqual(
+      expect.arrayContaining([
+        ["AskUser", "excluded-by-default"],
+        ["EnterPlanMode", "excluded-by-default"],
+        ["ExitPlanMode", "excluded-by-default"],
+        ["Deferred", "no-execute"],
+        ["NeedsApproval", "needs-approval"],
+      ]),
+    );
+  });
+
+  it("supports includeTools and excludeTools without mutating input", () => {
+    const tools: ToolSet = {
+      Read: createExecutableTool(),
+      Grep: createExecutableTool(),
+      Bash: createExecutableTool(),
+    };
+
+    const selected = selectCodemodeTools(tools, {
+      includeTools: ["Read", "Grep"],
+      excludeTools: ["Grep"],
+    });
+
+    expect(Object.keys(selected)).toEqual(["Read"]);
+    expect(Object.keys(tools)).toEqual(["Read", "Grep", "Bash"]);
+  });
+});
+
+describe("createCodemodeTool", () => {
+  it("delegates to injected createCodeTool with filtered tools", async () => {
+    const captured: ToolSet[] = [];
+    const createCodeTool = vi.fn(createCapturingCodeTool(captured));
+
+    const result = await createCodemodeTool(
+      {
+        Read: createExecutableTool(),
+        AskUser: createDeferredTool(),
+      },
+      {
+        executor: createExecutor(),
+        createCodeTool,
+      },
+    );
+
+    expect(result.name).toBe("codemode");
+    expect(result.innerTools.Read).toBeDefined();
+    expect(result.innerTools.AskUser).toBeUndefined();
+    expect(result.providers).toEqual([
+      { name: "bashkit", tools: result.innerTools },
+    ]);
+    expect(createCodeTool).toHaveBeenCalledWith({
+      tools: result.providers,
+      executor: expect.objectContaining({ execute: expect.any(Function) }),
+    });
+  });
+
+  it("supports overriding the default BashKit namespace", async () => {
+    const createCodeTool = vi.fn(createCapturingCodeTool([]));
+
+    const result = await createCodemodeTool(
+      {
+        Read: createExecutableTool(),
+      },
+      {
+        executor: createExecutor(),
+        namespace: "workspace",
+        createCodeTool,
+      },
+    );
+
+    expect(result.providers[0].name).toBe("workspace");
+    expect(createCodeTool).toHaveBeenCalledWith({
+      tools: result.providers,
+      executor: expect.objectContaining({ execute: expect.any(Function) }),
+    });
+  });
+
+  it("supports named providers and filters each provider", async () => {
+    const createCodeTool = vi.fn(createCapturingCodeTool([]));
+
+    const result = await createCodemodeTool(
+      {
+        Read: createExecutableTool(),
+      },
+      {
+        executor: createExecutor(),
+        providers: [
+          {
+            name: "repo",
+            tools: {
+              Summarize: createExecutableTool(),
+              NeedsApproval: createApprovalTool(),
+            },
+          },
+        ],
+        createCodeTool,
+      },
+    );
+
+    expect(result.providers).toHaveLength(2);
+    expect(result.providers[0].tools.Read).toBeDefined();
+    expect(result.providers[1].name).toBe("repo");
+    expect(result.providers[1].tools.Summarize).toBeDefined();
+    expect(result.providers[1].tools.NeedsApproval).toBeUndefined();
+    expect(createCodeTool).toHaveBeenCalledWith({
+      tools: result.providers,
+      executor: expect.objectContaining({ execute: expect.any(Function) }),
+    });
+  });
+
+  it("does not apply default includeTools to named providers", async () => {
+    const createCodeTool = vi.fn(createCapturingCodeTool([]));
+
+    const result = await createCodemodeTool(
+      {
+        Read: createExecutableTool(),
+        Bash: createExecutableTool(),
+      },
+      {
+        executor: createExecutor(),
+        includeTools: ["Read"],
+        providers: [
+          {
+            name: "github",
+            tools: {
+              ListIssues: createExecutableTool(),
+              FetchPullRequest: createExecutableTool(),
+            },
+          },
+        ],
+        createCodeTool,
+      },
+    );
+
+    expect(Object.keys(result.providers[0].tools)).toEqual(["Read"]);
+    expect(Object.keys(result.providers[1].tools)).toEqual([
+      "ListIssues",
+      "FetchPullRequest",
+    ]);
+  });
+
+  it("supports provider-specific includeTools", async () => {
+    const createCodeTool = vi.fn(createCapturingCodeTool([]));
+
+    const result = await createCodemodeTool(
+      {
+        Read: createExecutableTool(),
+      },
+      {
+        executor: createExecutor(),
+        providers: [
+          {
+            name: "github",
+            tools: {
+              ListIssues: createExecutableTool(),
+              FetchPullRequest: createExecutableTool(),
+            },
+            includeTools: ["ListIssues"],
+          },
+        ],
+        createCodeTool,
+      },
+    );
+
+    expect(Object.keys(result.providers[1].tools)).toEqual(["ListIssues"]);
+  });
+
+  it("passes a custom description through to createCodeTool", async () => {
+    const createCodeTool = vi.fn(createCapturingCodeTool([]));
+
+    await createCodemodeTool(
+      {
+        Read: createExecutableTool(),
+      },
+      {
+        executor: createExecutor(),
+        description: "Run code with these tools:\n{{types}}",
+        createCodeTool,
+      },
+    );
+
+    expect(createCodeTool).toHaveBeenCalledWith({
+      tools: [
+        {
+          name: "bashkit",
+          tools: expect.objectContaining({ Read: expect.any(Object) }),
+        },
+      ],
+      executor: expect.objectContaining({ execute: expect.any(Function) }),
+      description: "Run code with these tools:\n{{types}}",
+    });
+  });
+
+  it("returns an error object when codemode execution throws", async () => {
+    const createCodeTool: CreateCodeTool = async () =>
+      tool({
+        description: "Throwing codemode tool",
+        inputSchema: zodSchema(z.object({})),
+        execute: async (): Promise<unknown> => {
+          throw new Error("worker crashed");
+        },
+      });
+
+    const result = await createCodemodeTool(
+      {
+        Read: createExecutableTool(),
+      },
+      {
+        executor: createExecutor(),
+        createCodeTool,
+      },
+    );
+
+    const output = await executeTool(result.tool, {});
+
+    assertError(output);
+    expect(output.error).toContain("Codemode execution failed");
+    expect(output.error).toContain("worker crashed");
+  });
+});
+
+describe("createAgentTools codemode config", () => {
+  it("adds a codemode tool using selected wrapped tools", async () => {
+    const sandbox = createMockSandbox();
+    const captured: ToolSet[] = [];
+
+    const { tools } = await createAgentTools(sandbox, {
+      askUser: true,
+      planMode: true,
+      codemode: {
+        executor: createExecutor(),
+        createCodeTool: createCapturingCodeTool(captured),
+      },
+    });
+
+    expect(tools.codemode).toBeDefined();
+    expect(captured).toHaveLength(1);
+    expect(captured[0].Bash).toBeDefined();
+    expect(captured[0].AskUser).toBeUndefined();
+    expect(captured[0].EnterPlanMode).toBeUndefined();
+    expect(captured[0].ExitPlanMode).toBeUndefined();
+  });
+
+  it("adds codemode-only extra tools to the inner tool set", async () => {
+    const sandbox = createMockSandbox();
+    const captured: ToolSet[] = [];
+
+    const { tools } = await createAgentTools(sandbox, {
+      codemode: {
+        executor: createExecutor(),
+        tools: {
+          CustomTool: createExecutableTool({ output: "custom" }),
+        },
+        createCodeTool: createCapturingCodeTool(captured),
+      },
+    });
+
+    expect(tools.CustomTool).toBeUndefined();
+    expect(captured[0].CustomTool).toBeDefined();
+  });
+
+  it("wraps named provider tools with context layers", async () => {
+    const sandbox = createMockSandbox();
+    const createCodeTool: CreateCodeTool = async ({ tools }) => {
+      const providers = Array.isArray(tools) ? tools : [];
+      const repoProvider = providers.find(
+        (provider) => provider.name === "repo",
+      );
+      const repoTools = repoProvider?.tools ?? {};
+
+      return tool({
+        description: "Mock provider codemode tool",
+        inputSchema: zodSchema(z.object({})),
+        execute: async () => {
+          const result = await executeTool(repoTools.BashAlias, {});
+          return result;
+        },
+      });
+    };
+
+    const { tools, planModeState } = await createAgentTools(sandbox, {
+      planMode: true,
+      context: {
+        executionPolicy: {
+          planModeBlockedTools: ["BashAlias"],
+        },
+        outputPolicy: false,
+      },
+      codemode: {
+        executor: createExecutor(),
+        providers: [
+          {
+            name: "repo",
+            tools: {
+              BashAlias: createExecutableTool({ output: "ran" }),
+            },
+          },
+        ],
+        createCodeTool,
+      },
+    });
+
+    if (!planModeState) throw new Error("expected planModeState");
+    planModeState.isActive = true;
+
+    const result = await executeTool(tools.codemode, {});
+
+    assertError(result);
+    expect(result.error).toContain("not available in plan mode");
+  });
+
+  it("preserves execution policy inside codemode", async () => {
+    const sandbox = createMockSandbox();
+    const { tools, planModeState } = await createAgentTools(sandbox, {
+      planMode: true,
+      context: {
+        executionPolicy: {},
+        outputPolicy: false,
+      },
+      codemode: {
+        executor: createExecutor(),
+        createCodeTool: createCapturingCodeTool([]),
+      },
+    });
+
+    if (!planModeState) throw new Error("expected planModeState");
+    planModeState.isActive = true;
+
+    const result = await executeTool(tools.codemode, {
+      toolName: "Bash",
+      params: { command: "echo hi", description: "test" },
+    });
+
+    assertError(result);
+    expect(result.error).toContain("not available in plan mode");
+  });
+
+  it("wraps the top-level codemode tool with output policy", async () => {
+    const sandbox = createMockSandbox();
+    const createCodeTool: CreateCodeTool = async () =>
+      createExecutableTool({ output: "x".repeat(200) });
+
+    const { tools } = await createAgentTools(sandbox, {
+      context: {
+        outputPolicy: { maxOutputLength: 100, redirectionThreshold: 50 },
+      },
+      codemode: {
+        executor: createExecutor(),
+        createCodeTool,
+      },
+    });
+
+    const result = await executeTool(tools.codemode, {});
+
+    assertSuccess<Record<string, unknown>>(result);
+    expect(result._hint).toBeDefined();
+  });
+
+  it("rejects codemode tool name conflicts", async () => {
+    const sandbox = createMockSandbox();
+
+    await expect(
+      createAgentTools(sandbox, {
+        codemode: {
+          executor: createExecutor(),
+          toolName: "Bash",
+          createCodeTool: createCapturingCodeTool([]),
+        },
+      }),
+    ).rejects.toThrow('Codemode tool name "Bash" conflicts');
+  });
+});
+
+describe("codemode with standalone context layers", () => {
+  it("keeps selected tools policy-wrapped when passed manually", async () => {
+    const state = { isActive: true };
+    const wrapped = applyContextLayers(
+      { Bash: createExecutableTool({ output: "ran" }) },
+      [createExecutionPolicy(state)],
+    );
+    const captured: ToolSet[] = [];
+
+    await createCodemodeTool(wrapped, {
+      executor: createExecutor(),
+      createCodeTool: createCapturingCodeTool(captured),
+    });
+
+    const result = await executeTool(captured[0].Bash, {});
+    assertError(result);
+    expect(result.error).toContain("not available in plan mode");
+  });
+});
diff --git a/tests/tools/index.test.ts b/tests/tools/index.test.ts
index f94e36c..20f3ebb 100644
--- a/tests/tools/index.test.ts
+++ b/tests/tools/index.test.ts
@@ -1,5 +1,9 @@
 import { describe, it, expect, beforeEach } from "vitest";
-import { createAgentTools, type AgentToolsResult } from "@/tools/index";
+import {
+  createAgentTools,
+  type AgentToolsResult,
+  type CodemodeExecutor,
+} from "@/tools/index";
 import type { WebFetchConfig } from "@/types";
 import type { CachedTool } from "@/cache/cached";
 import {
@@ -17,6 +21,12 @@ describe("createAgentTools", () => {
     });
   });
 
+  function createExecutor(): CodemodeExecutor {
+    return {
+      execute: async () => ({ result: null }),
+    };
+  }
+
   describe("default tools", () => {
     it("should create core sandbox tools by default", async () => {
       const { tools } = await createAgentTools(sandbox);
@@ -39,6 +49,7 @@ describe("createAgentTools", () => {
       expect(tools.ExitPlanMode).toBeUndefined();
       expect(tools.Skill).toBeUndefined();
       expect(tools.Patch).toBeUndefined();
+      expect(tools.codemode).toBeUndefined();
     });
 
     it("should not return planModeState by default", async () => {
@@ -166,6 +177,32 @@ describe("createAgentTools", () => {
     });
   });
 
+  describe("codemode tool", () => {
+    it("should include codemode when configured", async () => {
+      const { tools } = await createAgentTools(sandbox, {
+        codemode: {
+          executor: createExecutor(),
+          createCodeTool: async ({ tools: innerTools }) => {
+            if (Array.isArray(innerTools)) {
+              const readTool = innerTools[0]?.tools.Read;
+              if (!readTool) throw new Error("expected Read tool");
+              return readTool;
+            }
+            return innerTools.Read;
+          },
+        },
+      });
+
+      expect(tools.codemode).toBeDefined();
+    });
+
+    it("should not include codemode without config", async () => {
+      const { tools } = await createAgentTools(sandbox);
+
+      expect(tools.codemode).toBeUndefined();
+    });
+  });
+
   describe("web tools", () => {
     it("should include WebSearch when configured", async () => {
       const { tools } = await createAgentTools(sandbox, {