diff --git a/Packages/Edith/Sources/Edith/Core/Navigation/NavigationCatalog.swift b/Packages/Edith/Sources/Edith/Core/Navigation/NavigationCatalog.swift
index e7bbcd1db..b4a36ac4a 100644
--- a/Packages/Edith/Sources/Edith/Core/Navigation/NavigationCatalog.swift
+++ b/Packages/Edith/Sources/Edith/Core/Navigation/NavigationCatalog.swift
@@ -160,6 +160,9 @@ enum NavigationCatalog {
             id: "media", title: "Media", symbolName: "play.rectangle.on.rectangle",
             band: .suite(.media), isSuiteLanding: true,
             expansionKey: SuiteExpansion.key(for: .media)),
+        SidebarPage(
+            id: "mediaToolkit", title: "Media Toolkit", symbolName: "photo.stack",
+            band: .suite(.media), abilityIDs: ["mediaToolkit"], parentID: "media"),
         SidebarPage(
             id: "music", title: "Music", symbolName: "music.note", band: .suite(.media),
             abilityIDs: ["music"], parentID: "media"),
@@ -269,7 +272,7 @@ enum MainDestination: String, CaseIterable, Identifiable {
     case appMaintenance
     case system, runningApps
     case desk
-    case media, music, calendar
+    case media, music, mediaToolkit, calendar
     case data, database, attention, seoAudit
     case extensions, settings, about
 
diff --git a/Packages/Edith/Sources/Edith/Core/Navigation/PageContent.swift b/Packages/Edith/Sources/Edith/Core/Navigation/PageContent.swift
index 9d9a84835..6f9775723 100644
--- a/Packages/Edith/Sources/Edith/Core/Navigation/PageContent.swift
+++ b/Packages/Edith/Sources/Edith/Core/Navigation/PageContent.swift
@@ -25,6 +25,7 @@ struct PageContent: View {
         case .runningApps: SystemPage()
         case .desk: SuiteLandingPage(suite: SuiteRegistry.suite(.desk))
         case .media: SuiteLandingPage(suite: SuiteRegistry.suite(.media))
+        case .mediaToolkit: MediaToolkitPage()
         case .music: MusicPage()
         case .calendar: CalendarPage()
         case .data: SuiteLandingPage(suite: SuiteRegistry.suite(.data))
diff --git a/Packages/Edith/Sources/Edith/Features/Extensions/Views/ExtensionPreview.swift b/Packages/Edith/Sources/Edith/Features/Extensions/Views/ExtensionPreview.swift
index e9421bf46..b2f5fc28d 100644
--- a/Packages/Edith/Sources/Edith/Features/Extensions/Views/ExtensionPreview.swift
+++ b/Packages/Edith/Sources/Edith/Features/Extensions/Views/ExtensionPreview.swift
@@ -37,6 +37,7 @@ struct ExtensionPreview: View {
         case "clipboard": clipboardPreview(phase: phase)
         case "keystrokeHighlight": keystrokeHighlightPreview(phase: phase)
         case "music": musicPreview(animating: animating)
+        case "mediaToolkit": mediaToolkitPreview(phase: phase)
         case "focusDim": focusDimPreview(phase: phase)
         case "presenter": presenterPreview(phase: phase)
         case "colorPicker": colorPickerPreview(phase: phase)
@@ -48,6 +49,33 @@ struct ExtensionPreview: View {
         }
     }
 
+    private func mediaToolkitPreview(phase: Double) -> some View {
+        let progress = CGFloat(0.42 + (sin(phase * 1.8) + 1) * 0.22)
+        return VStack(alignment: .leading, spacing: UIScale.pt(8)) {
+            HStack(spacing: UIScale.pt(7)) {
+                ForEach(["photo", "photo.on.rectangle", "film"], id: \.self) { icon in
+                    RoundedRectangle(cornerRadius: UIScale.pt(5))
+                        .fill(DashSkin.paper2(dark))
+                        .overlay {
+                            Image(systemName: icon)
+                                .font(.system(size: UIScale.pt(9)))
+                                .foregroundStyle(DashSkin.inkFaint(dark))
+                        }
+                        .frame(width: UIScale.pt(30), height: UIScale.pt(25))
+                }
+            }
+            GeometryReader { proxy in
+                ZStack(alignment: .leading) {
+                    Capsule().fill(DashSkin.lineStrong(dark))
+                    Capsule().fill(DashSkin.accent(dark)).frame(width: proxy.size.width * progress)
+                }
+            }
+            .frame(height: UIScale.pt(5))
+        }
+        .padding(.horizontal, UIScale.pt(15))
+        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .center)
+    }
+
     private func usagePreview(phase: Double) -> some View {
         let fill = CGFloat(0.48 + sin(phase * 1.7) * 0.2)
         return VStack(alignment: .leading, spacing: UIScale.pt(6)) {
diff --git a/Packages/Edith/Sources/Edith/Features/MediaToolkit/MediaToolkitPage.swift b/Packages/Edith/Sources/Edith/Features/MediaToolkit/MediaToolkitPage.swift
new file mode 100644
index 000000000..0c8e2274a
--- /dev/null
+++ b/Packages/Edith/Sources/Edith/Features/MediaToolkit/MediaToolkitPage.swift
@@ -0,0 +1,840 @@
+import AppKit
+import EdithKit
+import Observation
+import SwiftUI
+import UniformTypeIdentifiers
+
+enum MediaToolkitMode: String, CaseIterable, Identifiable {
+    case images
+    case video
+
+    var id: String { rawValue }
+
+    var title: String {
+        switch self {
+        case .images: "Images"
+        case .video: "Video"
+        }
+    }
+}
+
+final class MediaCancellationToken: @unchecked Sendable {
+    private let lock = NSLock()
+    private var value = false
+
+    var isCancelled: Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return value
+    }
+
+    func cancel() {
+        lock.lock()
+        value = true
+        lock.unlock()
+    }
+}
+
+struct MediaToolkitExecutor {
+    var images:
+        ([URL], URL, MediaImageOptions, @escaping @Sendable (Int, Int) -> Void) async throws ->
+            [MediaImageResult]
+    var video:
+        (URL, URL, MediaVideoOptions, @escaping @Sendable (Double) -> Void) async throws ->
+            MediaVideoResult
+
+    static let agent = MediaToolkitExecutor(
+        images: { try await AgentMediaClient.convertImages($0, to: $1, options: $2, progress: $3) },
+        video: { try await AgentMediaClient.compressVideo($0, to: $1, options: $2, progress: $3) })
+}
+
+@MainActor
+@Observable
+final class MediaToolkitPageModel {
+    var mode = MediaToolkitMode.images {
+        didSet {
+            if mode != oldValue, !isProcessing { clearResults() }
+        }
+    }
+    private(set) var imageURLs: [URL] = []
+    private(set) var videoURL: URL?
+    var outputDirectory: URL?
+    private(set) var imageResults: [MediaImageResult] = []
+    private(set) var videoResult: MediaVideoResult?
+    private(set) var isProcessing = false
+    private(set) var progress = 0.0
+    private(set) var status = "Ready"
+    private(set) var errorMessage: String?
+    private var task: Task<Void, Never>?
+    private var cancellationToken: MediaCancellationToken?
+
+    private let executor: MediaToolkitExecutor
+
+    init(executor: MediaToolkitExecutor = .agent) {
+        self.executor = executor
+    }
+
+    var canProcess: Bool {
+        !isProcessing && (mode == .images ? !imageURLs.isEmpty : videoURL != nil)
+    }
+
+    var resolvedOutputDirectory: URL? {
+        if let outputDirectory { return outputDirectory }
+        switch mode {
+        case .images: return imageURLs.first?.deletingLastPathComponent()
+        case .video: return videoURL?.deletingLastPathComponent()
+        }
+    }
+
+    func add(_ urls: [URL]) {
+        guard !isProcessing else { return }
+        var images: [URL] = []
+        var videos: [URL] = []
+        for url in urls.prefix(10_000) {
+            let standardized = url.standardizedFileURL
+            if Self.isImage(standardized) {
+                images.append(standardized)
+            } else if Self.isVideo(standardized) {
+                videos.append(standardized)
+            }
+        }
+        if !images.isEmpty {
+            mode = .images
+            var seen = Set<URL>()
+            for url in imageURLs { seen.insert(url) }
+            for url in images where seen.insert(url).inserted { imageURLs.append(url) }
+        } else if let video = videos.first {
+            mode = .video
+            videoURL = video
+        } else {
+            errorMessage = "Choose an image or video that macOS can read."
+            return
+        }
+        clearResults()
+    }
+
+    func removeImage(_ url: URL) {
+        imageURLs.removeAll { $0 == url }
+        clearResults()
+    }
+
+    func removeVideo() {
+        videoURL = nil
+        clearResults()
+    }
+
+    func clearSelection() {
+        imageURLs = []
+        videoURL = nil
+        clearResults()
+    }
+
+    func process(imageOptions: MediaImageOptions, videoOptions: MediaVideoOptions) {
+        guard canProcess, let destination = resolvedOutputDirectory else { return }
+        let token = MediaCancellationToken()
+        cancellationToken = token
+        isProcessing = true
+        progress = 0
+        status = mode == .images ? "Converting images" : "Compressing video"
+        errorMessage = nil
+        imageResults = []
+        videoResult = nil
+        let selectedMode = mode
+        let images = imageURLs
+        let video = videoURL
+        task = Task { [weak self] in
+            guard let model = self else { return }
+            do {
+                switch selectedMode {
+                case .images:
+                    let results = try await model.executor.images(
+                        images, destination, imageOptions,
+                        { completed, total in
+                            Task { @MainActor in
+                                model.progress = Double(completed) / Double(max(1, total))
+                                model.status = "Converted \(completed) of \(total)"
+                            }
+                        })
+                    guard model.cancellationToken === token else { return }
+                    model.imageResults = results
+                    let succeeded = results.filter { $0.outputURL != nil }.count
+                    model.status = "Converted \(succeeded) of \(results.count)"
+                case .video:
+                    guard let video else { return }
+                    let result = try await model.executor.video(
+                        video, destination, videoOptions,
+                        { value in
+                            Task { @MainActor in
+                                model.progress = value
+                                model.status = "Compressing \(Int(value * 100))%"
+                            }
+                        })
+                    guard model.cancellationToken === token else { return }
+                    model.videoResult = result
+                    model.status = "Compression complete"
+                }
+                model.progress = 1
+                model.finish()
+            } catch is CancellationError {
+                guard model.cancellationToken === token else { return }
+                model.status = "Cancelled"
+                model.progress = 0
+                model.finish()
+            } catch {
+                guard model.cancellationToken === token else { return }
+                model.errorMessage = error.localizedDescription
+                model.status = "Could not finish"
+                model.progress = 0
+                model.finish()
+            }
+        }
+    }
+
+    func cancel() {
+        guard isProcessing else { return }
+        status = "Cancelling"
+        cancellationToken?.cancel()
+        task?.cancel()
+    }
+
+    func reveal(_ url: URL) {
+        NSWorkspace.shared.activateFileViewerSelecting([url])
+    }
+
+    func open(_ url: URL) {
+        NSWorkspace.shared.open(url)
+    }
+
+    private func clearResults() {
+        imageResults = []
+        videoResult = nil
+        errorMessage = nil
+        progress = 0
+        status = "Ready"
+    }
+
+    private func finish() {
+        isProcessing = false
+        task = nil
+        cancellationToken = nil
+    }
+
+    private static func isImage(_ url: URL) -> Bool {
+        UTType(filenameExtension: url.pathExtension)?.conforms(to: .image) == true
+    }
+
+    private static func isVideo(_ url: URL) -> Bool {
+        UTType(filenameExtension: url.pathExtension)?.conforms(to: .movie) == true
+    }
+}
+
+struct MediaToolkitPage: View {
+    @State private var model: MediaToolkitPageModel
+    @State private var dropTargeted = false
+    @AppStorage(AppStorageKeys.MediaToolkit.imageFormat, store: SharedDefaults.store)
+    private var imageFormat = MediaImageFormat.jpeg.rawValue
+    @AppStorage(AppStorageKeys.MediaToolkit.imageMaxDimension, store: SharedDefaults.store)
+    private var imageMaxDimension = 1600
+    @AppStorage(AppStorageKeys.MediaToolkit.imageQuality, store: SharedDefaults.store)
+    private var imageQuality = 0.82
+    @AppStorage(AppStorageKeys.MediaToolkit.videoKeepAudio, store: SharedDefaults.store)
+    private var videoKeepAudio = true
+    @AppStorage(AppStorageKeys.MediaToolkit.videoTargetMegabytes, store: SharedDefaults.store)
+    private var videoTargetMegabytes = 20
+    @Environment(\.colorScheme) private var scheme
+    @Environment(\.compactLayout) private var compact
+
+    @MainActor init(model: MediaToolkitPageModel? = nil) {
+        _model = State(initialValue: model ?? MediaToolkitPageModel())
+    }
+
+    private var dark: Bool { scheme == .dark }
+
+    var body: some View {
+        @Bindable var model = model
+        VStack(spacing: 0) {
+            PageHeader(
+                "Media Toolkit",
+                trailing: {
+                    Label("ON-DEVICE", systemImage: "lock.fill")
+                        .font(DashSkin.mono(9, weight: .semibold))
+                        .foregroundStyle(DashSkin.accent(dark))
+                        .padding(.horizontal, UIScale.pt(10))
+                        .padding(.vertical, UIScale.pt(6))
+                        .background(DashSkin.accent(dark).opacity(0.1), in: Capsule())
+                },
+                accessory: {
+                    Picker("Media type", selection: $model.mode) {
+                        ForEach(MediaToolkitMode.allCases) { mode in
+                            Text(mode.title).tag(mode)
+                        }
+                    }
+                    .labelsHidden()
+                    .pickerStyle(.segmented)
+                    .frame(maxWidth: compact ? .infinity : UIScale.pt(320))
+                    .disabled(model.isProcessing)
+                })
+            ScrollView {
+                VStack(alignment: .leading, spacing: UIScale.pt(16)) {
+                    intro
+                    dropZone
+                    if hasSelection { selectionCard }
+                    settingsCard
+                    outputCard
+                    actionCard
+                    if hasResults { resultsCard }
+                }
+                .pageContent(compact, width: .readable)
+            }
+        }
+        .background(DashSkin.paper(dark))
+        .onDrop(of: [.fileURL], isTargeted: $dropTargeted) { providers in
+            Task {
+                model.add(await MediaToolkitDrop.urls(from: providers))
+            }
+            return true
+        }
+        .onDisappear { model.cancel() }
+    }
+
+    private var hasSelection: Bool {
+        model.mode == .images ? !model.imageURLs.isEmpty : model.videoURL != nil
+    }
+
+    private var hasResults: Bool {
+        !model.imageResults.isEmpty || model.videoResult != nil
+    }
+
+    private var intro: some View {
+        HStack(alignment: .top, spacing: UIScale.pt(14)) {
+            Image(systemName: model.mode == .images ? "photo.stack" : "film.stack")
+                .font(.system(size: UIScale.pt(22), weight: .medium))
+                .foregroundStyle(DashSkin.accent(dark))
+                .frame(width: UIScale.pt(42), height: UIScale.pt(42))
+                .background(
+                    DashSkin.accent(dark).opacity(0.1), in: RoundedRectangle(cornerRadius: 11))
+            VStack(alignment: .leading, spacing: UIScale.pt(5)) {
+                Text(model.mode == .images ? "Prepare a whole image batch" : "Make a video fit")
+                    .font(DashSkin.serif(20))
+                    .foregroundStyle(DashSkin.ink(dark))
+                Text(
+                    model.mode == .images
+                        ? "Convert formats, resize the longest edge, and keep every original untouched."
+                        : "Create a complete H.264 MP4 under a hard size limit without trimming the timeline."
+                )
+                .font(.system(size: UIScale.pt(12)))
+                .foregroundStyle(DashSkin.inkSoft(dark))
+                .fixedSize(horizontal: false, vertical: true)
+            }
+            Spacer(minLength: 0)
+        }
+        .padding(UIScale.pt(16))
+        .mediaCard(dark)
+    }
+
+    private var dropZone: some View {
+        Button(action: chooseInputs) {
+            VStack(spacing: UIScale.pt(9)) {
+                Image(systemName: dropTargeted ? "arrow.down.circle.fill" : "plus.circle")
+                    .font(.system(size: UIScale.pt(30), weight: .light))
+                    .foregroundStyle(DashSkin.accent(dark))
+                Text(model.mode == .images ? "Drop images here" : "Drop a video here")
+                    .font(.system(size: UIScale.pt(14), weight: .semibold))
+                    .foregroundStyle(DashSkin.ink(dark))
+                Text(model.mode == .images ? "or choose multiple files" : "or choose one file")
+                    .font(.system(size: UIScale.pt(11)))
+                    .foregroundStyle(DashSkin.inkFaint(dark))
+            }
+            .frame(maxWidth: .infinity, minHeight: UIScale.pt(128))
+            .background(
+                dropTargeted ? DashSkin.accent(dark).opacity(0.1) : DashSkin.paper2(dark),
+                in: RoundedRectangle(cornerRadius: UIScale.pt(14))
+            )
+            .overlay {
+                RoundedRectangle(cornerRadius: UIScale.pt(14))
+                    .stroke(
+                        dropTargeted ? DashSkin.accent(dark) : DashSkin.lineStrong(dark),
+                        style: StrokeStyle(lineWidth: 1.2, dash: [7, 5]))
+            }
+        }
+        .buttonStyle(.edith(.borderless))
+        .disabled(model.isProcessing)
+        .accessibilityLabel(model.mode == .images ? "Choose input images" : "Choose input video")
+    }
+
+    private var selectionCard: some View {
+        MediaToolkitCard(
+            title: model.mode == .images ? "Selected images" : "Selected video",
+            subtitle: model.mode == .images ? "\(model.imageURLs.count) files" : nil
+        ) {
+            if model.mode == .images {
+                ForEach(model.imageURLs, id: \.self) { url in
+                    MediaToolkitFileRow(url: url) {
+                        model.removeImage(url)
+                    }
+                    if url != model.imageURLs.last { Divider().opacity(0.4) }
+                }
+            } else if let url = model.videoURL {
+                MediaToolkitFileRow(url: url) { model.removeVideo() }
+            }
+            HStack {
+                Button(model.mode == .images ? "Add more" : "Choose another") { chooseInputs() }
+                Spacer()
+                Button("Clear", role: .destructive) { model.clearSelection() }
+            }
+            .buttonStyle(.edith(.borderless))
+            .disabled(model.isProcessing)
+        }
+    }
+
+    @ViewBuilder
+    private var settingsCard: some View {
+        if model.mode == .images {
+            MediaToolkitCard(title: "Image settings", subtitle: imageSettingsSummary) {
+                Picker(
+                    "Format",
+                    selection: $imageFormat.configured(AppStorageKeys.MediaToolkit.imageFormat)
+                ) {
+                    ForEach(MediaImageFormat.allCases) { format in
+                        Text(format.rawValue.uppercased()).tag(format.rawValue)
+                    }
+                }
+                .pickerStyle(.segmented)
+                LabeledContent("Longest edge") {
+                    Picker(
+                        "Longest edge",
+                        selection: $imageMaxDimension.configured(
+                            AppStorageKeys.MediaToolkit.imageMaxDimension)
+                    ) {
+                        Text("Original").tag(0)
+                        ForEach([512, 1024, 1600, 2048, 3840], id: \.self) { value in
+                            Text("\(value) px").tag(value)
+                        }
+                    }
+                    .labelsHidden()
+                    .frame(width: UIScale.pt(150))
+                }
+                VStack(alignment: .leading, spacing: UIScale.pt(6)) {
+                    LabeledContent("Quality") {
+                        Text("\(Int(imageQuality * 100))%")
+                            .monospacedDigit()
+                            .foregroundStyle(.secondary)
+                    }
+                    Slider(
+                        value: $imageQuality.configured(AppStorageKeys.MediaToolkit.imageQuality),
+                        in: 0.1...1, step: 0.01)
+                    Text("Quality affects JPEG and HEIC. PNG remains lossless.")
+                        .font(.system(size: UIScale.pt(10.5)))
+                        .foregroundStyle(.tertiary)
+                }
+            }
+            .disabled(model.isProcessing)
+        } else {
+            MediaToolkitCard(title: "Video settings", subtitle: "H.264 · MP4") {
+                LabeledContent("Maximum size") {
+                    Stepper(
+                        "\(videoTargetMegabytes) MB",
+                        value: $videoTargetMegabytes.configured(
+                            AppStorageKeys.MediaToolkit.videoTargetMegabytes),
+                        in: 1...512
+                    )
+                    .monospacedDigit()
+                }
+                HStack(spacing: UIScale.pt(6)) {
+                    ForEach([5, 10, 20, 50, 100], id: \.self) { value in
+                        Button("\(value) MB") { setVideoTarget(value) }
+                            .buttonStyle(.edith(.borderless))
+                            .padding(.horizontal, UIScale.pt(7))
+                            .padding(.vertical, UIScale.pt(4))
+                            .background(
+                                videoTargetMegabytes == value
+                                    ? DashSkin.accent(dark).opacity(0.12) : Color.clear,
+                                in: Capsule())
+                    }
+                }
+                Toggle(
+                    "Keep audio",
+                    isOn: $videoKeepAudio.configured(
+                        AppStorageKeys.MediaToolkit.videoKeepAudio))
+                Text(
+                    "The complete timeline is preserved. Very small targets may be refused rather than trimming the video."
+                )
+                .font(.system(size: UIScale.pt(10.5)))
+                .foregroundStyle(.tertiary)
+                .fixedSize(horizontal: false, vertical: true)
+            }
+            .disabled(model.isProcessing)
+        }
+    }
+
+    private var outputCard: some View {
+        MediaToolkitCard(title: "Output", subtitle: "Originals stay untouched") {
+            HStack(spacing: UIScale.pt(10)) {
+                Image(systemName: "folder")
+                    .foregroundStyle(DashSkin.accent(dark))
+                VStack(alignment: .leading, spacing: UIScale.pt(2)) {
+                    Text(
+                        model.outputDirectory == nil ? "Beside the selected files" : "Chosen folder"
+                    )
+                    .font(.system(size: UIScale.pt(12), weight: .medium))
+                    Text(
+                        model.resolvedOutputDirectory?.path(percentEncoded: false)
+                            ?? "Select media first"
+                    )
+                    .font(DashSkin.mono(10))
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+                    .truncationMode(.middle)
+                }
+                Spacer(minLength: UIScale.pt(8))
+                if model.outputDirectory != nil {
+                    Button("Use source folder") { model.outputDirectory = nil }
+                        .buttonStyle(.edith(.borderless))
+                }
+                Button("Choose folder") { chooseOutputDirectory() }
+            }
+            .disabled(model.isProcessing)
+        }
+    }
+
+    private var actionCard: some View {
+        VStack(alignment: .leading, spacing: UIScale.pt(11)) {
+            HStack(spacing: UIScale.pt(10)) {
+                VStack(alignment: .leading, spacing: UIScale.pt(3)) {
+                    Text(model.status)
+                        .font(.system(size: UIScale.pt(12), weight: .semibold))
+                    Text(actionDetail)
+                        .font(.system(size: UIScale.pt(10.5)))
+                        .foregroundStyle(.secondary)
+                }
+                Spacer(minLength: UIScale.pt(10))
+                if model.isProcessing {
+                    Button("Cancel", role: .cancel) { model.cancel() }
+                } else {
+                    Button(actionTitle) { process() }
+                        .buttonStyle(.edith(.primary))
+                        .disabled(!model.canProcess)
+                }
+            }
+            if model.isProcessing {
+                ProgressView(value: model.progress)
+                    .progressViewStyle(.linear)
+            }
+            if let error = model.errorMessage {
+                Label(error, systemImage: "exclamationmark.triangle.fill")
+                    .font(.system(size: UIScale.pt(11)))
+                    .foregroundStyle(.red)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+        }
+        .padding(UIScale.pt(14))
+        .background(
+            DashSkin.accent(dark).opacity(dark ? 0.08 : 0.06),
+            in: RoundedRectangle(cornerRadius: 14)
+        )
+        .overlay {
+            RoundedRectangle(cornerRadius: UIScale.pt(14))
+                .stroke(DashSkin.accent(dark).opacity(0.22), lineWidth: 1)
+        }
+    }
+
+    private var resultsCard: some View {
+        MediaToolkitCard(title: "Finished output", subtitle: resultSummary) {
+            ForEach(model.imageResults, id: \.inputURL) { result in
+                MediaToolkitResultRow(
+                    name: result.inputURL.lastPathComponent,
+                    outputURL: result.outputURL,
+                    inputBytes: result.inputBytes,
+                    outputBytes: result.outputBytes,
+                    error: result.error,
+                    open: model.open,
+                    reveal: model.reveal)
+                if result.inputURL != model.imageResults.last?.inputURL {
+                    Divider().opacity(0.4)
+                }
+            }
+            if let result = model.videoResult {
+                MediaToolkitResultRow(
+                    name: result.inputURL.lastPathComponent,
+                    outputURL: result.outputURL,
+                    inputBytes: result.inputBytes,
+                    outputBytes: result.outputBytes,
+                    error: nil,
+                    open: model.open,
+                    reveal: model.reveal)
+            }
+        }
+    }
+
+    private var imageSettingsSummary: String {
+        let dimension = imageMaxDimension == 0 ? "original size" : "\(imageMaxDimension) px"
+        return "\(imageFormat.uppercased()) · \(dimension)"
+    }
+
+    private var actionTitle: String {
+        model.mode == .images ? "Convert images" : "Compress video"
+    }
+
+    private var actionDetail: String {
+        if model.isProcessing { return "You can cancel without changing the originals." }
+        if model.mode == .images {
+            return model.imageURLs.isEmpty
+                ? "Choose one or more images to begin."
+                : "\(model.imageURLs.count) image\(model.imageURLs.count == 1 ? "" : "s") ready."
+        }
+        return model.videoURL == nil ? "Choose one video to begin." : "The full video is ready."
+    }
+
+    private var resultSummary: String? {
+        if let result = model.videoResult {
+            return MediaToolkitFormatting.change(from: result.inputBytes, to: result.outputBytes)
+        }
+        let successful = model.imageResults.filter { $0.outputURL != nil }
+        guard !successful.isEmpty else { return nil }
+        return "\(successful.count) file\(successful.count == 1 ? "" : "s") written"
+    }
+
+    private func process() {
+        let format = MediaImageFormat(rawValue: imageFormat) ?? .jpeg
+        model.process(
+            imageOptions: MediaImageOptions(
+                format: format, quality: imageQuality,
+                maxDimension: imageMaxDimension == 0 ? nil : imageMaxDimension),
+            videoOptions: MediaVideoOptions(
+                targetMegabytes: videoTargetMegabytes, keepAudio: videoKeepAudio))
+    }
+
+    private func setVideoTarget(_ value: Int) {
+        $videoTargetMegabytes.configured(AppStorageKeys.MediaToolkit.videoTargetMegabytes)
+            .wrappedValue = value
+    }
+
+    private func chooseInputs() {
+        let panel = NSOpenPanel()
+        panel.canChooseDirectories = false
+        panel.canChooseFiles = true
+        panel.allowsMultipleSelection = model.mode == .images
+        panel.allowedContentTypes = model.mode == .images ? [.image] : [.movie]
+        panel.prompt = model.mode == .images ? "Add" : "Choose"
+        panel.message =
+            model.mode == .images ? "Choose images to convert" : "Choose a video to compress"
+        guard panel.runModal() == .OK else { return }
+        model.add(panel.urls)
+    }
+
+    private func chooseOutputDirectory() {
+        let panel = NSOpenPanel()
+        panel.canChooseDirectories = true
+        panel.canCreateDirectories = true
+        panel.canChooseFiles = false
+        panel.allowsMultipleSelection = false
+        panel.prompt = "Choose"
+        panel.message = "Choose where converted media should be written"
+        guard panel.runModal() == .OK, let url = panel.url else { return }
+        model.outputDirectory = url
+    }
+}
+
+struct MediaToolkitCard<Content: View>: View {
+    let title: String
+    var subtitle: String?
+    @ViewBuilder let content: () -> Content
+    @Environment(\.colorScheme) private var scheme
+
+    var body: some View {
+        let dark = scheme == .dark
+        VStack(alignment: .leading, spacing: UIScale.pt(12)) {
+            HStack(alignment: .firstTextBaseline) {
+                Text(title)
+                    .font(.system(size: UIScale.pt(14), weight: .semibold))
+                    .foregroundStyle(DashSkin.ink(dark))
+                Spacer(minLength: UIScale.pt(8))
+                if let subtitle {
+                    Text(subtitle)
+                        .font(.system(size: UIScale.pt(10.5)))
+                        .foregroundStyle(.secondary)
+                }
+            }
+            content()
+        }
+        .padding(UIScale.pt(15))
+        .mediaCard(dark)
+    }
+}
+
+struct MediaToolkitFileRow: View {
+    let url: URL
+    let remove: () -> Void
+
+    var body: some View {
+        HStack(spacing: UIScale.pt(10)) {
+            Image(nsImage: NSWorkspace.shared.icon(forFile: url.path))
+                .resizable()
+                .scaledToFit()
+                .frame(width: UIScale.pt(28), height: UIScale.pt(28))
+            VStack(alignment: .leading, spacing: UIScale.pt(2)) {
+                Text(url.lastPathComponent)
+                    .font(.system(size: UIScale.pt(12), weight: .medium))
+                    .lineLimit(1)
+                Text(MediaToolkitFormatting.fileSize(url))
+                    .font(DashSkin.mono(9.5))
+                    .foregroundStyle(.secondary)
+            }
+            Spacer(minLength: UIScale.pt(8))
+            Button(action: remove) {
+                Image(systemName: "xmark.circle.fill")
+                    .foregroundStyle(.secondary)
+            }
+            .buttonStyle(.edith(.borderless))
+            .accessibilityLabel("Remove \(url.lastPathComponent)")
+        }
+    }
+}
+
+struct MediaToolkitResultRow: View {
+    let name: String
+    let outputURL: URL?
+    let inputBytes: Int64
+    let outputBytes: Int64
+    let error: String?
+    let open: (URL) -> Void
+    let reveal: (URL) -> Void
+
+    var body: some View {
+        HStack(spacing: UIScale.pt(10)) {
+            Image(systemName: outputURL == nil ? "xmark.circle.fill" : "checkmark.circle.fill")
+                .font(.system(size: UIScale.pt(18)))
+                .foregroundStyle(outputURL == nil ? .red : .green)
+            VStack(alignment: .leading, spacing: UIScale.pt(3)) {
+                Text(name)
+                    .font(.system(size: UIScale.pt(12), weight: .medium))
+                    .lineLimit(1)
+                Text(error ?? MediaToolkitFormatting.change(from: inputBytes, to: outputBytes))
+                    .font(.system(size: UIScale.pt(10.5)))
+                    .foregroundStyle(.secondary)
+                    .lineLimit(2)
+            }
+            Spacer(minLength: UIScale.pt(8))
+            if let outputURL {
+                Button("Open") { open(outputURL) }
+                    .buttonStyle(.edith(.borderless))
+                Button("Reveal") { reveal(outputURL) }
+                    .buttonStyle(.edith(.borderless))
+            }
+        }
+    }
+}
+
+enum MediaToolkitFormatting {
+    static func bytes(_ value: Int64) -> String {
+        ByteCountFormatter.string(fromByteCount: value, countStyle: .file)
+    }
+
+    static func fileSize(_ url: URL) -> String {
+        let value = Int64((try? url.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0)
+        return bytes(value)
+    }
+
+    static func change(from input: Int64, to output: Int64) -> String {
+        guard input > 0 else { return bytes(output) }
+        let percent = Int(((1 - Double(output) / Double(input)) * 100).rounded())
+        let direction = percent >= 0 ? "smaller" : "larger"
+        return "\(bytes(input)) to \(bytes(output)) · \(abs(percent))% \(direction)"
+    }
+}
+
+enum MediaToolkitDrop {
+    @MainActor
+    static func urls(from providers: [NSItemProvider]) async -> [URL] {
+        var urls: [URL] = []
+        for provider in providers {
+            if let url = try? await provider.loadItem(
+                forTypeIdentifier: UTType.fileURL.identifier) as? URL
+            {
+                urls.append(url)
+            } else if let data = try? await provider.loadItem(
+                forTypeIdentifier: UTType.fileURL.identifier) as? Data,
+                let url = URL(dataRepresentation: data, relativeTo: nil)
+            {
+                urls.append(url)
+            }
+        }
+        return urls
+    }
+}
+
+extension View {
+    fileprivate func mediaCard(_ dark: Bool) -> some View {
+        background(DashSkin.paper2(dark), in: RoundedRectangle(cornerRadius: UIScale.pt(14)))
+            .overlay {
+                RoundedRectangle(cornerRadius: UIScale.pt(14))
+                    .stroke(DashSkin.line(dark), lineWidth: 1)
+            }
+    }
+}
+
+struct MediaToolkitRows: View {
+    @AppStorage(AppStorageKeys.Tabs.mediaToolkitEnabled, store: SharedDefaults.store)
+    private var enabled = false
+    @AppStorage(AppStorageKeys.MediaToolkit.imageFormat, store: SharedDefaults.store)
+    private var imageFormat = MediaImageFormat.jpeg.rawValue
+    @AppStorage(AppStorageKeys.MediaToolkit.imageMaxDimension, store: SharedDefaults.store)
+    private var imageMaxDimension = 1600
+    @AppStorage(AppStorageKeys.MediaToolkit.imageQuality, store: SharedDefaults.store)
+    private var imageQuality = 0.82
+    @AppStorage(AppStorageKeys.MediaToolkit.videoKeepAudio, store: SharedDefaults.store)
+    private var videoKeepAudio = true
+    @AppStorage(AppStorageKeys.MediaToolkit.videoTargetMegabytes, store: SharedDefaults.store)
+    private var videoTargetMegabytes = 20
+
+    var body: some View {
+        Section("Image conversion") {
+            Picker(
+                "Format",
+                selection: $imageFormat.configured(AppStorageKeys.MediaToolkit.imageFormat)
+            ) {
+                ForEach(MediaImageFormat.allCases) { format in
+                    Text(format.rawValue.uppercased()).tag(format.rawValue)
+                }
+            }
+            Picker(
+                "Longest edge",
+                selection: $imageMaxDimension.configured(
+                    AppStorageKeys.MediaToolkit.imageMaxDimension)
+            ) {
+                Text("Original size").tag(0)
+                ForEach([512, 1024, 1600, 2048, 3840], id: \.self) { value in
+                    Text("\(value) px").tag(value)
+                }
+            }
+            LabeledContent("Quality") {
+                HStack {
+                    Slider(
+                        value: $imageQuality.configured(AppStorageKeys.MediaToolkit.imageQuality),
+                        in: 0.1...1, step: 0.01
+                    )
+                    .frame(width: UIScale.pt(150))
+                    Text("\(Int(imageQuality * 100))%")
+                        .monospacedDigit()
+                        .frame(width: UIScale.pt(38), alignment: .trailing)
+                }
+            }
+        }
+        .disabled(!enabled)
+        .opacity(enabled ? 1 : 0.5)
+
+        Section("Video compression") {
+            Stepper(
+                "Maximum size: \(videoTargetMegabytes) MB",
+                value: $videoTargetMegabytes.configured(
+                    AppStorageKeys.MediaToolkit.videoTargetMegabytes),
+                in: 1...512)
+            Toggle(
+                "Keep audio",
+                isOn: $videoKeepAudio.configured(AppStorageKeys.MediaToolkit.videoKeepAudio))
+            Button("Open Media Toolkit") { SectionWindow.open(.mediaToolkit) }
+        }
+        .disabled(!enabled)
+        .opacity(enabled ? 1 : 0.5)
+    }
+}
diff --git a/Packages/Edith/Sources/Edith/Features/Settings/Views/ExtensionsPane.swift b/Packages/Edith/Sources/Edith/Features/Settings/Views/ExtensionsPane.swift
index bc4877773..0d4794aa0 100644
--- a/Packages/Edith/Sources/Edith/Features/Settings/Views/ExtensionsPane.swift
+++ b/Packages/Edith/Sources/Edith/Features/Settings/Views/ExtensionsPane.swift
@@ -665,6 +665,7 @@ private struct ExtensionSettingsSheet: View {
         case "lidAwake": 400
         case "music": 460
         case "focusDim", "colorPicker", "keystrokeHighlight": 430
+        case "mediaToolkit": 520
         case "system": 500
         case "notchShelf", "presenter": 580
         default: 620
@@ -1059,6 +1060,7 @@ private struct ExtensionDetailRows: View {
                 MusicRows()
                 MusicBarRows()
             case .downloads: DownloadsRows()
+            case .mediaToolkit: MediaToolkitRows()
             case .calendar: CalendarRows()
             case .notchShelf: NotchShelfRows()
             case .audioMixer: AudioMixerRows()
diff --git a/Packages/Edith/Sources/EdithAgent/AgentMain.swift b/Packages/Edith/Sources/EdithAgent/AgentMain.swift
index a545cc3eb..54fa730cb 100644
--- a/Packages/Edith/Sources/EdithAgent/AgentMain.swift
+++ b/Packages/Edith/Sources/EdithAgent/AgentMain.swift
@@ -97,6 +97,7 @@ public enum AgentBoot {
                         }
                     }, record: { await runtime.record($0) })
                 await tasks.registerCommand()
+                await MediaToolkitWorkflow.register(on: tasks)
                 await StorageInspectionWorkflow().register(on: tasks)
                 await AgentMachineOperations.register(on: tasks)
                 await downloads.registerEstimate(on: tasks)
diff --git a/Packages/Edith/Sources/EdithAgent/MediaToolkitWorkflow.swift b/Packages/Edith/Sources/EdithAgent/MediaToolkitWorkflow.swift
new file mode 100644
index 000000000..632699cd6
--- /dev/null
+++ b/Packages/Edith/Sources/EdithAgent/MediaToolkitWorkflow.swift
@@ -0,0 +1,36 @@
+import EdithKit
+import Foundation
+
+public enum MediaToolkitWorkflow {
+    public static func register(on tasks: AgentTaskService) async {
+        await tasks.register(
+            operation: MediaToolkitOperation.convertImages.descriptor.id.rawValue, concurrency: 1
+        ) { payload, context in
+            try requireEnabled()
+            let request = try AgentPayload.decode(MediaImageTaskRequest.self, from: payload)
+            let result = try MediaToolkit.convertImages(
+                request.inputs, to: request.destination, options: request.options,
+                progress: { completed, _ in context.report(String(completed)) },
+                cancelled: { Task.isCancelled })
+            return try AgentPayload.encode(result)
+        }
+        await tasks.register(
+            operation: MediaToolkitOperation.compressVideo.descriptor.id.rawValue, concurrency: 1
+        ) { payload, context in
+            try requireEnabled()
+            let request = try AgentPayload.decode(MediaVideoTaskRequest.self, from: payload)
+            let result = try await MediaToolkit.compressVideo(
+                request.input, to: request.destination, options: request.options,
+                progress: { context.report(String($0)) }, cancelled: { Task.isCancelled })
+            return try AgentPayload.encode(result)
+        }
+    }
+
+    private static func requireEnabled() throws {
+        guard ExtensionRegistry.entry("mediaToolkit")?.isEnabled(in: SharedDefaults.store) == true
+        else {
+            throw MediaToolkitError.failed(
+                "Enable the Media Toolkit ability before processing media.")
+        }
+    }
+}
diff --git a/Packages/Edith/Sources/EdithCLI/CommandTree.swift b/Packages/Edith/Sources/EdithCLI/CommandTree.swift
index 24a69be77..b50d59938 100644
--- a/Packages/Edith/Sources/EdithCLI/CommandTree.swift
+++ b/Packages/Edith/Sources/EdithCLI/CommandTree.swift
@@ -135,6 +135,16 @@ public enum CommandTree {
     typealias Spec = CommandSpec
 
     static let specs: [String: Spec] = [
+        "ed media status": Spec(options: ["--json", "--help"]),
+        "ed media convert-images": Spec(
+            options: [
+                "--json", "--help", "--to", "--format", "--quality",
+                "--max-dimension",
+            ], optionValues: ["--to": .localPath], repeatingArgument: .localPath),
+        "ed media compress-video": Spec(
+            options: ["--json", "--help", "--to", "--target-mb", "--no-audio"],
+            optionValues: ["--to": .localPath], arguments: [.localPath]),
+        "ed media": Spec(options: ["--json", "--help"]),
         "ed": Spec(options: ["--help", "--version"]),
         "ed guide": Spec(options: ["--json"], arguments: [.guideTopic]),
         "ed version": Spec(options: ["--json", "-h", "--help", "--version"]),
diff --git a/Packages/Edith/Sources/EdithCLI/Commands/MediaCommands.swift b/Packages/Edith/Sources/EdithCLI/Commands/MediaCommands.swift
new file mode 100644
index 000000000..5cb549c6e
--- /dev/null
+++ b/Packages/Edith/Sources/EdithCLI/Commands/MediaCommands.swift
@@ -0,0 +1,251 @@
+import ArgumentParser
+import EdithKit
+import Foundation
+
+struct MediaCommand: AsyncParsableCommand {
+    static let configuration = CommandConfiguration(
+        commandName: "media",
+        abstract: "Convert images and compress videos locally.",
+        subcommands: [
+            MediaStatusCommand.self, MediaConvertImagesCommand.self,
+            MediaCompressVideoCommand.self,
+        ],
+        defaultSubcommand: MediaStatusCommand.self)
+}
+
+struct MediaStatusCommand: AsyncParsableCommand {
+    static let configuration = CommandConfiguration(
+        commandName: "status", abstract: "Show Media Toolkit defaults and supported formats.")
+
+    @Flag(name: .long, help: "Emit JSON on stdout.")
+    var json = false
+
+    func run() async throws {
+        try await execute {
+            let defaults = CLIEnvironment.sharedDefaults
+            let enabled =
+                ExtensionRegistry.entry("mediaToolkit")?.isEnabled(in: defaults) ?? false
+            let format =
+                defaults.string(forKey: AppStorageKeys.MediaToolkit.imageFormat)
+                ?? MediaImageFormat.jpeg.rawValue
+            let maxDimension =
+                defaults.object(forKey: AppStorageKeys.MediaToolkit.imageMaxDimension) as? Int
+                ?? 1600
+            let quality =
+                defaults.object(forKey: AppStorageKeys.MediaToolkit.imageQuality) as? Double
+                ?? 0.82
+            let targetMegabytes =
+                defaults.object(forKey: AppStorageKeys.MediaToolkit.videoTargetMegabytes) as? Int
+                ?? 20
+            let keepAudio =
+                defaults.object(forKey: AppStorageKeys.MediaToolkit.videoKeepAudio) as? Bool
+                ?? true
+            guard !json else {
+                CLIOut.json(
+                    .object([
+                        "enabled": .bool(enabled),
+                        "image": .object([
+                            "format": .string(format),
+                            "formats": .strings(MediaImageFormat.allCases.map(\.rawValue)),
+                            "maxDimension": .int(maxDimension),
+                            "quality": .double(quality),
+                        ]),
+                        "video": .object([
+                            "keepAudio": .bool(keepAudio),
+                            "targetMegabytes": .int(targetMegabytes),
+                        ]),
+                    ]))
+                return
+            }
+            CLIOut.out("Media Toolkit: \(enabled ? "on" : "off")")
+            CLIOut.out(
+                "Images: \(format), \(maxDimension == 0 ? "original size" : "\(maxDimension) px"), \(Int(quality * 100))% quality"
+            )
+            CLIOut.out("Video: \(targetMegabytes) MB, audio \(keepAudio ? "kept" : "removed")")
+        }
+    }
+}
+
+enum MediaCLI {
+    static func url(_ path: String) -> URL {
+        let expanded = (path as NSString).expandingTildeInPath
+        if expanded.hasPrefix("/") {
+            return URL(fileURLWithPath: expanded).standardizedFileURL
+        }
+        return URL(fileURLWithPath: FileManager.default.currentDirectoryPath)
+            .appendingPathComponent(expanded).standardizedFileURL
+    }
+
+    static func input(_ path: String) throws -> URL {
+        let url = url(path)
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            throw CLIFailure.notFound("no file at \(url.path)")
+        }
+        return url
+    }
+
+    static func format(_ value: String) throws -> MediaImageFormat {
+        guard let format = MediaImageFormat(rawValue: value.lowercased()) else {
+            throw CLIFailure.usage(
+                "--format must be "
+                    + MediaImageFormat.allCases.map(\.rawValue)
+                    .joined(separator: ", "))
+        }
+        return format
+    }
+
+    static func failure(_ error: Error) -> CLIFailure {
+        if error is CancellationError { return .unavailable("media processing was cancelled") }
+        if let error = error as? MediaToolkitError {
+            return .unavailable(error.localizedDescription)
+        }
+        return CLIFailure(error.localizedDescription)
+    }
+
+    static func bytes(_ value: Int64) -> String {
+        ByteCountFormatter.string(fromByteCount: value, countStyle: .file)
+    }
+}
+
+struct MediaConvertImagesCommand: AsyncParsableCommand {
+    static let configuration = CommandConfiguration(
+        commandName: "convert-images",
+        abstract: "Convert and resize one or more images.")
+
+    @Argument(help: "Input image paths.")
+    var inputs: [String] = []
+
+    @Option(name: .customLong("to"), help: "Output directory.")
+    var outputDirectory: String
+
+    @Option(help: "Output format: jpeg, png or heic.")
+    var format = MediaImageFormat.jpeg.rawValue
+
+    @Option(help: "Lossy quality from 0.1 to 1.")
+    var quality = 0.82
+
+    @Option(help: "Largest output edge in pixels; 0 keeps the original size.")
+    var maxDimension = 1600
+
+    @Flag(name: .long, help: "Emit JSON on stdout.")
+    var json = false
+
+    func run() async throws {
+        try await execute {
+            guard !inputs.isEmpty else {
+                throw CLIFailure.usage("name at least one input image")
+            }
+            guard (0.1...1).contains(quality) else {
+                throw CLIFailure.usage("--quality must be between 0.1 and 1")
+            }
+            let maxDimension = try ArgumentChecks.nonNegative(
+                self.maxDimension, "--max-dimension")
+            guard maxDimension <= 20_000 else {
+                throw CLIFailure.usage("--max-dimension must be 20000 or less")
+            }
+            let format = try MediaCLI.format(format)
+            let inputURLs = try inputs.map(MediaCLI.input)
+            let outputURL = MediaCLI.url(outputDirectory)
+            let options = MediaImageOptions(
+                format: format, quality: quality,
+                maxDimension: maxDimension == 0 ? nil : maxDimension)
+            let results: [MediaImageResult]
+            do {
+                results = try await AgentMediaClient.convertImages(
+                    inputURLs, to: outputURL, options: options)
+            } catch {
+                throw MediaCLI.failure(error)
+            }
+            let succeeded = results.filter { $0.outputURL != nil }.count
+            guard !json else {
+                CLIOut.json(
+                    .object([
+                        "operation": .string(
+                            MediaToolkitOperation.convertImages.descriptor.id.rawValue),
+                        "outputDirectory": .string(outputURL.path),
+                        "succeeded": .int(succeeded),
+                        "failed": .int(results.count - succeeded),
+                        "results": .array(results.map(Self.json)),
+                    ]))
+                return
+            }
+            for result in results {
+                if let outputURL = result.outputURL {
+                    CLIOut.out(outputURL.path)
+                } else {
+                    CLIOut.note(
+                        "\(result.inputURL.lastPathComponent): \(result.error ?? "failed")")
+                }
+            }
+            CLIOut.note("converted \(succeeded) of \(results.count) images")
+        }
+    }
+
+    static func json(_ result: MediaImageResult) -> JSONValue {
+        .object([
+            "input": .string(result.inputURL.path),
+            "output": result.outputURL.map { .string($0.path) } ?? .null,
+            "inputBytes": .number(result.inputBytes),
+            "outputBytes": .number(result.outputBytes),
+            "error": result.error.map(JSONValue.string) ?? .null,
+        ])
+    }
+}
+
+struct MediaCompressVideoCommand: AsyncParsableCommand {
+    static let configuration = CommandConfiguration(
+        commandName: "compress-video",
+        abstract: "Compress a complete video under a size limit.")
+
+    @Argument(help: "Input video path.")
+    var input: String
+
+    @Option(name: .customLong("to"), help: "Output directory.")
+    var outputDirectory: String
+
+    @Option(help: "Maximum output size in decimal megabytes.")
+    var targetMB = 20
+
+    @Flag(help: "Remove audio from the compressed copy.")
+    var noAudio = false
+
+    @Flag(name: .long, help: "Emit JSON on stdout.")
+    var json = false
+
+    func run() async throws {
+        try await execute {
+            guard (1...512).contains(targetMB) else {
+                throw CLIFailure.usage("--target-mb must be between 1 and 512")
+            }
+            let inputURL = try MediaCLI.input(input)
+            let outputURL = MediaCLI.url(outputDirectory)
+            let options = MediaVideoOptions(
+                targetMegabytes: targetMB, keepAudio: !noAudio)
+            let result: MediaVideoResult
+            do {
+                result = try await AgentMediaClient.compressVideo(
+                    inputURL, to: outputURL, options: options)
+            } catch {
+                throw MediaCLI.failure(error)
+            }
+            guard !json else {
+                CLIOut.json(
+                    .object([
+                        "operation": .string(
+                            MediaToolkitOperation.compressVideo.descriptor.id.rawValue),
+                        "input": .string(result.inputURL.path),
+                        "output": .string(result.outputURL.path),
+                        "inputBytes": .number(result.inputBytes),
+                        "outputBytes": .number(result.outputBytes),
+                        "targetBytes": .number(result.targetBytes),
+                        "audio": .bool(options.keepAudio),
+                    ]))
+                return
+            }
+            CLIOut.out(result.outputURL.path)
+            CLIOut.note(
+                "compressed \(MediaCLI.bytes(result.inputBytes)) to \(MediaCLI.bytes(result.outputBytes))"
+            )
+        }
+    }
+}
diff --git a/Packages/Edith/Sources/EdithCLI/Commands/Root.swift b/Packages/Edith/Sources/EdithCLI/Commands/Root.swift
index 25cb942d7..9bdcd5a7f 100644
--- a/Packages/Edith/Sources/EdithCLI/Commands/Root.swift
+++ b/Packages/Edith/Sources/EdithCLI/Commands/Root.swift
@@ -66,6 +66,7 @@ public struct EdRoot: AsyncParsableCommand {
             AppsCommand.self,
             ToolsCommand.self,
             ColorCommand.self,
+            MediaCommand.self,
             EmojiCommand.self,
             ShelfCommand.self,
             CleanerCommand.self,
diff --git a/Packages/Edith/Sources/EdithCLI/Guide.swift b/Packages/Edith/Sources/EdithCLI/Guide.swift
index 1eeda5995..a3a648cd6 100644
--- a/Packages/Edith/Sources/EdithCLI/Guide.swift
+++ b/Packages/Edith/Sources/EdithCLI/Guide.swift
@@ -410,6 +410,9 @@ public enum Guide {
         ed system stats                 one sample of this Mac
         ed system stats --follow        keep sampling
         ed system disks
+        ed media status                 local media defaults and supported formats
+        ed media convert-images <images> --to <folder> --format jpeg
+        ed media compress-video <video> --to <folder> --target-mb 20
         ed music status                 whatever is playing, on whichever player
         ed music play|pause|stop|toggle|next|previous
         ed music volume 0.4
diff --git a/Packages/Edith/Sources/EdithCore/ExtensionLifecycle.swift b/Packages/Edith/Sources/EdithCore/ExtensionLifecycle.swift
index 31959a06b..7bc670401 100644
--- a/Packages/Edith/Sources/EdithCore/ExtensionLifecycle.swift
+++ b/Packages/Edith/Sources/EdithCore/ExtensionLifecycle.swift
@@ -706,6 +706,39 @@ public enum ExtensionLifecycleCatalog {
                     "players", "Check playback", "Confirm Edith sees the player and library.",
                     "ed music players --json")
             ]),
+        descriptor(
+            "mediaToolkit", "Convert and resize images or compress videos without uploading them.",
+            workflows: [
+                instruction(
+                    "images", "Convert images",
+                    "Process one or many images into JPEG, PNG or HEIC with optional resizing."),
+                instruction(
+                    "video", "Compress a video",
+                    "Encode a complete H.264 copy under a chosen file-size limit."),
+            ],
+            prerequisites: [
+                instruction(
+                    "files", "Choose local files",
+                    "Use image or video files that macOS can decode.")
+            ],
+            examples: [
+                "ed extensions enable mediaToolkit",
+                "ed media convert-images ~/Pictures/input.png --to ~/Pictures/Converted --json",
+                "ed media compress-video ~/Movies/input.mov --to ~/Movies --target-mb 20 --json",
+            ],
+            docs: [documentation("guide", "Media Toolkit guide", "docs/cli/media/README.md")],
+            recovery: [
+                instruction(
+                    "doctor", "Check Media Toolkit readiness",
+                    "Confirm local encoders and processing defaults are available.",
+                    "ed extensions doctor mediaToolkit --json")
+            ],
+            verification: [
+                instruction(
+                    "settings", "Inspect media defaults",
+                    "Confirm the extension and processing defaults are available.",
+                    "ed config ls --group media --json")
+            ]),
         descriptor(
             "calendar", "See upcoming events beside the work they shape.",
             workflows: [
diff --git a/Packages/Edith/Sources/EdithCore/ExtensionRegistry.swift b/Packages/Edith/Sources/EdithCore/ExtensionRegistry.swift
index 68692cdb6..dc36148b4 100644
--- a/Packages/Edith/Sources/EdithCore/ExtensionRegistry.swift
+++ b/Packages/Edith/Sources/EdithCore/ExtensionRegistry.swift
@@ -191,6 +191,12 @@ public enum ExtensionRegistry {
             symbolName: "mic.slash.fill", suite: .system, host: .bar, featured: false,
             defaultsKey: "micMuteEnabled", requiredCapabilities: [.microphoneControl],
             optionalCapabilities: [.globalShortcuts]),
+        ExtensionRegistryEntry(
+            id: "mediaToolkit", title: "Media Toolkit",
+            subtitle: "Batch-convert images and compress videos locally.",
+            symbolName: "photo.stack", suite: .media, host: .agent, featured: true,
+            defaultsKey: "tabMediaToolkitEnabled",
+            requiredCapabilities: [.localMediaProcessing]),
         ExtensionRegistryEntry(
             id: "clipboard", title: "Clipboard",
             subtitle: "Clipboard history with instant paste.",
diff --git a/Packages/Edith/Sources/EdithCore/PlatformCapabilities.swift b/Packages/Edith/Sources/EdithCore/PlatformCapabilities.swift
index 687a45727..e288113d0 100644
--- a/Packages/Edith/Sources/EdithCore/PlatformCapabilities.swift
+++ b/Packages/Edith/Sources/EdithCore/PlatformCapabilities.swift
@@ -18,6 +18,7 @@ public enum PlatformCapability: String, CaseIterable, Codable, Hashable, Sendabl
     case inputSuppression
     case keystrokeObservation
     case localMusicPlayback
+    case localMediaProcessing
     case localTerminal
     case machineManagement
     case mediaControls
diff --git a/Packages/Edith/Sources/EdithKit/Core/Backup/SettingsBackup.swift b/Packages/Edith/Sources/EdithKit/Core/Backup/SettingsBackup.swift
index c0b0e423a..791e4c529 100644
--- a/Packages/Edith/Sources/EdithKit/Core/Backup/SettingsBackup.swift
+++ b/Packages/Edith/Sources/EdithKit/Core/Backup/SettingsBackup.swift
@@ -719,7 +719,10 @@ final class SettingsBackup {
         AppStorageKeys.Presenter.detectScreenSharing, AppStorageKeys.Presenter.detectMirroring,
         "presenterHotKeyCode", "presenterHotKeyMods", "presenterHotKeyLabel",
         AppStorageKeys.Tabs.attentionEnabled, AppStorageKeys.Tabs.usageEnabled,
-        AppStorageKeys.Tabs.musicEnabled, "usageMachines",
+        AppStorageKeys.Tabs.musicEnabled, AppStorageKeys.Tabs.mediaToolkitEnabled,
+        AppStorageKeys.MediaToolkit.imageFormat, AppStorageKeys.MediaToolkit.imageMaxDimension,
+        AppStorageKeys.MediaToolkit.imageQuality, AppStorageKeys.MediaToolkit.videoKeepAudio,
+        AppStorageKeys.MediaToolkit.videoTargetMegabytes, "usageMachines",
         AppStorageKeys.Tabs.herdrEnabled, AppStorageKeys.Tabs.quinjetEnabled,
         AppStorageKeys.Tabs.seoAuditEnabled,
         AppStorageKeys.Homebrew.defaultKind,
@@ -845,7 +848,10 @@ final class SettingsBackup {
         AppStorageKeys.Presenter.detectScreenSharing, AppStorageKeys.Presenter.detectMirroring,
         "presenterHotKeyCode", "presenterHotKeyMods", "presenterHotKeyLabel",
         AppStorageKeys.Tabs.attentionEnabled, AppStorageKeys.Tabs.usageEnabled,
-        AppStorageKeys.Tabs.musicEnabled,
+        AppStorageKeys.Tabs.musicEnabled, AppStorageKeys.Tabs.mediaToolkitEnabled,
+        AppStorageKeys.MediaToolkit.imageFormat, AppStorageKeys.MediaToolkit.imageMaxDimension,
+        AppStorageKeys.MediaToolkit.imageQuality, AppStorageKeys.MediaToolkit.videoKeepAudio,
+        AppStorageKeys.MediaToolkit.videoTargetMegabytes,
         AppStorageKeys.Tabs.herdrEnabled, AppStorageKeys.Tabs.quinjetEnabled,
         AppStorageKeys.Tabs.seoAuditEnabled,
         AppStorageKeys.Homebrew.defaultKind,
diff --git a/Packages/Edith/Sources/EdithKit/Core/Defaults/AppStorageKeys.swift b/Packages/Edith/Sources/EdithKit/Core/Defaults/AppStorageKeys.swift
index 8a6aeed1c..c05d11757 100644
--- a/Packages/Edith/Sources/EdithKit/Core/Defaults/AppStorageKeys.swift
+++ b/Packages/Edith/Sources/EdithKit/Core/Defaults/AppStorageKeys.swift
@@ -217,6 +217,14 @@ public enum AppStorageKeys {
         public static let shuffling = "musicShuffling"
     }
 
+    public enum MediaToolkit {
+        public static let imageFormat = "mediaToolkitImageFormat"
+        public static let imageMaxDimension = "mediaToolkitImageMaxDimension"
+        public static let imageQuality = "mediaToolkitImageQuality"
+        public static let videoKeepAudio = "mediaToolkitVideoKeepAudio"
+        public static let videoTargetMegabytes = "mediaToolkitVideoTargetMegabytes"
+    }
+
     public enum Notch {
         public static let alertAudio = "notchAlertAudio"
         public static let alertBattery = "notchAlertBattery"
@@ -289,6 +297,7 @@ public enum AppStorageKeys {
         public static let pluginsEnabled = "tabPluginsEnabled"
         public static let databaseEnabled = "tabDatabaseEnabled"
         public static let herdrEnabled = "tabHerdrEnabled"
+        public static let mediaToolkitEnabled = "tabMediaToolkitEnabled"
         public static let musicEnabled = "tabMusicEnabled"
         public static let order = "tabOrder"
         public static let quinjetEnabled = "tabQuinjetEnabled"
diff --git a/Packages/Edith/Sources/EdithKit/Core/Defaults/SharedDefaults.swift b/Packages/Edith/Sources/EdithKit/Core/Defaults/SharedDefaults.swift
index dfc227ed7..9fcb070f5 100644
--- a/Packages/Edith/Sources/EdithKit/Core/Defaults/SharedDefaults.swift
+++ b/Packages/Edith/Sources/EdithKit/Core/Defaults/SharedDefaults.swift
@@ -11,6 +11,11 @@ public enum SharedDefaults {
         CompletionScripts.autoRefreshKey: true,
         MusicFade.enabledKey: true,
         MusicFade.secondsKey: MusicFade.defaultSeconds,
+        AppStorageKeys.MediaToolkit.imageFormat: MediaImageFormat.jpeg.rawValue,
+        AppStorageKeys.MediaToolkit.imageMaxDimension: 1600,
+        AppStorageKeys.MediaToolkit.imageQuality: 0.82,
+        AppStorageKeys.MediaToolkit.videoKeepAudio: true,
+        AppStorageKeys.MediaToolkit.videoTargetMegabytes: 20,
     ]
     public static let store: UserDefaults = {
         let store = UserDefaults(suiteName: activeSuiteName) ?? .standard
diff --git a/Packages/Edith/Sources/EdithKit/Core/Operations/ConfigCatalog.swift b/Packages/Edith/Sources/EdithKit/Core/Operations/ConfigCatalog.swift
index 15970623b..bdadfafb6 100644
--- a/Packages/Edith/Sources/EdithKit/Core/Operations/ConfigCatalog.swift
+++ b/Packages/Edith/Sources/EdithKit/Core/Operations/ConfigCatalog.swift
@@ -50,7 +50,7 @@ public enum ConfigCatalog {
         "budget",
         "dashboard", "database",
         "machines", "herdr", "quinjet", "companion", "finder", "system", "homebrew", "cleaner",
-        "music",
+        "music", "media",
         "calendar",
         "clipboard", "keystrokes",
         "notch", "focusdim", "presenter", "colorpicker", "emoji", "micmute",
@@ -61,7 +61,7 @@ public enum ConfigCatalog {
         agent + suites + appearance + panel + attention + usageAndLimits
         + menuBar + alerts + budget + dashboard + database + machines + herdr + quinjet + companion
         + finder + system + homebrew + cleaner
-        + music + calendar + clipboard + keystrokeHighlight + notch + focusDim + presenter
+        + music + media + calendar + clipboard + keystrokeHighlight + notch + focusDim + presenter
         + colorPicker + emoji
         + micMute
         + backup + permissions + terminal
@@ -662,6 +662,32 @@ public enum ConfigCatalog {
             fallback: .bool(false))
     ]
 
+    private static let media: [SettingDefinition] = [
+        SettingDefinition(
+            AppStorageKeys.Tabs.mediaToolkitEnabled, .bool, group: "media",
+            summary: "Media Toolkit extension: local image conversion and video compression.",
+            fallback: .bool(false)),
+        SettingDefinition(
+            AppStorageKeys.MediaToolkit.imageFormat, .string, group: "media",
+            summary: "Default image output format.",
+            allowed: MediaImageFormat.allCases.map(\.rawValue),
+            fallback: .string(MediaImageFormat.jpeg.rawValue)),
+        SettingDefinition(
+            AppStorageKeys.MediaToolkit.imageMaxDimension, .int, group: "media",
+            summary: "Largest image edge in pixels; 0 keeps the original size.",
+            integerRange: 0...20_000, fallback: .int(1600)),
+        SettingDefinition(
+            AppStorageKeys.MediaToolkit.imageQuality, .number, group: "media",
+            summary: "Lossy image quality from 0.1 to 1.", fallback: .double(0.82)),
+        SettingDefinition(
+            AppStorageKeys.MediaToolkit.videoKeepAudio, .bool, group: "media",
+            summary: "Keep the audio track when compressing video.", fallback: .bool(true)),
+        SettingDefinition(
+            AppStorageKeys.MediaToolkit.videoTargetMegabytes, .int, group: "media",
+            summary: "Maximum compressed video size in decimal megabytes.",
+            integerRange: 1...512, fallback: .int(20)),
+    ]
+
     private static let clipboard: [SettingDefinition] = [
         SettingDefinition(
             AppStorageKeys.Clipboard.enabled, .bool, group: "clipboard",
diff --git a/Packages/Edith/Sources/EdithKit/Core/Operations/UserOperationCatalog.swift b/Packages/Edith/Sources/EdithKit/Core/Operations/UserOperationCatalog.swift
index 2a943a4a3..16a1d0415 100644
--- a/Packages/Edith/Sources/EdithKit/Core/Operations/UserOperationCatalog.swift
+++ b/Packages/Edith/Sources/EdithKit/Core/Operations/UserOperationCatalog.swift
@@ -104,55 +104,60 @@ public enum UserOperationCatalog {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
 
-    private static let featureRegistrations: [RegisteredUserOperation] =
-        UsageProjectOperation.allCases.map {
+    private static let featureRegistrations: [RegisteredUserOperation] = {
+        var registrations = UsageProjectOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + ConfigurationOperation.allCases.map {
+        registrations += ConfigurationOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + TerminalToolingOperation.allCases.map {
+        registrations += TerminalToolingOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + PermissionOperation.allCases.map {
+        registrations += PermissionOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + RunningAppOperation.allCases.map {
+        registrations += RunningAppOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + ColorPickerOperation.allCases.map {
+        registrations += ColorPickerOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + ColorSwatchOperation.allCases.map {
+        registrations += ColorSwatchOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + EmojiOperation.allCases.map {
+        registrations += EmojiOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + CompanionSettingsOperation.allCases.map {
+        registrations += CompanionSettingsOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + ClipboardOperation.allCases.map {
+        registrations += ClipboardOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + AttentionFocusOperation.allCases.map {
+        registrations += AttentionFocusOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + CleanerOperation.allCases.map {
+        registrations += CleanerOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + HomebrewOperation.allCases.map {
+        registrations += HomebrewOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + AppMaintenanceOperation.allCases.map {
+        registrations += AppMaintenanceOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + DatabaseConnectionOperation.allCases.map {
+        registrations += DatabaseConnectionOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
-        + WorkspaceOperation.allCases.map {
+        registrations += WorkspaceOperation.allCases.map {
             RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
         }
+        registrations += MediaToolkitOperation.allCases.map {
+            RegisteredUserOperation(descriptor: $0.descriptor, exposure: $0.interfaceExposure)
+        }
+        return registrations
+    }()
 
     private static let agentRegistrations: [RegisteredUserOperation] =
         AgentControlOperation.allCases.map {
@@ -1495,3 +1500,18 @@ private extension CompanionMindRuntimeOperation {
         .userInterface(placements)
     }
 }
+
+private extension MediaToolkitOperation {
+    var interfaceExposure: UserOperationExposure {
+        switch self {
+        case .convertImages:
+            userInterface(
+                "Media Toolkit", "convert selected images",
+                ["~/Pictures/input.png", "--to", "~/Pictures/Converted"])
+        case .compressVideo:
+            userInterface(
+                "Media Toolkit", "compress the selected video",
+                ["~/Movies/input.mov", "--to", "~/Movies", "--target-mb", "20"])
+        }
+    }
+}
diff --git a/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionLifecycleProbe.swift b/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionLifecycleProbe.swift
index 8bb0f668c..30a12afff 100644
--- a/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionLifecycleProbe.swift
+++ b/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionLifecycleProbe.swift
@@ -206,6 +206,8 @@ public struct ExtensionLifecycleProbe: Sendable {
             requiresHelper: true, requiresMachine: false, toolRule: .all, adapter: true),
         "music": Policy(
             requiresHelper: true, requiresMachine: false, toolRule: .all, adapter: true),
+        "mediaToolkit": Policy(
+            requiresHelper: false, requiresMachine: false, toolRule: .all, adapter: true),
         "calendar": Policy(
             requiresHelper: true, requiresMachine: false, toolRule: .all, adapter: true),
         "notchShelf": Policy(
diff --git a/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionLiveAdapters.swift b/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionLiveAdapters.swift
index cec0e0b1a..7454d1b9a 100644
--- a/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionLiveAdapters.swift
+++ b/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionLiveAdapters.swift
@@ -67,7 +67,8 @@ public enum ExtensionLiveAdapters {
     public static let extensionIDs = [
         "usage", "quinjet", "plugins", "appMaintenance", "homebrew", "cleaner", "system",
         "keepAwake", "lidAwake",
-        "systemStats", "micMute", "clipboard", "emoji", "colorPicker", "keystrokeHighlight",
+        "systemStats", "micMute", "mediaToolkit", "clipboard", "emoji", "colorPicker",
+        "keystrokeHighlight",
         "focusDim", "presenter", "music", "downloads", "notchShelf", "audioMixer", "calendar",
         "attention", "seoAudit",
     ]
@@ -114,6 +115,7 @@ public enum ExtensionLiveAdapters {
         case "micMute": microphoneReadiness()
         case "lidAwake": lidAwakeReadiness()
         case "music": musicReadiness()
+        case "mediaToolkit": mediaToolkitReadiness(defaults: defaults)
         case "calendar": calendarReadiness()
         case "notchShelf": shelfReadiness()
         case "clipboard": await clipboardReadiness()
@@ -139,6 +141,31 @@ public enum ExtensionLiveAdapters {
         ).readiness
     }
 
+    static func mediaToolkitReadiness(defaults: UserDefaults) -> ExtensionAdapterReadiness {
+        let format =
+            defaults.string(forKey: AppStorageKeys.MediaToolkit.imageFormat)
+            ?? MediaImageFormat.jpeg.rawValue
+        let maxDimension =
+            defaults.object(forKey: AppStorageKeys.MediaToolkit.imageMaxDimension)
+            as? Int ?? 1600
+        let quality =
+            defaults.object(forKey: AppStorageKeys.MediaToolkit.imageQuality)
+            as? Double ?? 0.82
+        let target =
+            defaults.object(forKey: AppStorageKeys.MediaToolkit.videoTargetMegabytes)
+            as? Int ?? 20
+        let configured =
+            MediaImageFormat(rawValue: format) != nil
+            && (0...20_000).contains(maxDimension)
+            && (0.1...1).contains(quality)
+            && (1...512).contains(target)
+        return ExtensionAdapterFacts(
+            configured: configured,
+            readyDetail: "ImageIO and AVFoundation processing defaults are ready.",
+            setupDetail: "Reset the stored Media Toolkit format, quality, dimensions or size limit."
+        ).readiness
+    }
+
     static func siteAuditReadiness() -> ExtensionAdapterReadiness {
         .ready("Site Audit is ready to store projects and run history locally.")
     }
diff --git a/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionMutationCenter.swift b/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionMutationCenter.swift
index 924abbc58..61b665b4b 100644
--- a/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionMutationCenter.swift
+++ b/Packages/Edith/Sources/EdithKit/Features/Extensions/Services/ExtensionMutationCenter.swift
@@ -88,6 +88,7 @@ public enum ExtensionDetailRoute: String, CaseIterable, Sendable {
     case micMute
     case lidAwake
     case music
+    case mediaToolkit
     case downloads
     case calendar
     case notchShelf
diff --git a/Packages/Edith/Sources/EdithKit/Features/MediaToolkit/Services/AgentMediaClient.swift b/Packages/Edith/Sources/EdithKit/Features/MediaToolkit/Services/AgentMediaClient.swift
new file mode 100644
index 000000000..9e8056edb
--- /dev/null
+++ b/Packages/Edith/Sources/EdithKit/Features/MediaToolkit/Services/AgentMediaClient.swift
@@ -0,0 +1,47 @@
+import Foundation
+
+public struct MediaImageTaskRequest: Codable, Sendable {
+    public let inputs: [URL]
+    public let destination: URL
+    public let options: MediaImageOptions
+}
+
+public struct MediaVideoTaskRequest: Codable, Sendable {
+    public let input: URL
+    public let destination: URL
+    public let options: MediaVideoOptions
+}
+
+public enum AgentMediaClient {
+    public static func convertImages(
+        _ inputs: [URL], to destination: URL, options: MediaImageOptions,
+        progress: @escaping @Sendable (Int, Int) -> Void = { _, _ in }
+    ) async throws -> [MediaImageResult] {
+        let request = MediaImageTaskRequest(
+            inputs: inputs, destination: destination, options: options)
+        let submission = AgentTaskSubmission(
+            operation: MediaToolkitOperation.convertImages.descriptor.id.rawValue,
+            title: "Convert images", payload: try AgentPayload.encode(request))
+        let data = try await AgentTaskClient().run(submission) { output in
+            guard let completed = Int(output.text) else { return }
+            progress(completed, inputs.count)
+        }
+        return try AgentPayload.decode([MediaImageResult].self, from: data)
+    }
+
+    public static func compressVideo(
+        _ input: URL, to destination: URL, options: MediaVideoOptions,
+        progress: @escaping @Sendable (Double) -> Void = { _ in }
+    ) async throws -> MediaVideoResult {
+        let request = MediaVideoTaskRequest(
+            input: input, destination: destination, options: options)
+        let submission = AgentTaskSubmission(
+            operation: MediaToolkitOperation.compressVideo.descriptor.id.rawValue,
+            title: "Compress video", payload: try AgentPayload.encode(request))
+        let data = try await AgentTaskClient().run(submission) { output in
+            guard let value = Double(output.text) else { return }
+            progress(value)
+        }
+        return try AgentPayload.decode(MediaVideoResult.self, from: data)
+    }
+}
diff --git a/Packages/Edith/Sources/EdithKit/Features/MediaToolkit/Services/MediaToolkit.swift b/Packages/Edith/Sources/EdithKit/Features/MediaToolkit/Services/MediaToolkit.swift
new file mode 100644
index 000000000..281b688b1
--- /dev/null
+++ b/Packages/Edith/Sources/EdithKit/Features/MediaToolkit/Services/MediaToolkit.swift
@@ -0,0 +1,449 @@
+import AVFoundation
+import CoreGraphics
+import EdithCore
+import Foundation
+import ImageIO
+import UniformTypeIdentifiers
+
+public enum MediaImageFormat: String, CaseIterable, Codable, Identifiable, Sendable {
+    case jpeg
+    case png
+    case heic
+
+    public var id: String { rawValue }
+
+    public var fileExtension: String {
+        switch self {
+        case .jpeg: "jpg"
+        case .png: "png"
+        case .heic: "heic"
+        }
+    }
+
+    var type: UTType {
+        switch self {
+        case .jpeg: .jpeg
+        case .png: .png
+        case .heic: .heic
+        }
+    }
+}
+
+public struct MediaImageOptions: Codable, Equatable, Sendable {
+    public var format: MediaImageFormat
+    public var quality: Double
+    public var maxDimension: Int?
+
+    public init(format: MediaImageFormat, quality: Double = 0.82, maxDimension: Int? = 1600) {
+        self.format = format
+        self.quality = min(1, max(0.1, quality.isFinite ? quality : 0.82))
+        self.maxDimension = maxDimension.map { min(20_000, max(1, $0)) }
+    }
+}
+
+public struct MediaImageResult: Codable, Equatable, Sendable {
+    public let inputURL: URL
+    public let outputURL: URL?
+    public let inputBytes: Int64
+    public let outputBytes: Int64
+    public let error: String?
+
+    public init(
+        inputURL: URL, outputURL: URL?, inputBytes: Int64, outputBytes: Int64,
+        error: String?
+    ) {
+        self.inputURL = inputURL
+        self.outputURL = outputURL
+        self.inputBytes = inputBytes
+        self.outputBytes = outputBytes
+        self.error = error
+    }
+}
+
+public struct MediaVideoOptions: Codable, Equatable, Sendable {
+    public var targetMegabytes: Int
+    public var keepAudio: Bool
+
+    public init(targetMegabytes: Int = 20, keepAudio: Bool = true) {
+        self.targetMegabytes = min(512, max(1, targetMegabytes))
+        self.keepAudio = keepAudio
+    }
+
+    public var targetBytes: Int64 { Int64(targetMegabytes) * 1_000_000 }
+}
+
+public struct MediaVideoPlan: Equatable, Sendable {
+    public let width: Int
+    public let height: Int
+    public let videoBitRate: Int
+    public let audioBitRate: Int
+
+    public init(width: Int, height: Int, videoBitRate: Int, audioBitRate: Int) {
+        self.width = width
+        self.height = height
+        self.videoBitRate = videoBitRate
+        self.audioBitRate = audioBitRate
+    }
+}
+
+public struct MediaVideoResult: Codable, Equatable, Sendable {
+    public let inputURL: URL
+    public let outputURL: URL
+    public let inputBytes: Int64
+    public let outputBytes: Int64
+    public let targetBytes: Int64
+
+    public init(
+        inputURL: URL, outputURL: URL, inputBytes: Int64, outputBytes: Int64,
+        targetBytes: Int64
+    ) {
+        self.inputURL = inputURL
+        self.outputURL = outputURL
+        self.inputBytes = inputBytes
+        self.outputBytes = outputBytes
+        self.targetBytes = targetBytes
+    }
+}
+
+public enum MediaToolkitError: LocalizedError, Equatable {
+    case noInput
+    case unsupportedImage(String)
+    case unsupportedVideo
+    case invalidOutput
+    case targetTooSmall
+    case failed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .noInput: "Choose at least one input file."
+        case let .unsupportedImage(name): "\(name) is not a supported image."
+        case .unsupportedVideo: "The selected file does not contain a supported video track."
+        case .invalidOutput: "The output location is not writable."
+        case .targetTooSmall: "The target size is too small for the complete video."
+        case let .failed(message): message
+        }
+    }
+}
+
+public enum MediaToolkitOperation: String, CaseIterable, Sendable {
+    case convertImages = "convert-images"
+    case compressVideo = "compress-video"
+
+    public var descriptor: UserOperationDescriptor {
+        switch self {
+        case .convertImages:
+            UserOperationDescriptor(
+                id: UserOperationID(rawValue: "media.convert-images"),
+                summary: "Convert and resize local images in a batch.",
+                cli: ["media", rawValue], effect: .write)
+        case .compressVideo:
+            UserOperationDescriptor(
+                id: UserOperationID(rawValue: "media.compress-video"),
+                summary: "Compress a local video under a chosen size limit.",
+                cli: ["media", rawValue], effect: .write)
+        }
+    }
+}
+
+public enum MediaToolkit {
+    public static func convertImages(
+        _ inputURLs: [URL], to outputDirectory: URL, options: MediaImageOptions,
+        progress: @Sendable (Int, Int) -> Void = { _, _ in },
+        cancelled: @Sendable () -> Bool = { false }
+    ) throws -> [MediaImageResult] {
+        guard !inputURLs.isEmpty else { throw MediaToolkitError.noInput }
+        try FileManager.default.createDirectory(
+            at: outputDirectory, withIntermediateDirectories: true)
+        var results: [MediaImageResult] = []
+        for (index, inputURL) in inputURLs.enumerated() {
+            if cancelled() { throw CancellationError() }
+            let inputBytes = fileSize(inputURL)
+            do {
+                let outputURL = uniqueOutputURL(
+                    input: inputURL, directory: outputDirectory,
+                    extension: options.format.fileExtension)
+                try convertImage(inputURL, to: outputURL, options: options, cancelled: cancelled)
+                results.append(
+                    MediaImageResult(
+                        inputURL: inputURL, outputURL: outputURL, inputBytes: inputBytes,
+                        outputBytes: fileSize(outputURL), error: nil))
+            } catch is CancellationError {
+                throw CancellationError()
+            } catch {
+                results.append(
+                    MediaImageResult(
+                        inputURL: inputURL, outputURL: nil, inputBytes: inputBytes,
+                        outputBytes: 0, error: error.localizedDescription))
+            }
+            progress(index + 1, inputURLs.count)
+        }
+        return results
+    }
+
+    public static func compressVideo(
+        _ inputURL: URL, to outputDirectory: URL, options: MediaVideoOptions,
+        progress: @Sendable (Double) -> Void = { _ in },
+        cancelled: @Sendable () -> Bool = { false }
+    ) async throws -> MediaVideoResult {
+        try FileManager.default.createDirectory(
+            at: outputDirectory, withIntermediateDirectories: true)
+        let asset = AVURLAsset(url: inputURL)
+        guard let videoTrack = try await asset.loadTracks(withMediaType: .video).first else {
+            throw MediaToolkitError.unsupportedVideo
+        }
+        let duration = try await asset.load(.duration).seconds
+        guard duration.isFinite, duration > 0 else { throw MediaToolkitError.unsupportedVideo }
+        let audioTracks =
+            options.keepAudio ? try await asset.loadTracks(withMediaType: .audio) : []
+        let naturalSize = try await videoTrack.load(.naturalSize)
+        let preferredTransform = try await videoTrack.load(.preferredTransform)
+        let nominalFrameRate = try await videoTrack.load(.nominalFrameRate)
+        let transformed = naturalSize.applying(preferredTransform)
+        let sourceSize = CGSize(width: abs(transformed.width), height: abs(transformed.height))
+        let frameRate = max(1, Double(nominalFrameRate))
+        let outputURL = uniqueOutputURL(
+            input: inputURL, directory: outputDirectory, extension: "mp4")
+        var scale = 1.0
+        var outputBytes: Int64 = 0
+        do {
+            for pass in 0..<3 {
+                guard !cancelled() else { throw CancellationError() }
+                guard
+                    let plan = videoPlan(
+                        targetBytes: options.targetBytes, duration: duration,
+                        sourceSize: sourceSize,
+                        frameRate: frameRate, hasAudio: !audioTracks.isEmpty, scale: scale)
+                else { throw MediaToolkitError.targetTooSmall }
+                try encodeVideo(
+                    asset: asset, videoTrack: videoTrack, audioTracks: audioTracks,
+                    preferredTransform: preferredTransform, frameRate: frameRate,
+                    duration: duration, plan: plan, outputURL: outputURL,
+                    progress: progress, cancelled: cancelled)
+                outputBytes = fileSize(outputURL)
+                if outputBytes <= options.targetBytes { break }
+                guard pass < 2 else { throw MediaToolkitError.targetTooSmall }
+                scale *= min(
+                    0.9, Double(options.targetBytes) / Double(max(1, outputBytes)) * 0.9)
+            }
+        } catch {
+            try? FileManager.default.removeItem(at: outputURL)
+            throw error
+        }
+        return MediaVideoResult(
+            inputURL: inputURL, outputURL: outputURL, inputBytes: fileSize(inputURL),
+            outputBytes: outputBytes, targetBytes: options.targetBytes)
+    }
+
+    public static func videoPlan(
+        targetBytes: Int64, duration: Double, sourceSize: CGSize, frameRate: Double,
+        hasAudio: Bool, scale: Double = 1
+    ) -> MediaVideoPlan? {
+        guard targetBytes > 0, duration.isFinite, duration > 0,
+            sourceSize.width.isFinite, sourceSize.height.isFinite,
+            sourceSize.width > 0, sourceSize.height > 0, frameRate.isFinite, frameRate > 0,
+            scale.isFinite, scale > 0
+        else { return nil }
+        let audioBitRate = hasAudio ? 96_000 : 0
+        let totalBitRate = Int(Double(targetBytes * 8) * 0.9 / duration)
+        let videoBitRate = Int(Double(totalBitRate - audioBitRate) * scale)
+        guard videoBitRate >= 240_000 else { return nil }
+        let dimensionScale = min(1, 1920 / max(sourceSize.width, sourceSize.height))
+        let sourceWidth = even(Int((sourceSize.width * dimensionScale).rounded()))
+        let sourceHeight = even(Int((sourceSize.height * dimensionScale).rounded()))
+        let pixelBudget = Double(videoBitRate) / max(1, frameRate * 0.07)
+        let pixelScale = min(1, sqrt(pixelBudget / Double(sourceWidth * sourceHeight)))
+        let width = even(Int(Double(sourceWidth) * pixelScale))
+        let height = even(Int(Double(sourceHeight) * pixelScale))
+        return MediaVideoPlan(
+            width: width, height: height, videoBitRate: videoBitRate,
+            audioBitRate: audioBitRate)
+    }
+
+    private static func convertImage(
+        _ inputURL: URL, to outputURL: URL, options: MediaImageOptions,
+        cancelled: @Sendable () -> Bool
+    ) throws {
+        guard let source = CGImageSourceCreateWithURL(inputURL as CFURL, nil) else {
+            throw MediaToolkitError.unsupportedImage(inputURL.lastPathComponent)
+        }
+        let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any]
+        let sourceWidth = properties?[kCGImagePropertyPixelWidth] as? Int ?? 1
+        let sourceHeight = properties?[kCGImagePropertyPixelHeight] as? Int ?? 1
+        let maxPixelSize = min(
+            max(sourceWidth, sourceHeight), options.maxDimension ?? max(sourceWidth, sourceHeight))
+        let thumbnailOptions: [CFString: Any] = [
+            kCGImageSourceCreateThumbnailFromImageAlways: true,
+            kCGImageSourceCreateThumbnailWithTransform: true,
+            kCGImageSourceThumbnailMaxPixelSize: maxPixelSize,
+            kCGImageSourceShouldCacheImmediately: true,
+        ]
+        guard
+            let image = CGImageSourceCreateThumbnailAtIndex(
+                source, 0, thumbnailOptions as CFDictionary)
+        else { throw MediaToolkitError.unsupportedImage(inputURL.lastPathComponent) }
+        if cancelled() { throw CancellationError() }
+        let stagingURL = outputURL.deletingLastPathComponent()
+            .appendingPathComponent(".\(UUID().uuidString).tmp")
+        defer { try? FileManager.default.removeItem(at: stagingURL) }
+        guard
+            let destination = CGImageDestinationCreateWithURL(
+                stagingURL as CFURL, options.format.type.identifier as CFString, 1, nil)
+        else { throw MediaToolkitError.invalidOutput }
+        CGImageDestinationAddImage(
+            destination, image,
+            [kCGImageDestinationLossyCompressionQuality: options.quality] as CFDictionary)
+        guard CGImageDestinationFinalize(destination) else {
+            throw MediaToolkitError.failed("The image encoder could not finish the file.")
+        }
+        if cancelled() { throw CancellationError() }
+        try FileManager.default.moveItem(at: stagingURL, to: outputURL)
+    }
+
+    private static func encodeVideo(
+        asset: AVAsset, videoTrack: AVAssetTrack, audioTracks: [AVAssetTrack],
+        preferredTransform: CGAffineTransform, frameRate: Double, duration: Double,
+        plan: MediaVideoPlan, outputURL: URL,
+        progress: @Sendable (Double) -> Void, cancelled: @Sendable () -> Bool
+    ) throws {
+        try? FileManager.default.removeItem(at: outputURL)
+        guard let reader = try? AVAssetReader(asset: asset),
+            let writer = try? AVAssetWriter(outputURL: outputURL, fileType: .mp4)
+        else { throw MediaToolkitError.unsupportedVideo }
+        writer.shouldOptimizeForNetworkUse = true
+        let videoOutput = AVAssetReaderTrackOutput(
+            track: videoTrack,
+            outputSettings: [
+                kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA
+            ])
+        videoOutput.alwaysCopiesSampleData = false
+        guard reader.canAdd(videoOutput) else { throw MediaToolkitError.unsupportedVideo }
+        reader.add(videoOutput)
+        let videoSettings: [String: Any] = [
+            AVVideoCodecKey: AVVideoCodecType.h264,
+            AVVideoWidthKey: plan.width,
+            AVVideoHeightKey: plan.height,
+            AVVideoScalingModeKey: AVVideoScalingModeResizeAspect,
+            AVVideoCompressionPropertiesKey: [
+                AVVideoAverageBitRateKey: plan.videoBitRate,
+                AVVideoExpectedSourceFrameRateKey: max(1, Int(frameRate.rounded())),
+                AVVideoMaxKeyFrameIntervalDurationKey: 4,
+                AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
+            ],
+        ]
+        let videoInput = AVAssetWriterInput(mediaType: .video, outputSettings: videoSettings)
+        videoInput.expectsMediaDataInRealTime = false
+        videoInput.transform = preferredTransform
+        guard writer.canAdd(videoInput) else { throw MediaToolkitError.unsupportedVideo }
+        writer.add(videoInput)
+        var audioOutput: AVAssetReaderAudioMixOutput?
+        var audioInput: AVAssetWriterInput?
+        if !audioTracks.isEmpty {
+            let output = AVAssetReaderAudioMixOutput(
+                audioTracks: audioTracks,
+                audioSettings: [
+                    AVFormatIDKey: kAudioFormatLinearPCM,
+                    AVLinearPCMBitDepthKey: 32,
+                    AVLinearPCMIsFloatKey: true,
+                    AVLinearPCMIsNonInterleaved: false,
+                    AVLinearPCMIsBigEndianKey: false,
+                ])
+            if reader.canAdd(output) {
+                reader.add(output)
+                audioOutput = output
+                let input = AVAssetWriterInput(
+                    mediaType: .audio,
+                    outputSettings: [
+                        AVFormatIDKey: kAudioFormatMPEG4AAC,
+                        AVSampleRateKey: 48_000,
+                        AVNumberOfChannelsKey: 2,
+                        AVEncoderBitRateKey: plan.audioBitRate,
+                    ])
+                if writer.canAdd(input) {
+                    writer.add(input)
+                    audioInput = input
+                }
+            }
+        }
+        guard reader.startReading(), writer.startWriting() else {
+            throw MediaToolkitError.failed(
+                writer.error?.localizedDescription ?? "The video encoder could not start.")
+        }
+        writer.startSession(atSourceTime: .zero)
+        var nextVideo = videoOutput.copyNextSampleBuffer()
+        var nextAudio = audioOutput?.copyNextSampleBuffer()
+        while nextVideo != nil || nextAudio != nil {
+            if cancelled() {
+                reader.cancelReading()
+                writer.cancelWriting()
+                throw CancellationError()
+            }
+            let videoTime = nextVideo.map(CMSampleBufferGetPresentationTimeStamp)
+            let audioTime = nextAudio.map(CMSampleBufferGetPresentationTimeStamp)
+            let videoFirst: Bool
+            switch (videoTime, audioTime) {
+            case let (video?, audio?): videoFirst = video <= audio
+            case (_?, nil): videoFirst = true
+            default: videoFirst = false
+            }
+            let acceptsVideo = nextVideo != nil && videoInput.isReadyForMoreMediaData
+            let acceptsAudio = nextAudio != nil && audioInput?.isReadyForMoreMediaData == true
+            if acceptsVideo, videoFirst || !acceptsAudio, let sample = nextVideo {
+                guard videoInput.append(sample) else { throw writerFailure(writer) }
+                let timestamp = CMSampleBufferGetPresentationTimeStamp(sample).seconds
+                progress(min(0.99, max(0, timestamp / duration)))
+                nextVideo = videoOutput.copyNextSampleBuffer()
+            } else if acceptsAudio, let input = audioInput, let sample = nextAudio {
+                guard input.append(sample) else { throw writerFailure(writer) }
+                nextAudio = audioOutput?.copyNextSampleBuffer()
+            } else if nextAudio != nil, audioInput == nil {
+                nextAudio = nil
+            } else {
+                guard writer.status == .writing else { throw writerFailure(writer) }
+                Thread.sleep(forTimeInterval: 0.002)
+            }
+        }
+        videoInput.markAsFinished()
+        audioInput?.markAsFinished()
+        guard reader.status != .failed else {
+            throw MediaToolkitError.failed(
+                reader.error?.localizedDescription ?? "The video could not be read.")
+        }
+        let semaphore = DispatchSemaphore(value: 0)
+        writer.finishWriting { semaphore.signal() }
+        while semaphore.wait(timeout: .now() + .milliseconds(50)) == .timedOut {
+            if cancelled() {
+                writer.cancelWriting()
+                throw CancellationError()
+            }
+        }
+        guard writer.status == .completed else { throw writerFailure(writer) }
+        progress(1)
+    }
+
+    private static func writerFailure(_ writer: AVAssetWriter) -> MediaToolkitError {
+        .failed(writer.error?.localizedDescription ?? "The video could not be encoded.")
+    }
+
+    private static func uniqueOutputURL(
+        input: URL, directory: URL, extension fileExtension: String
+    ) -> URL {
+        let base = input.deletingPathExtension().lastPathComponent + "-converted"
+        var candidate = directory.appendingPathComponent(base).appendingPathExtension(fileExtension)
+        var counter = 2
+        while FileManager.default.fileExists(atPath: candidate.path) {
+            candidate = directory.appendingPathComponent("\(base)-\(counter)")
+                .appendingPathExtension(fileExtension)
+            counter += 1
+        }
+        return candidate
+    }
+
+    private static func fileSize(_ url: URL) -> Int64 {
+        Int64((try? url.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0)
+    }
+
+    private static func even(_ value: Int) -> Int {
+        let positive = max(2, value)
+        return positive.isMultiple(of: 2) ? positive : positive - 1
+    }
+}
diff --git a/Packages/Edith/Tests/EdithCoreTests/ExtensionRegistryTests.swift b/Packages/Edith/Tests/EdithCoreTests/ExtensionRegistryTests.swift
index d8d395bf8..b76081ccf 100644
--- a/Packages/Edith/Tests/EdithCoreTests/ExtensionRegistryTests.swift
+++ b/Packages/Edith/Tests/EdithCoreTests/ExtensionRegistryTests.swift
@@ -13,12 +13,11 @@ import Testing
     @Test func identifiersMatchCurrentBaseline() {
         #expect(
             ExtensionRegistry.entries.map(\.id) == [
-                "usage", "herdr", "quinjet", "companion", "plugins",
-                "appMaintenance", "homebrew", "cleaner",
-                "system", "keepAwake", "lidAwake", "systemStats", "micMute",
-                "clipboard", "emoji", "colorPicker", "keystrokeHighlight", "focusDim", "presenter",
-                "music", "downloads", "notchShelf", "audioMixer", "calendar",
-                "database", "attention", "seoAudit",
+                "usage", "herdr", "quinjet", "companion", "plugins", "appMaintenance", "homebrew",
+                "cleaner", "system", "keepAwake", "lidAwake", "systemStats", "micMute",
+                "mediaToolkit", "clipboard", "emoji", "colorPicker", "keystrokeHighlight",
+                "focusDim", "presenter", "music", "downloads", "notchShelf", "audioMixer",
+                "calendar", "database", "attention", "seoAudit",
             ])
     }
 
diff --git a/Packages/Edith/Tests/EdithTests/CLIContractTests.swift b/Packages/Edith/Tests/EdithTests/CLIContractTests.swift
index d5d848bf8..879e2822f 100644
--- a/Packages/Edith/Tests/EdithTests/CLIContractTests.swift
+++ b/Packages/Edith/Tests/EdithTests/CLIContractTests.swift
@@ -365,6 +365,15 @@ enum JSONContract {
         JSONCase(
             "ed download reveal", ["download", "reveal", "1", "--json"],
             mutatesTheMachine: true),
+        JSONCase("ed media status", ["media", "status", "--json"]),
+        JSONCase(
+            "ed media convert-images",
+            ["media", "convert-images", "/tmp/source.png", "--to", "/tmp/output", "--json"],
+            mutatesTheMachine: true),
+        JSONCase(
+            "ed media compress-video",
+            ["media", "compress-video", "/tmp/source.mov", "--to", "/tmp/output", "--json"],
+            mutatesTheMachine: true),
         JSONCase("ed color pick", ["color", "pick", "--json"], mutatesTheMachine: true),
         JSONCase("ed color ls", ["color", "ls", "--json"]),
         JSONCase(
diff --git a/Packages/Edith/Tests/EdithTests/CLIHarness.swift b/Packages/Edith/Tests/EdithTests/CLIHarness.swift
index bb00ba570..fc6d9bc75 100644
--- a/Packages/Edith/Tests/EdithTests/CLIHarness.swift
+++ b/Packages/Edith/Tests/EdithTests/CLIHarness.swift
@@ -70,6 +70,8 @@ enum CLIProcessProbeError: Error, Equatable, LocalizedError {
     }
 }
 
+private final class CLIProbeBundleMarker: NSObject {}
+
 enum CLIProcessProbe {
     static let defaultTimeout: TimeInterval = 15
     private static let terminationGrace: TimeInterval = 2
@@ -80,7 +82,11 @@ enum CLIProcessProbe {
         .deletingLastPathComponent()
 
     static var binary: URL {
-        packageRoot.appendingPathComponent(".build/debug/ed")
+        if let path = ProcessInfo.processInfo.environment["EDITH_TEST_CLI_EXECUTABLE"] {
+            return URL(fileURLWithPath: path)
+        }
+        return Bundle(for: CLIProbeBundleMarker.self).bundleURL
+            .deletingLastPathComponent().appendingPathComponent("ed")
     }
 
     static func run(
diff --git a/Packages/Edith/Tests/EdithTests/CLIMediaTests.swift b/Packages/Edith/Tests/EdithTests/CLIMediaTests.swift
new file mode 100644
index 000000000..7305df1b4
--- /dev/null
+++ b/Packages/Edith/Tests/EdithTests/CLIMediaTests.swift
@@ -0,0 +1,100 @@
+import CoreGraphics
+import Foundation
+import ImageIO
+import Testing
+import UniformTypeIdentifiers
+
+@testable import EdithCLI
+
+@Suite struct CLIMediaTests {
+    @Test func bareCommandReportsDefaultsAsHumanTextOrJSON() async {
+        let human = await CLIProbe.run(["media"])
+        let json = await CLIProbe.run(["media", "--json"])
+
+        #expect(human.code == 0)
+        #expect(human.stdout.contains("Media Toolkit: off"))
+        #expect(json.code == 0)
+        #expect(json.object?["enabled"] as? Bool == false)
+        #expect((json.object?["image"] as? [String: Any])?["format"] as? String == "jpeg")
+        #expect(
+            (json.object?["video"] as? [String: Any])?["targetMegabytes"] as? Int == 20)
+    }
+
+    @Test func parserExposesBothMediaOperations() throws {
+        let images = try #require(
+            try EdRoot.parseAsRoot([
+                "media", "convert-images", "one.png", "two.png", "--to", "out",
+                "--format", "heic", "--quality", "0.7", "--max-dimension", "800",
+                "--json",
+            ]) as? MediaConvertImagesCommand)
+        let video = try #require(
+            try EdRoot.parseAsRoot([
+                "media", "compress-video", "movie.mov", "--to", "out", "--target-mb",
+                "12", "--no-audio", "--json",
+            ]) as? MediaCompressVideoCommand)
+
+        #expect(images.inputs == ["one.png", "two.png"])
+        #expect(images.outputDirectory == "out")
+        #expect(images.format == "heic")
+        #expect(images.quality == 0.7)
+        #expect(images.maxDimension == 800)
+        #expect(images.json)
+        #expect(video.input == "movie.mov")
+        #expect(video.outputDirectory == "out")
+        #expect(video.targetMB == 12)
+        #expect(video.noAudio)
+        #expect(video.json)
+    }
+
+    @Test func conversionRequiresTheAgentAndDoesNotWriteFromTheCLI() async throws {
+        try await CLIProbe.inWorld { world in
+            let input = world.sandbox.appendingPathComponent("input.png")
+            let output = world.sandbox.appendingPathComponent("converted")
+            try writeImage(input, width: 100, height: 50)
+
+            let result = await CLIProbe.capture([
+                "media", "convert-images", input.path, "--to", output.path,
+                "--format", "jpeg", "--max-dimension", "20", "--json",
+            ])
+            #expect(result.code != 0)
+            #expect(!FileManager.default.fileExists(atPath: output.path))
+        }
+    }
+
+    @Test func invalidOptionsAreUsageErrors() async {
+        for arguments in [
+            ["media", "convert-images", "x.png", "--to", "out", "--format", "webp"],
+            ["media", "convert-images", "x.png", "--to", "out", "--quality", "0.01"],
+            ["media", "compress-video", "x.mov", "--to", "out", "--target-mb", "0"],
+        ] {
+            let result = await CLIProbe.run(arguments)
+            #expect(result.code == ExitCodes.usage, "\(arguments) exited \(result.code)")
+        }
+    }
+
+    @Test func missingInputIsNotFound() async {
+        let result = await CLIProbe.run([
+            "media", "compress-video", "/definitely/missing.mov", "--to", "/tmp",
+        ])
+
+        #expect(result.code == ExitCodes.notFound)
+        #expect(result.stdout.isEmpty)
+        #expect(result.stderr.contains("no file at"))
+    }
+
+    private func writeImage(_ url: URL, width: Int, height: Int) throws {
+        let context = try #require(
+            CGContext(
+                data: nil, width: width, height: height, bitsPerComponent: 8,
+                bytesPerRow: 0, space: CGColorSpaceCreateDeviceRGB(),
+                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue))
+        context.setFillColor(CGColor(red: 0.9, green: 0.3, blue: 0.1, alpha: 1))
+        context.fill(CGRect(x: 0, y: 0, width: width, height: height))
+        let image = try #require(context.makeImage())
+        let destination = try #require(
+            CGImageDestinationCreateWithURL(
+                url as CFURL, UTType.png.identifier as CFString, 1, nil))
+        CGImageDestinationAddImage(destination, image, nil)
+        #expect(CGImageDestinationFinalize(destination))
+    }
+}
diff --git a/Packages/Edith/Tests/EdithTests/CLIShapeTests.swift b/Packages/Edith/Tests/EdithTests/CLIShapeTests.swift
index 55dabb8bb..4b923258b 100644
--- a/Packages/Edith/Tests/EdithTests/CLIShapeTests.swift
+++ b/Packages/Edith/Tests/EdithTests/CLIShapeTests.swift
@@ -236,7 +236,7 @@ enum CommandCrawler {
             "ed companion hypotheses", "ed companion discrepancies", "ed companion standup",
             "ed companion connectors", "ed companion db", "ed companion stack",
             "ed machines terminal",
-            "ed lid-awake",
+            "ed lid-awake", "ed media",
             "ed attention", "ed attention categories", "ed attention focus",
             "ed quinjet",
             "ed database", "ed database connections", "ed database saved-queries",
diff --git a/Packages/Edith/Tests/EdithTests/ExtensionLifecycleProbeTests.swift b/Packages/Edith/Tests/EdithTests/ExtensionLifecycleProbeTests.swift
index 25a5fce67..f78f2f0d6 100644
--- a/Packages/Edith/Tests/EdithTests/ExtensionLifecycleProbeTests.swift
+++ b/Packages/Edith/Tests/EdithTests/ExtensionLifecycleProbeTests.swift
@@ -69,6 +69,10 @@ import EdithDatabase
             id: "micMute", helper: true, machine: false,
             toolRule: .all, adapter: true,
             requiredTools: [], optionalTools: []),
+        MatrixRow(
+            id: "mediaToolkit", helper: false, machine: false,
+            toolRule: .all, adapter: true,
+            requiredTools: [], optionalTools: []),
         MatrixRow(
             id: "clipboard", helper: true, machine: false,
             toolRule: .all, adapter: true,
diff --git a/Packages/Edith/Tests/EdithTests/ExtensionLiveAdapterTests.swift b/Packages/Edith/Tests/EdithTests/ExtensionLiveAdapterTests.swift
index 0246f6b4c..0afc09846 100644
--- a/Packages/Edith/Tests/EdithTests/ExtensionLiveAdapterTests.swift
+++ b/Packages/Edith/Tests/EdithTests/ExtensionLiveAdapterTests.swift
@@ -255,6 +255,21 @@ import EdithCore
                 == .failed("The configured music library path is not a folder."))
     }
 
+    @Test func mediaToolkitAdapterValidatesStoredDefaults() {
+        let suite = "test.extension-adapter.media-toolkit.\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defer { defaults.removePersistentDomain(forName: suite) }
+
+        #expect(
+            ExtensionLiveAdapters.mediaToolkitReadiness(defaults: defaults)
+                == .ready("ImageIO and AVFoundation processing defaults are ready."))
+        defaults.set("webp", forKey: AppStorageKeys.MediaToolkit.imageFormat)
+        #expect(
+            ExtensionLiveAdapters.mediaToolkitReadiness(defaults: defaults)
+                == .needsSetup(
+                    "Reset the stored Media Toolkit format, quality, dimensions or size limit."))
+    }
+
     @Test func calendarAdapterMapsPermissionAndContentStates() {
         #expect(
             ExtensionLiveAdapters.calendarReadiness(
diff --git a/Packages/Edith/Tests/EdithTests/ExtensionRegistryTests.swift b/Packages/Edith/Tests/EdithTests/ExtensionRegistryTests.swift
index 8f9c05ea5..cbddfcb5a 100644
--- a/Packages/Edith/Tests/EdithTests/ExtensionRegistryTests.swift
+++ b/Packages/Edith/Tests/EdithTests/ExtensionRegistryTests.swift
@@ -7,6 +7,7 @@ import Testing
 
 @Suite struct ExtensionRegistryTests {
     private let knownDefaultsKeys: Set<String> = [
+        "tabMediaToolkitEnabled",
         "tabUsageEnabled",
         "tabHerdrEnabled",
         "tabQuinjetEnabled",
@@ -44,12 +45,11 @@ import Testing
     @Test func registryMatchesCurrentBaseline() {
         #expect(
             ExtensionRegistry.entries.map(\.id) == [
-                "usage", "herdr", "quinjet", "companion", "plugins",
-                "appMaintenance", "homebrew", "cleaner",
-                "system", "keepAwake", "lidAwake", "systemStats", "micMute",
-                "clipboard", "emoji", "colorPicker", "keystrokeHighlight", "focusDim", "presenter",
-                "music", "downloads", "notchShelf", "audioMixer", "calendar",
-                "database", "attention", "seoAudit",
+                "usage", "herdr", "quinjet", "companion", "plugins", "appMaintenance", "homebrew",
+                "cleaner", "system", "keepAwake", "lidAwake", "systemStats", "micMute",
+                "mediaToolkit", "clipboard", "emoji", "colorPicker", "keystrokeHighlight",
+                "focusDim", "presenter", "music", "downloads", "notchShelf", "audioMixer",
+                "calendar", "database", "attention", "seoAudit",
             ])
     }
 
@@ -202,7 +202,7 @@ import Testing
         #expect(
             featuredIdentifiers == [
                 "usage", "herdr", "quinjet", "appMaintenance", "system", "keepAwake", "clipboard",
-                "keystrokeHighlight", "notchShelf", "database", "attention",
+                "keystrokeHighlight", "notchShelf", "database", "attention", "mediaToolkit",
             ])
     }
 
@@ -324,6 +324,7 @@ import Testing
 
     @Test func permissionTiersMatchFeatureRequirements() {
         let required: [String: [ExtensionPermission]] = [
+            "mediaToolkit": [],
             "usage": [],
             "herdr": [],
             "quinjet": [],
@@ -353,6 +354,7 @@ import Testing
             "seoAudit": [],
         ]
         let optional: [String: [ExtensionPermission]] = [
+            "mediaToolkit": [],
             "usage": [.notifications],
             "herdr": [],
             "quinjet": [],
diff --git a/Packages/Edith/Tests/EdithTests/ExtensionRuntimeStateTests.swift b/Packages/Edith/Tests/EdithTests/ExtensionRuntimeStateTests.swift
index 41812fc37..21dee3940 100644
--- a/Packages/Edith/Tests/EdithTests/ExtensionRuntimeStateTests.swift
+++ b/Packages/Edith/Tests/EdithTests/ExtensionRuntimeStateTests.swift
@@ -264,6 +264,10 @@ import Testing
             ("micMute", "MicMuteRows", "enabled", "ExtensionsPane.swift"),
             ("lidAwake", "LidAwakeRows", "enabled", "LidAwakeRows.swift"),
             ("music", "MusicRows", "enabled", "ExtensionsPane.swift"),
+            (
+                "mediaToolkit", "MediaToolkitRows", "enabled",
+                "../../MediaToolkit/MediaToolkitPage.swift"
+            ),
             ("calendar", "CalendarRows", "enabled", "ExtensionsPane.swift"),
             ("notchShelf", "NotchShelfRows", "enabled", "NotchShelfRows.swift"),
             ("clipboard", "ClipboardRows", "enabled", "ClipboardRows.swift"),
diff --git a/Packages/Edith/Tests/EdithTests/MainDestinationTests.swift b/Packages/Edith/Tests/EdithTests/MainDestinationTests.swift
index 347e7b51f..f3a0ababa 100644
--- a/Packages/Edith/Tests/EdithTests/MainDestinationTests.swift
+++ b/Packages/Edith/Tests/EdithTests/MainDestinationTests.swift
@@ -65,7 +65,7 @@ import Testing
                 .appMaintenance,
                 .system, .runningApps,
                 .desk,
-                .media, .music, .calendar,
+                .media, .mediaToolkit, .music, .calendar,
                 .data, .database, .attention, .seoAudit,
             ])
     }
diff --git a/Packages/Edith/Tests/EdithTests/MediaToolkitPageModelTests.swift b/Packages/Edith/Tests/EdithTests/MediaToolkitPageModelTests.swift
new file mode 100644
index 000000000..d61f942be
--- /dev/null
+++ b/Packages/Edith/Tests/EdithTests/MediaToolkitPageModelTests.swift
@@ -0,0 +1,106 @@
+import AppKit
+import SwiftUI
+import CoreGraphics
+import EdithKit
+import Foundation
+import ImageIO
+import Testing
+import UniformTypeIdentifiers
+
+@testable import Edith
+
+@MainActor
+@Suite struct MediaToolkitPageModelTests {
+    @Test func imageSelectionDeduplicatesAndUsesTheSourceFolder() {
+        let model = MediaToolkitPageModel()
+        let first = URL(fileURLWithPath: "/tmp/media/a.png")
+        let second = URL(fileURLWithPath: "/tmp/media/b.jpg")
+
+        model.add([first, first, second])
+
+        #expect(model.mode == .images)
+        #expect(model.imageURLs == [first, second])
+        #expect(model.resolvedOutputDirectory == first.deletingLastPathComponent())
+        #expect(model.canProcess)
+    }
+
+    @Test func videoSelectionReplacesTheCurrentVideo() {
+        let model = MediaToolkitPageModel()
+        let first = URL(fileURLWithPath: "/tmp/first.mov")
+        let second = URL(fileURLWithPath: "/tmp/second.mp4")
+
+        model.add([first])
+        model.add([second])
+
+        #expect(model.mode == .video)
+        #expect(model.videoURL == second)
+        #expect(model.canProcess)
+    }
+
+    @Test func unsupportedSelectionReportsAUsefulError() {
+        let model = MediaToolkitPageModel()
+
+        model.add([URL(fileURLWithPath: "/tmp/archive.zip")])
+
+        #expect(!model.canProcess)
+        #expect(model.errorMessage == "Choose an image or video that macOS can read.")
+    }
+
+    @Test func modelProcessesAnImageAndPublishesTheResult() async throws {
+        let root = URL(fileURLWithPath: "/tmp")
+            .appendingPathComponent("media-demo-" + UUID().uuidString, isDirectory: true)
+        let input = root.appendingPathComponent("source.png")
+        let output = root.appendingPathComponent("output", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        try writeImage(input)
+        let model = MediaToolkitPageModel(
+            executor: MediaToolkitExecutor(
+                images: { try MediaToolkit.convertImages($0, to: $1, options: $2, progress: $3) },
+                video: {
+                    try await MediaToolkit.compressVideo($0, to: $1, options: $2, progress: $3)
+                }))
+        model.add([input])
+        model.outputDirectory = output
+
+        model.process(
+            imageOptions: MediaImageOptions(format: .jpeg, maxDimension: 1600),
+            videoOptions: MediaVideoOptions())
+        while model.isProcessing {
+            try await Task.sleep(for: .milliseconds(10))
+        }
+
+        let result = try #require(model.imageResults.first)
+        let resultURL = try #require(result.outputURL)
+        #expect(resultURL.pathExtension == "jpg")
+        #expect(FileManager.default.fileExists(atPath: resultURL.path))
+        #expect(model.progress == 1)
+        #expect(model.status == "Converted 1 of 1")
+        if let directory = ProcessInfo.processInfo.environment["EDITH_RENDER_DUMP"] {
+            let hosting = NSHostingView(rootView: MediaToolkitPage(model: model))
+            hosting.frame = NSRect(x: 0, y: 0, width: 1000, height: 1100)
+            hosting.layoutSubtreeIfNeeded()
+            let bitmap = try #require(hosting.bitmapImageRepForCachingDisplay(in: hosting.bounds))
+            hosting.cacheDisplay(in: hosting.bounds, to: bitmap)
+            let data = try #require(bitmap.representation(using: .png, properties: [:]))
+            try data.write(
+                to: URL(fileURLWithPath: directory).appendingPathComponent("media-toolkit.png"))
+        }
+    }
+
+    private func writeImage(_ url: URL) throws {
+        let context = try #require(
+            CGContext(
+                data: nil, width: 80, height: 40, bitsPerComponent: 8,
+                bytesPerRow: 0, space: CGColorSpaceCreateDeviceRGB(),
+                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue))
+        context.setFillColor(CGColor(red: 0.2, green: 0.7, blue: 0.4, alpha: 1))
+        context.fill(CGRect(x: 0, y: 0, width: 80, height: 40))
+        let image = try #require(context.makeImage())
+        let destination = try #require(
+            CGImageDestinationCreateWithURL(
+                url as CFURL, UTType.png.identifier as CFString, 1, nil))
+        CGImageDestinationAddImage(destination, image, nil)
+        try #require(CGImageDestinationFinalize(destination))
+    }
+}
diff --git a/Packages/Edith/Tests/EdithTests/MediaToolkitTests.swift b/Packages/Edith/Tests/EdithTests/MediaToolkitTests.swift
new file mode 100644
index 000000000..06da788b3
--- /dev/null
+++ b/Packages/Edith/Tests/EdithTests/MediaToolkitTests.swift
@@ -0,0 +1,203 @@
+import AVFoundation
+import CoreGraphics
+import CoreVideo
+import Foundation
+import ImageIO
+import Testing
+import UniformTypeIdentifiers
+
+@testable import EdithKit
+
+@Suite struct MediaToolkitTests {
+    @Test func imageOptionsClampUnsafeValues() {
+        let options = MediaImageOptions(format: .jpeg, quality: 4, maxDimension: -20)
+
+        #expect(options.quality == 1)
+        #expect(options.maxDimension == 1)
+    }
+
+    @Test func videoPlanFitsDimensionsAndReservesAudio() throws {
+        let plan = try #require(
+            MediaToolkit.videoPlan(
+                targetBytes: 20_000_000, duration: 60,
+                sourceSize: CGSize(width: 3840, height: 2160), frameRate: 30,
+                hasAudio: true))
+
+        #expect(plan.width <= 1920)
+        #expect(plan.height <= 1920)
+        #expect(plan.width.isMultiple(of: 2))
+        #expect(plan.height.isMultiple(of: 2))
+        #expect(plan.audioBitRate == 96_000)
+        #expect(plan.videoBitRate > 240_000)
+        #expect(abs(Double(plan.width) / Double(plan.height) - 16.0 / 9.0) < 0.01)
+    }
+
+    @Test func portraitVideoPlanPreservesOrientationAndAspectRatio() throws {
+        let plan = try #require(
+            MediaToolkit.videoPlan(
+                targetBytes: 12_000_000, duration: 30,
+                sourceSize: CGSize(width: 1080, height: 1920), frameRate: 30,
+                hasAudio: false))
+
+        #expect(plan.width < plan.height)
+        #expect(plan.height <= 1920)
+        #expect(abs(Double(plan.width) / Double(plan.height) - 9.0 / 16.0) < 0.01)
+    }
+
+    @Test func impossibleVideoTargetHasNoPlan() {
+        let plan = MediaToolkit.videoPlan(
+            targetBytes: 100_000, duration: 600,
+            sourceSize: CGSize(width: 1920, height: 1080), frameRate: 30,
+            hasAudio: true)
+
+        #expect(plan == nil)
+    }
+
+    @Test func batchConversionResizesAndAvoidsCollisions() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let input = root.appendingPathComponent("source.png")
+        let output = root.appendingPathComponent("output", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        try writeImage(input, width: 120, height: 60)
+
+        let first = try MediaToolkit.convertImages(
+            [input], to: output,
+            options: MediaImageOptions(format: .jpeg, quality: 0.8, maxDimension: 40))
+        let second = try MediaToolkit.convertImages(
+            [input], to: output,
+            options: MediaImageOptions(format: .jpeg, quality: 0.8, maxDimension: 40))
+        let firstURL = try #require(first.first?.outputURL)
+        let secondURL = try #require(second.first?.outputURL)
+        let source = try #require(CGImageSourceCreateWithURL(firstURL as CFURL, nil))
+        let properties = try #require(
+            CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any])
+
+        #expect(firstURL.pathExtension == "jpg")
+        #expect(firstURL != secondURL)
+        #expect(properties[kCGImagePropertyPixelWidth] as? Int == 40)
+        #expect(properties[kCGImagePropertyPixelHeight] as? Int == 20)
+    }
+
+    @Test func cancellationStopsBeforeWork() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        #expect(throws: CancellationError.self) {
+            try MediaToolkit.convertImages(
+                [root.appendingPathComponent("missing.png")], to: root,
+                options: MediaImageOptions(format: .png), cancelled: { true })
+        }
+    }
+
+    @Test func videoCompressionWritesACompleteBoundedFile() async throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let input = root.appendingPathComponent("source.mov")
+        let output = root.appendingPathComponent("output", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        try await writeVideo(input, width: 320, height: 180, frames: 60, frameRate: 30)
+
+        let result = try await MediaToolkit.compressVideo(
+            input, to: output,
+            options: MediaVideoOptions(targetMegabytes: 1, keepAudio: false))
+        let asset = AVURLAsset(url: result.outputURL)
+        let duration = try await asset.load(.duration).seconds
+        let tracks = try await asset.loadTracks(withMediaType: .video)
+
+        #expect(result.outputBytes > 0)
+        #expect(result.outputBytes <= result.targetBytes)
+        #expect(result.outputURL.pathExtension == "mp4")
+        #expect(duration >= 1.9)
+        #expect(tracks.count == 1)
+    }
+
+    @Test func cancelledVideoCompressionLeavesNoOutput() async throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let input = root.appendingPathComponent("source.mov")
+        let output = root.appendingPathComponent("output", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        try await writeVideo(input, width: 160, height: 90, frames: 3, frameRate: 30)
+
+        await #expect(throws: CancellationError.self) {
+            try await MediaToolkit.compressVideo(
+                input, to: output,
+                options: MediaVideoOptions(targetMegabytes: 1, keepAudio: false),
+                cancelled: { true })
+        }
+        let contents = try FileManager.default.contentsOfDirectory(
+            at: output, includingPropertiesForKeys: nil)
+        #expect(contents.isEmpty)
+    }
+
+    private func writeImage(_ url: URL, width: Int, height: Int) throws {
+        let space = CGColorSpaceCreateDeviceRGB()
+        let context = try #require(
+            CGContext(
+                data: nil, width: width, height: height, bitsPerComponent: 8,
+                bytesPerRow: 0, space: space,
+                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue))
+        context.setFillColor(CGColor(red: 0.15, green: 0.45, blue: 0.9, alpha: 1))
+        context.fill(CGRect(x: 0, y: 0, width: width, height: height))
+        let image = try #require(context.makeImage())
+        let destination = try #require(
+            CGImageDestinationCreateWithURL(url as CFURL, UTType.png.identifier as CFString, 1, nil)
+        )
+        CGImageDestinationAddImage(destination, image, nil)
+        #expect(CGImageDestinationFinalize(destination))
+    }
+
+    private func writeVideo(
+        _ url: URL, width: Int, height: Int, frames: Int, frameRate: Int32
+    ) async throws {
+        let writer = try AVAssetWriter(outputURL: url, fileType: .mov)
+        let input = AVAssetWriterInput(
+            mediaType: .video,
+            outputSettings: [
+                AVVideoCodecKey: AVVideoCodecType.h264,
+                AVVideoWidthKey: width,
+                AVVideoHeightKey: height,
+            ])
+        let adaptor = AVAssetWriterInputPixelBufferAdaptor(
+            assetWriterInput: input,
+            sourcePixelBufferAttributes: [
+                kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
+                kCVPixelBufferWidthKey as String: width,
+                kCVPixelBufferHeightKey as String: height,
+            ])
+        try #require(writer.canAdd(input))
+        writer.add(input)
+        try #require(writer.startWriting())
+        writer.startSession(atSourceTime: .zero)
+        let pool = try #require(adaptor.pixelBufferPool)
+        for frame in 0..<frames {
+            while !input.isReadyForMoreMediaData {
+                try await Task.sleep(for: .milliseconds(2))
+            }
+            var pixelBuffer: CVPixelBuffer?
+            try #require(
+                CVPixelBufferPoolCreatePixelBuffer(nil, pool, &pixelBuffer) == kCVReturnSuccess)
+            let buffer = try #require(pixelBuffer)
+            CVPixelBufferLockBaseAddress(buffer, [])
+            if let base = CVPixelBufferGetBaseAddress(buffer) {
+                let byteCount = CVPixelBufferGetBytesPerRow(buffer) * height
+                memset(base, Int32((frame * 3) % 220 + 20), byteCount)
+            }
+            CVPixelBufferUnlockBaseAddress(buffer, [])
+            try #require(
+                adaptor.append(
+                    buffer,
+                    withPresentationTime: CMTime(value: Int64(frame), timescale: frameRate)))
+        }
+        input.markAsFinished()
+        await withCheckedContinuation { continuation in
+            writer.finishWriting { continuation.resume() }
+        }
+        try #require(writer.status == .completed)
+    }
+}
diff --git a/Packages/Edith/Tests/EdithTests/MediaToolkitWorkflowTests.swift b/Packages/Edith/Tests/EdithTests/MediaToolkitWorkflowTests.swift
new file mode 100644
index 000000000..f378ff2e9
--- /dev/null
+++ b/Packages/Edith/Tests/EdithTests/MediaToolkitWorkflowTests.swift
@@ -0,0 +1,65 @@
+import CoreGraphics
+import Foundation
+import ImageIO
+import Testing
+import UniformTypeIdentifiers
+
+@testable import EdithAgent
+@testable import EdithKit
+
+@Suite(.serialized) struct MediaToolkitWorkflowTests {
+    @Test func imageConversionRunsThroughTheAgentTaskQueue() async throws {
+        let defaults = SharedDefaults.store
+        let suiteKey = "suiteMediaEnabled"
+        let abilityKey = AppStorageKeys.Tabs.mediaToolkitEnabled
+        let suiteBefore = defaults.object(forKey: suiteKey)
+        let abilityBefore = defaults.object(forKey: abilityKey)
+        defaults.set(true, forKey: suiteKey)
+        defaults.set(true, forKey: abilityKey)
+        defer {
+            defaults.set(suiteBefore, forKey: suiteKey)
+            defaults.set(abilityBefore, forKey: abilityKey)
+        }
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        let input = root.appendingPathComponent("sample.png")
+        let context = try #require(
+            CGContext(
+                data: nil, width: 120, height: 60, bitsPerComponent: 8, bytesPerRow: 0,
+                space: CGColorSpaceCreateDeviceRGB(),
+                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue))
+        context.setFillColor(CGColor(red: 0.2, green: 0.5, blue: 0.8, alpha: 1))
+        context.fill(CGRect(x: 0, y: 0, width: 120, height: 60))
+        let image = try #require(context.makeImage())
+        let destination = try #require(
+            CGImageDestinationCreateWithURL(
+                input as CFURL, UTType.png.identifier as CFString, 1, nil))
+        CGImageDestinationAddImage(destination, image, nil)
+        #expect(CGImageDestinationFinalize(destination))
+        let service = try AgentTaskService(directory: nil)
+        await MediaToolkitWorkflow.register(on: service)
+        let payload = MediaImageTaskRequest(
+            inputs: [input], destination: root.appendingPathComponent("output"),
+            options: MediaImageOptions(format: .jpeg, maxDimension: 40))
+        let request = AgentTaskSubmission(
+            operation: MediaToolkitOperation.convertImages.descriptor.id.rawValue,
+            title: "Convert sample image", payload: try AgentPayload.encode(payload))
+        _ = try await service.submit(request)
+        var status = try await service.status(request.id)
+        for _ in 0..<250 where !status.snapshot.state.isTerminal {
+            try await Task.sleep(for: .milliseconds(20))
+            status = try await service.status(request.id)
+        }
+        #expect(status.snapshot.state == .succeeded)
+        let result = try AgentPayload.decode([MediaImageResult].self, from: #require(status.result))
+        let output = try #require(result.first?.outputURL)
+        let source = try #require(CGImageSourceCreateWithURL(output as CFURL, nil))
+        let properties = try #require(
+            CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any])
+        #expect(properties[kCGImagePropertyPixelWidth] as? Int == 40)
+        #expect(properties[kCGImagePropertyPixelHeight] as? Int == 20)
+        #expect(FileManager.default.fileExists(atPath: input.path))
+        await service.shutdown()
+    }
+}
diff --git a/README.md b/README.md
index eef9667d4..79f15a510 100644
--- a/README.md
+++ b/README.md
@@ -65,6 +65,7 @@ and platform details.
 **Everything else on the shelf**
 
 - **Music player** - your local music folder with thumbnails, drag-to-seek, fades, auto-advance and media keys; also controls Spotify and Apple Music.
+- **Media Toolkit** - batch image conversion and aspect-preserving resizing, plus local video compression to a hard file-size limit.
 - **Clipboard history** - a global paste panel with search and paste-in-place.
 - **Color picker** - system-wide eyedropper on a hotkey, with swatch history.
 - **Emoji picker** - every emoji this Mac can draw on a hotkey, with search, categories, skin tones and your most-used pinned to the top.
diff --git a/docs/cli/README.md b/docs/cli/README.md
index 03b326e08..b4777a11c 100644
--- a/docs/cli/README.md
+++ b/docs/cli/README.md
@@ -61,6 +61,7 @@ report still exits 0, so read `verified`, `state.phase`, `state.runtimePhase`,
 | [`ed herdr`](./herdr/README.md) | Live Herdr sessions on this Mac and your SSH machines |
 | [`ed quinjet`](./quinjet/README.md) | Discover, inspect and launch Quinjet review workspaces locally or on a configured machine |
 | [`ed database`](./database/README.md) | Saved database connections and capability reports through the authenticated local broker |
+| [`ed media`](./media/README.md) | Daemon-backed image conversion and video compression |
 | [`ed clipboard`](./clipboard/README.md) | Clipboard history: read, copy, pin and prune |
 | [`ed attention`](./attention/README.md) | Application, website, music, focus and distraction insight |
 | [`ed color`](./color/README.md) | Launching the colour picker and reading its swatch history |
diff --git a/docs/cli/media/README.md b/docs/cli/media/README.md
new file mode 100644
index 000000000..3902521cb
--- /dev/null
+++ b/docs/cli/media/README.md
@@ -0,0 +1,48 @@
+# `ed media`
+
+`ed media` processes images and videos entirely on this Mac. It submits cancellable tasks to the local Edith daemon and does not upload files
+or require a third-party executable. Image conversion uses ImageIO, and video
+compression uses AVFoundation. Enable the Media suite and Media Toolkit ability
+before processing.
+
+The image command accepts a batch and writes collision-safe files into one output folder.
+The video command writes a complete H.264 MP4 whose final byte count is at or below the
+requested limit. Both commands preserve their inputs and can run while the app window is closed and the daemon is running.
+
+## Commands
+
+- [`ed media status`](./status.md)
+- [`ed media convert-images`](./convert-images.md)
+- [`ed media compress-video`](./compress-video.md)
+
+## Common behavior
+
+- Relative paths resolve from the current directory, and paths beginning with `~` expand
+  to the current home directory.
+- Output folders are created when they do not exist.
+- Existing files are never overwritten. Outputs use `-converted`, then a numeric suffix
+  when necessary.
+- JPEG, PNG and HEIC are the image output formats. ImageIO accepts any input format that
+  macOS can decode.
+- Video output is H.264 in an MP4 container. Audio is AAC unless `--no-audio` is passed.
+- Decimal megabytes are used for video limits, so `20 MB` means `20,000,000` bytes.
+- `--json` prints exactly one JSON document on stdout. Diagnostics remain on stderr.
+- Pressing Control-C cancels processing. A staged image or incomplete video is removed.
+
+## Exit codes
+
+| Code | Meaning |
+| --- | --- |
+| 0 | Processing completed. Image batches may include individual failures in the result. |
+| 1 | A file encoder, output directory or other operating system operation failed. |
+| 2 | An option was out of range or a required argument was missing. |
+| 3 | An input path did not exist. |
+| 4 | The source format was unsupported, the target was impossible, or processing was cancelled. |
+
+## Related commands
+
+- `ed extensions enable mediaToolkit`
+- `ed config ls --group media --json`
+- `ed extensions status mediaToolkit --json`
+
+[All `ed` commands](../README.md)
diff --git a/docs/cli/media/compress-video.md b/docs/cli/media/compress-video.md
new file mode 100644
index 000000000..7871f347d
--- /dev/null
+++ b/docs/cli/media/compress-video.md
@@ -0,0 +1,37 @@
+# `ed media compress-video`
+
+Compresses one complete local video into an H.264 MP4 at or below a requested file-size
+limit. The encoder derives a bitrate and a bounded resolution from the source duration,
+frame rate and target size. If rate control overshoots, it retries with a smaller budget.
+
+Usage:
+
+```
+ed media compress-video <input> --to <directory> [--target-mb <megabytes>] [--no-audio] [--json]
+```
+
+Options:
+
+| Name | Values | Default | Meaning |
+| --- | --- | --- | --- |
+| `--to` | directory path | required | Folder that receives the MP4. |
+| `--target-mb` | `1` through `512` | `20` | Hard output limit in decimal megabytes. |
+| `--no-audio` | flag | off | Omit every source audio track. |
+| `--json` | flag | off | Emit one structured result document. |
+
+The command preserves the whole duration. It does not trim, crop, join or otherwise edit
+the timeline. If the selected limit cannot carry a usable full-length video, the command
+removes the incomplete output and exits 4.
+
+The JSON object contains `operation`, `input`, `output`, `inputBytes`, `outputBytes`,
+`targetBytes`, and `audio`. A successful result always has `outputBytes <= targetBytes`.
+
+Examples:
+
+```
+ed media compress-video demo.mov --to ./exports
+ed media compress-video recording.mp4 --to ./share --target-mb 8 --no-audio
+ed media compress-video presentation.mov --to ./exports --target-mb 100 --json
+```
+
+[Back to `ed media`](./README.md) · [All `ed` commands](../README.md)
diff --git a/docs/cli/media/convert-images.md b/docs/cli/media/convert-images.md
new file mode 100644
index 000000000..8902971c0
--- /dev/null
+++ b/docs/cli/media/convert-images.md
@@ -0,0 +1,38 @@
+# `ed media convert-images`
+
+Converts one or more local images into a shared output folder. Every image is processed
+independently, so one unreadable input does not discard successful results from the same
+batch.
+
+Usage:
+
+```
+ed media convert-images <inputs>... --to <directory> [--format <format>] [--quality <value>] [--max-dimension <pixels>] [--json]
+```
+
+Options:
+
+| Name | Values | Default | Meaning |
+| --- | --- | --- | --- |
+| `--to` | directory path | required | Folder that receives every converted file. |
+| `--format` | `jpeg`, `png`, `heic` | `jpeg` | Output image format. |
+| `--quality` | `0.1` through `1` | `0.82` | Lossy compression quality for JPEG and HEIC. |
+| `--max-dimension` | `0` through `20000` | `1600` | Largest pixel edge. `0` keeps the source dimensions. |
+| `--json` | flag | off | Emit one structured result document. |
+
+Resizing preserves aspect ratio and never enlarges an image. Orientation metadata is
+applied to the pixels during conversion. Metadata is not copied into the new file.
+
+The JSON object contains `operation`, `outputDirectory`, `succeeded`, `failed`, and
+`results`. Each result contains `input`, nullable `output`, `inputBytes`, `outputBytes`,
+and nullable `error`.
+
+Examples:
+
+```
+ed media convert-images photo.png --to ./converted
+ed media convert-images *.tiff --to ./web --format heic --quality 0.75
+ed media convert-images a.jpg b.jpg --to ./thumbs --format png --max-dimension 512 --json
+```
+
+[Back to `ed media`](./README.md) · [All `ed` commands](../README.md)
diff --git a/docs/cli/media/status.md b/docs/cli/media/status.md
new file mode 100644
index 000000000..8ed8b99c7
--- /dev/null
+++ b/docs/cli/media/status.md
@@ -0,0 +1,25 @@
+# `ed media status`
+
+Shows whether the Media Toolkit extension is enabled and reports the saved defaults used
+by its image and video workspaces. Running bare `ed media` invokes the same command.
+
+Usage:
+
+```
+ed media [status] [--json]
+```
+
+The human-readable result lists the current image format, maximum image dimension,
+quality, target video size, and audio preference. The JSON object contains `enabled`, an
+`image` object with `format`, `formats`, `maxDimension`, and `quality`, plus a `video`
+object with `keepAudio` and `targetMegabytes`.
+
+Examples:
+
+```
+ed media
+ed media status
+ed media --json
+```
+
+[Back to `ed media`](./README.md) · [All `ed` commands](../README.md)
diff --git a/scripts/build-jobs.sh b/scripts/build-jobs.sh
new file mode 100644
index 000000000..5112012ff
--- /dev/null
+++ b/scripts/build-jobs.sh
@@ -0,0 +1,30 @@
+validate_build_jobs() {
+  case "$1" in
+    "") ;;
+    *[!0-9]*|0)
+      echo "EDITH_BUILD_JOBS must be a positive integer" >&2
+      return 1
+      ;;
+  esac
+}
+
+xcodebuild_with_jobs() {
+  local jobs="$1"
+  shift
+  if [ -n "$jobs" ]; then
+    xcodebuild -jobs "$jobs" "$@"
+  else
+    xcodebuild "$@"
+  fi
+}
+
+swift_build_with_jobs() {
+  local jobs="$1"
+  local swift_bin="$2"
+  shift 2
+  if [ -n "$jobs" ]; then
+    "$swift_bin" build --jobs "$jobs" "$@"
+  else
+    "$swift_bin" build "$@"
+  fi
+}
diff --git a/scripts/build-jobs.test.js b/scripts/build-jobs.test.js
new file mode 100644
index 000000000..49f8e4635
--- /dev/null
+++ b/scripts/build-jobs.test.js
@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+
+const harness = `
+set -euo pipefail
+source scripts/build-jobs.sh
+xcodebuild() { printf 'xcode:%s\\n' "$@"; }
+swift_stub() { printf 'swift:%s\\n' "$@"; }
+jobs="\${EDITH_BUILD_JOBS:-}"
+validate_build_jobs "$jobs"
+xcodebuild_with_jobs "$jobs" -project app
+swift_build_with_jobs "$jobs" swift_stub --package-path package
+`;
+
+function run(jobs) {
+  const environment = { ...process.env };
+  if (jobs === undefined) {
+    delete environment.EDITH_BUILD_JOBS;
+  } else {
+    environment.EDITH_BUILD_JOBS = jobs;
+  }
+  return Bun.spawnSync(["/bin/bash", "-u", "-c", harness], {
+    cwd: process.cwd(),
+    env: environment,
+  });
+}
+
+describe("build job limits", () => {
+  test("the unset default uses native command parallelism under nounset", () => {
+    const result = run(undefined);
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.toString()).toBe(
+      "xcode:-project\nxcode:app\nswift:build\nswift:--package-path\nswift:package\n",
+    );
+  });
+
+  test("an explicit value bounds Xcode and Swift builds", () => {
+    const result = run("2");
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.toString()).toBe(
+      "xcode:-jobs\nxcode:2\nxcode:-project\nxcode:app\nswift:build\nswift:--jobs\nswift:2\nswift:--package-path\nswift:package\n",
+    );
+  });
+
+  test("invalid values fail before either build starts", () => {
+    for (const value of ["0", "two", "-1"]) {
+      const result = run(value);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stdout.toString()).toBe("");
+      expect(result.stderr.toString()).toContain(
+        "EDITH_BUILD_JOBS must be a positive integer",
+      );
+    }
+  });
+});