@@ -495,6 +495,15 @@ function normalizeExperimental(
         )
         if (value !== undefined) result.media_blob = value
       }
+      if (own(experimental, "image_generation")) {
+        const value = decodeEncoded(
+          ConfigExperimental.Info.fields.image_generation,
+          experimental.image_generation,
+          ["experimental", "image_generation"],
+          diagnostics,
+        )
+        if (value !== undefined) result.image_generation = value
+      }
       if (own(experimental, "schedules")) {
         const value = decodeEncoded(
           ConfigExperimental.Info.fields.schedules,
 
@@ -3,11 +3,13 @@ export * as ImageGenerateTool from "./image-generate.js"
 import path from "path"
 import { ToolFailure } from "@opencode/ai/effect"
 import type { Context } from "@opencode/plugin/effect/plugin"
+import type { Document, Entry } from "@opencode/schema/config"
 import { Identifier } from "@opencode/schema/identifier"
 import type { Session } from "@opencode/schema/session"
 import { Global } from "@opencode/util/global"
 import { Duration, Effect, Schema, Stream } from "effect"
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
+import { Config } from "../../config.js"
 import { Environment } from "../../environment/index.js"
 import { FileAccess } from "../../file-access.js"
 import { Generate } from "../../generate.js"
@@ -67,6 +69,7 @@ export const Plugin = {
     const generate = yield* Generate.Service
     const global = yield* Global.Service
     const http = yield* HttpClient.HttpClient
+    const config = yield* Config.Service
     const models = yield* Model.Service
     const permission = yield* Permission.Service
 
@@ -77,12 +80,25 @@ export const Plugin = {
     ) {
       const available = yield* models.available(["image"])
       if (!input) {
+        // A configured default is a preference: when it can't serve this call, pick automatically and say so.
+        const settings = settingsFrom(yield* config.entries())
+        const configured = settings ? settings.model : undefined
+        const preferred = configured
+          ? available.find((model) => model.providerID === configured.providerID && model.id === configured.model)
+          : undefined
+        if (preferred && (!images || acceptsImages(preferred))) return { model: preferred }
         const providerID = (yield* ctx.session.get({ sessionID })).model?.providerID
         const model = defaultModel(available, { providerID, images })
-        if (model) return model
-        return yield* new ToolFailure({
-          message: images ? "None of the available image models accept input images." : "No image model is available.",
-        })
+        if (!model)
+          return yield* new ToolFailure({
+            message: images
+              ? "None of the available image models accept input images."
+              : "No image model is available.",
+          })
+        if (!configured) return { model }
+        const ref = `${configured.providerID}/${configured.model}`
+        const reason = preferred ? "doesn't accept input images" : "isn't available"
+        return { model, note: ` ${ref} ${reason}; used ${model.providerID}/${model.id}.` }
       }
       const ref = yield* Effect.try({
         try: () => Model.Ref.parse(input),
@@ -102,7 +118,7 @@ export const Plugin = {
               : `Model "${ref.providerID}/${ref.id}" does not accept input images. Image models that do: ${capable.map((model) => `${model.providerID}/${model.id}`).join(", ")}.`,
         })
       }
-      return model
+      return { model }
     })
 
     const readImage = Effect.fn("ImageGenerateTool.readImage")(function* (
@@ -161,21 +177,24 @@ export const Plugin = {
         Effect.catchTag("Environment.NotFound", () => Effect.succeed(false)),
       )
 
-    // Registered only while an image model is available, and re-evaluated whenever the model catalog changes.
-    // Subscribing before the first read keeps a change in between from being missed.
+    // Registered only while an image model is available and config doesn't turn the tool off, re-evaluated
+    // whenever either changes. Subscribing before the first read keeps a change in between from being missed.
+    const wanted = Effect.all([config.entries(), models.available(["image"])]).pipe(
+      Effect.map(([entries, available]) => settingsFrom(entries) !== false && available.length > 0),
+    )
     let enabled = false
-    const refresh = models.available(["image"]).pipe(
-      Effect.flatMap((available) => {
-        if (available.length > 0 === enabled) return Effect.void
-        enabled = available.length > 0
+    const refresh = wanted.pipe(
+      Effect.flatMap((next) => {
+        if (next === enabled) return Effect.void
+        enabled = next
         return ctx.tool.reload()
       }),
     )
-    yield* ctx.event.subscribe({ types: ["model.updated"] }).pipe(
+    yield* ctx.event.subscribe({ types: ["model.updated", "config.updated"] }).pipe(
       Stream.runForEach(() => refresh),
       Effect.forkScoped({ startImmediately: true }),
     )
-    enabled = (yield* models.available(["image"])).length > 0
+    enabled = yield* wanted
 
     yield* ctx.tool
       .transform((editor) => {
@@ -189,7 +208,8 @@ export const Plugin = {
           execute: (input, context) =>
             Effect.gen(function* () {
               const source = { type: "tool" as const, messageID: context.messageID, id: context.id }
-              const model = yield* resolveModel(input.model, context.sessionID, input.images !== undefined)
+              const resolved = yield* resolveModel(input.model, context.sessionID, input.images !== undefined)
+              const model = resolved.model
               const ref = `${model.providerID}/${model.id}`
               const target = input.path ? yield* access.resolve({ path: input.path, kind: "file" }) : undefined
               const requested =
@@ -250,7 +270,9 @@ export const Plugin = {
               if (yield* exists(file))
                 return yield* new ToolFailure({ message: `${file} already exists. Choose a new path.` })
               yield* environment.files.write(file, bytes)
-              const note = mime === "image/png" ? "" : ` The model returned ${mime}, so the file is in that format.`
+              const note =
+                (resolved.note ?? "") +
+                (mime === "image/png" ? "" : ` The model returned ${mime}, so the file is in that format.`)
               return {
                 output: { path: file, model: ref },
                 content: [
@@ -284,6 +306,13 @@ export function defaultModel(
   return PREFERRED_FAMILIES.flatMap((family) => pool.find((model) => model.family === family) ?? [])[0] ?? pool[0]
 }
 
+// Read per field so a later config that sets other experimental options doesn't hide this one.
+function settingsFrom(entries: readonly Entry[]) {
+  return entries.findLast(
+    (entry): entry is Document => entry.type === "document" && entry.info.experimental?.image_generation !== undefined,
+  )?.info.experimental?.image_generation
+}
+
 function acceptsImages(model: Model.Info) {
   return model.capabilities.input.some((item) => item.startsWith("image"))
 }
@@ -545,6 +545,7 @@ describe("ConfigNormalize", () => {
           todo: true,
           background_compaction: true,
           media_blob: true,
+          image_generation: { model: "openai/gpt-image-2" },
           subagent_depth: 0,
           location_idle_timeout: "2 hours",
           policies: [{ action: "provider.use", resource: "custom", effect: "allow" }],
@@ -556,6 +557,7 @@ describe("ConfigNormalize", () => {
         todo: true,
         background_compaction: true,
         media_blob: true,
+        image_generation: { model: { providerID: "openai", model: "gpt-image-2" } },
         subagent_depth: 0,
         location_idle_timeout: "7200000 millis",
       },
@@ -569,6 +571,22 @@ describe("ConfigNormalize", () => {
     })
   })
 
+  test("normalizes the image generation setting", () => {
+    expect(normalized({ experimental: { image_generation: false } }).encoded.experimental).toEqual({
+      image_generation: false,
+    })
+    expect(normalized({ experimental: { image_generation: {} } }).encoded.experimental).toEqual({
+      image_generation: {},
+    })
+    for (const value of [true, { model: "no-slash" }, { model: 1 }, "openai/gpt-image-2"]) {
+      const result = normalized({ experimental: { image_generation: value } })
+      expect(result.encoded.experimental).toBeUndefined()
+      expect(result.diagnostics.map((item) => [item.kind, item.path])).toEqual([
+        ["invalid", ["experimental", "image_generation"]],
+      ])
+    }
+  })
+
   test("never emits experimental policies", () => {
     expect(
       normalized({ experimental: { policies: [{ action: "provider.use", resource: "*", effect: "deny" }] } }).encoded,
 
@@ -1,6 +1,8 @@
 import { describe, expect } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
+import { Bus } from "@opencode/core/bus"
+import { Config } from "@opencode/core/config"
 import { Generate } from "@opencode/core/generate"
 import { Location } from "@opencode/core/location"
 import { Model } from "@opencode/core/model"
@@ -12,6 +14,8 @@ import { Session } from "@opencode/core/session"
 import { Tool } from "@opencode/core/tool"
 import { ImageGenerateTool } from "@opencode/core/tool/plugin/image-generate"
 import { OpenCodeTools } from "@opencode/core/tool/plugin/opencode"
+import { Document, Event, Info } from "@opencode/schema/config"
+import { ConfigExperimental } from "@opencode/schema/config/experimental"
 import type { ImageRequest, ImageResult } from "@opencode/schema/generate"
 import { Global } from "@opencode/util/global"
 import { Effect, Layer, Schedule } from "effect"
@@ -82,6 +86,33 @@ const setup = (providerID = "test") =>
     return { session, run, directory: location.directory }
   })
 
+const configure = (image_generation: ConfigExperimental.Info["image_generation"]) =>
+  Effect.gen(function* () {
+    const config = yield* Config.Test
+    yield* config.setEntries([
+      new Document({
+        type: "document",
+        info: new Info({ experimental: new ConfigExperimental.Info({ image_generation }) }),
+      }),
+    ])
+    const bus = yield* Bus.Service
+    yield* bus.publish(Event.Updated, {})
+  })
+
+const configuredModel = (providerID: string, model: string) => ({
+  model: { providerID: Provider.ID.make(providerID), model: Model.ID.make(model) },
+})
+
+const registered = Tool.Service.use((registry) => toolDefinitions(registry)).pipe(
+  Effect.map((tools) => tools.some((tool) => tool.name === ImageGenerateTool.name)),
+)
+// Catalog and config changes reach the tool through events, so wait for them instead of a fixed delay.
+const until = (expected: boolean) =>
+  registered.pipe(
+    Effect.repeat({ until: (value) => value === expected, schedule: Schedule.spaced("5 millis") }),
+    Effect.timeout("10 seconds"),
+  )
+
 const text = (result: { readonly content?: ReadonlyArray<Tool.Content> }) =>
   result.content?.[0]?.type === "text" ? result.content[0].text : undefined
 const failure = (result: { readonly error?: { readonly message: string } }) => result.error?.message
@@ -90,17 +121,6 @@ describe("image_generate", () => {
   it.live("is registered only while an image model is available", () =>
     Effect.gen(function* () {
       yield* setup()
-      const registry = yield* Tool.Service
-      const registered = toolDefinitions(registry).pipe(
-        Effect.map((tools) => tools.some((tool) => tool.name === ImageGenerateTool.name)),
-      )
-      // The catalog change reaches the tool through model.updated, so wait for it instead of a fixed delay.
-      const until = (expected: boolean) =>
-        registered.pipe(
-          Effect.repeat({ until: (value) => value === expected, schedule: Schedule.spaced("5 millis") }),
-          Effect.timeout("10 seconds"),
-        )
-
       expect(yield* registered).toBe(false)
       yield* imageModel("test", "painter")
       expect(yield* until(true)).toBe(true)
@@ -110,6 +130,49 @@ describe("image_generate", () => {
     }),
   )
 
+  it.live("is not registered while config turns it off", () =>
+    Effect.gen(function* () {
+      yield* imageModel("test", "painter")
+      yield* configure(false)
+      yield* setup()
+      expect(yield* registered).toBe(false)
+      yield* configure({})
+      expect(yield* until(true)).toBe(true)
+      yield* configure(false)
+      expect(yield* until(false)).toBe(false)
+    }),
+  )
+
+  it.live("uses the configured model unless the agent picks one, and falls back with a note", () =>
+    Effect.gen(function* () {
+      yield* imageModel("test", "painter", (model) => {
+        model.capabilities.input = ["text", "image"]
+      })
+      yield* imageModel("other", "text-only", (model) => {
+        model.capabilities.input = ["text"]
+      })
+      yield* configure(configuredModel("other", "text-only"))
+      const { run, directory } = yield* setup()
+      yield* Effect.promise(() => fs.writeFile(path.join(directory, "in.png"), Buffer.from(PNG, "base64")))
+
+      // The configured model beats the session's provider, and an explicit model beats both.
+      const configured = yield* run({ prompt: "x" })
+      expect(configured.output).toMatchObject({ model: "other/text-only" })
+      expect(text(configured)).not.toContain("used")
+      expect((yield* run({ prompt: "x", model: "test/painter" })).output).toMatchObject({ model: "test/painter" })
+
+      // A configured model that can't serve the call is skipped, and the result says why.
+      const edit = yield* run({ prompt: "x", images: ["in.png"] })
+      expect(edit.output).toMatchObject({ model: "test/painter" })
+      expect(text(edit)).toContain("other/text-only doesn't accept input images; used test/painter.")
+
+      yield* configure(configuredModel("gone", "model"))
+      const missing = yield* run({ prompt: "x" })
+      expect(missing.output).toMatchObject({ model: "test/painter" })
+      expect(text(missing)).toContain("gone/model isn't available; used test/painter.")
+    }),
+  )
+
   it.live("reads input images, asks permission, and saves the result without overwriting", () =>
     Effect.gen(function* () {
       yield* imageModel("test", "painter", (model) => {
 
@@ -2,6 +2,7 @@ export * as ConfigExperimental from "./experimental.js"
 
 import { Schema } from "effect"
 import { NonNegativeInt, optional } from "../schema.js"
+import { ConfigModel } from "./model.js"
 import { ConfigPolicy } from "./policy.js"
 
 export class Info extends Schema.Class<Info>("ConfigExperimental.Info")({
@@ -19,6 +20,15 @@ export class Info extends Schema.Class<Info>("ConfigExperimental.Info")({
     description:
       "Store new session media once in a deduplicated blob table instead of inline in every message row. Defaults to false.",
   }),
+  image_generation: Schema.Union([
+    Schema.Literal(false),
+    Schema.Struct({ model: ConfigModel.Selection.pipe(optional) }),
+  ])
+    .pipe(optional)
+    .annotate({
+      description:
+        "Image generation tool settings. `model` sets the default image model (providerID/modelID) used when the agent doesn't choose one; set to false to disable the image_generate tool.",
+    }),
   schedules: Schema.Boolean.pipe(optional).annotate({
     description: "Enable experimental scheduled tasks that wake a session with a prompt. Defaults to false.",
   }),