diff --git a/crates/takana-cli/src/kernel_ab.rs b/crates/takana-cli/src/kernel_ab.rs
index 646903d1..37453443 100644
--- a/crates/takana-cli/src/kernel_ab.rs
+++ b/crates/takana-cli/src/kernel_ab.rs
@@ -162,6 +162,147 @@ pub fn instalar_candidato(bzimage: &Path, esp: &Path, ruta_efi: &str) -> Result<
     Ok(n)
 }
 
+// ══ kexec: el reboot suave (ADR 0017 §1) ═══════════════════════════════════════════════════════
+//
+// Se usa **`kexec_file_load`**, no el `kexec_load` viejo, y la diferencia es de orden de magnitud:
+// `kexec_load` recibe los segmentos YA armados y el *purgatory* —el código que corre entre los dos
+// kernels—, o sea que usarlo obliga a reimplementar kexec-tools. `kexec_file_load` recibe los
+// **descriptores** del kernel y del initrd y hace el trabajo dentro del kernel.
+//
+// Se hace con `asm!` en vez de agregar la crate `libc` al workspace: es **un** syscall, su número y
+// su ABI son contrato estable de Linux, y la alternativa era arrastrar una dependencia a un
+// workspace compartido por dos frentes.
+//
+// ⚠ **Esto no es «actualizar sin rebootear».** El userspace muere igual: es un reboot que se salta
+// el firmware. Lo que ahorra son los 20-30 s de POST/UEFI — la mitad del downtime en un servidor
+// remoto, y nada en un portátil. La ayuda del comando lo dice con esas palabras a propósito.
+#[cfg(target_arch = "x86_64")]
+mod sys {
+    /// `kexec_file_load` en x86_64. Contrato: `include/uapi/asm-generic/unistd.h`.
+    pub const NR_KEXEC_FILE_LOAD: u64 = 320;
+    /// `reboot`.
+    pub const NR_REBOOT: u64 = 169;
+
+    pub const LINUX_REBOOT_MAGIC1: u64 = 0xfee1_dead;
+    pub const LINUX_REBOOT_MAGIC2: u64 = 672_274_793;
+    pub const LINUX_REBOOT_CMD_KEXEC: u64 = 0x4558_4543;
+    /// Cargar sin initramfs (el fd de initrd se ignora).
+    pub const KEXEC_FILE_NO_INITRAMFS: u64 = 0x4;
+
+    /// # Safety
+    /// Invoca un syscall crudo. Los argumentos tienen que respetar la ABI del syscall llamado.
+    pub unsafe fn syscall5(n: u64, a: u64, b: u64, c: u64, d: u64, e: u64) -> i64 {
+        let ret: i64;
+        unsafe {
+            std::arch::asm!(
+                "syscall",
+                inlateout("rax") n => ret,
+                in("rdi") a,
+                in("rsi") b,
+                in("rdx") c,
+                in("r10") d,
+                in("r8") e,
+                lateout("rcx") _,
+                lateout("r11") _,
+                options(nostack)
+            );
+        }
+        ret
+    }
+}
+
+/// Carga un kernel para el próximo `reboot -f kexec`. NO salta todavía.
+#[cfg(target_arch = "x86_64")]
+pub fn kexec_cargar(kernel: &Path, initrd: Option<&Path>, cmdline: &str) -> Result<()> {
+    use std::os::fd::AsRawFd;
+    let fk = std::fs::File::open(kernel)
+        .with_context(|| format!("abriendo el kernel {}", kernel.display()))?;
+    // El cmdline viaja con su NUL: el kernel cuenta `cmdline_len` INCLUYENDO el terminador, y sin él
+    // lee un byte de más. Es el error clásico de esta llamada.
+    let mut cl: Vec<u8> = cmdline.as_bytes().to_vec();
+    cl.push(0);
+
+    let (fd_i, flags) = match initrd {
+        Some(p) => {
+            let fi = std::fs::File::open(p)
+                .with_context(|| format!("abriendo el initrd {}", p.display()))?;
+            (Some(fi), 0u64)
+        }
+        None => (None, sys::KEXEC_FILE_NO_INITRAMFS),
+    };
+    let raw_i = fd_i.as_ref().map(|f| f.as_raw_fd()).unwrap_or(-1);
+
+    let r = unsafe {
+        sys::syscall5(
+            sys::NR_KEXEC_FILE_LOAD,
+            fk.as_raw_fd() as u64,
+            raw_i as u64,
+            cl.len() as u64,
+            cl.as_ptr() as u64,
+            flags,
+        )
+    };
+    if r < 0 {
+        let e = -r;
+        // Traducir los tres errores que de verdad pasan, porque «Permission denied» a secas manda a
+        // buscar permisos de fichero cuando el problema es otro.
+        // ⚠ EPERM y ENOSYS se confunden fácil y mandan a lugares OPUESTOS. Medido en este mismo hub:
+        // el kernel de Artix trae `CONFIG_KEXEC_FILE=y` y aun así devolvió EPERM — por no ser root.
+        // El primer texto de este match decía «falta CONFIG_KEXEC_FILE» para EPERM, que es
+        // exactamente el diagnóstico equivocado: manda a recompilar un kernel que estaba bien.
+        let pista = match e {
+            1 => " ⇒ falta CAP_SYS_BOOT: hay que ser root (y si YA sos root, es lockdown: Secure Boot no deja cargar un kernel sin firmar)",
+            38 => " ⇒ el kernel que CORRE no implementa kexec_file_load: le falta CONFIG_KEXEC_FILE",
+            13 => " ⇒ no puedo leer el fichero del kernel o del initrd",
+            22 => " ⇒ la imagen no le gustó al kernel (¿es un bzImage x86_64 válido?)",
+            _ => "",
+        };
+        bail!("kexec_file_load falló: errno {e}{pista}");
+    }
+    Ok(())
+}
+
+/// Salta al kernel ya cargado. **No vuelve.**
+#[cfg(target_arch = "x86_64")]
+pub fn kexec_saltar() -> Result<()> {
+    let r = unsafe {
+        sys::syscall5(
+            sys::NR_REBOOT,
+            sys::LINUX_REBOOT_MAGIC1,
+            sys::LINUX_REBOOT_MAGIC2,
+            sys::LINUX_REBOOT_CMD_KEXEC,
+            0,
+            0,
+        )
+    };
+    bail!("reboot(KEXEC) volvió con {r}: no había kernel cargado, o no somos root")
+}
+
+#[cfg(not(target_arch = "x86_64"))]
+pub fn kexec_cargar(_: &Path, _: Option<&Path>, _: &str) -> Result<()> {
+    bail!("kexec: sólo implementado para x86_64")
+}
+#[cfg(not(target_arch = "x86_64"))]
+pub fn kexec_saltar() -> Result<()> {
+    bail!("kexec: sólo implementado para x86_64")
+}
+
+/// ¿El kernel que corre soporta `kexec_file_load`? Se responde **preguntándole al kernel**, no
+/// leyendo un `.config` que puede no ser el suyo.
+pub fn kexec_file_disponible() -> bool {
+    // Un `kexec_file_load` con fd inválido devuelve EBADF (9) si el syscall EXISTE, y ENOSYS (38)
+    // si no está compilado. Distinguir los dos es toda la prueba, y no carga nada.
+    #[cfg(target_arch = "x86_64")]
+    {
+        let r = unsafe { sys::syscall5(sys::NR_KEXEC_FILE_LOAD, u64::MAX, u64::MAX, 0, 0, sys::KEXEC_FILE_NO_INITRAMFS) };
+        -r != 38
+    }
+    #[cfg(not(target_arch = "x86_64"))]
+    {
+        false
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/takana-cli/src/kernel_cmd.rs b/crates/takana-cli/src/kernel_cmd.rs
index c1d3a74c..cbee9d16 100644
--- a/crates/takana-cli/src/kernel_cmd.rs
+++ b/crates/takana-cli/src/kernel_cmd.rs
@@ -227,6 +227,28 @@ pub enum KernelCmd {
         #[arg(long)]
         dry_run: bool,
     },
+    /// Soft reboot into a kernel: skip firmware and bootloader (ADR 0017 §1).
+    ///
+    /// ⚠ **NO es «actualizar sin rebootear».** El userspace muere igual — es un reboot que se salta
+    /// el firmware. Ahorra los 20-30 s de POST/UEFI, que en un servidor remoto es la mitad del
+    /// downtime y en un portátil no es nada. Se dice acá porque media industria vende esto como
+    /// «live kernel update» y no lo es.
+    Kexec {
+        /// Artefacto del kernel en el store (nombre de directorio o ruta).
+        artefacto: String,
+        /// initramfs a cargar con él.
+        #[arg(long)]
+        initrd: Option<PathBuf>,
+        /// Kernel command line for the new kernel.
+        #[arg(long, default_value = "console=tty0 console=ttyS0,115200")]
+        cmdline: String,
+        /// Load it and stop there: the jump needs `--jump`.
+        #[arg(long)]
+        load_only: bool,
+        /// Actually jump. Without this it only loads and reports.
+        #[arg(long)]
+        jump: bool,
+    },
     /// Say where this boot came from and what is on trial.
     BootStatus {
         #[arg(long, default_value = crate::efi_boot::EFIVARS)]
@@ -266,6 +288,8 @@ pub fn run(cmd: KernelCmd, store: &str) -> Result<()> {
     match cmd {
         KernelCmd::Stage { artefacto, esp, efivars, tries, state, dry_run } =>
             ab_stage(&artefacto, store, &esp, &efivars, tries, &state, dry_run),
+        KernelCmd::Kexec { artefacto, initrd, cmdline, load_only, jump } =>
+            kexec_cmd(&artefacto, store, initrd.as_deref(), &cmdline, load_only, jump),
         KernelCmd::BootStatus { efivars, state } => ab_status(&efivars, &state),
         KernelCmd::Confirm { esp, efivars, state } => ab_confirm(&esp, &efivars, &state),
         KernelCmd::Rollback { esp, efivars, state } => ab_rollback(&esp, &efivars, &state),
@@ -2120,3 +2144,42 @@ fn ab_rollback(esp: &Path, efivars: &Path, state: &Path) -> Result<()> {
     println!("el kernel estable sigue siendo el que estaba. No se tocó.");
     Ok(())
 }
+
+fn kexec_cmd(
+    artefacto: &str,
+    store: &str,
+    initrd: Option<&Path>,
+    cmdline: &str,
+    load_only: bool,
+    jump: bool,
+) -> Result<()> {
+    let (bz, nombre) = bzimage_de(artefacto, store)?;
+    println!("kexec: {nombre}");
+    println!("  kernel:  {}", bz.display());
+    match initrd {
+        Some(p) => println!("  initrd:  {}", p.display()),
+        None => println!("  initrd:  (ninguno)"),
+    }
+    println!("  cmdline: {cmdline}");
+
+    // Ojo: esto detecta si el SYSCALL existe, no si podemos usarlo. Un kernel con el flag puesto y
+    // un usuario sin privilegios pasa esta puerta y falla después con EPERM, que es lo correcto:
+    // mejor el error real del syscall que una sospecha nuestra.
+    if !kernel_ab::kexec_file_disponible() {
+        bail!(
+            "este kernel no implementa kexec_file_load (falta CONFIG_KEXEC_FILE).\n  \
+             Los kernels del corpus traen CONFIG_KEXEC —el syscall viejo— que exige armar los \
+             segmentos y el purgatory a mano, o sea kexec-tools entero.\n  \
+             La variante `recipes/linux-metal-kexec.toml` lo trae encendido."
+        );
+    }
+
+    kernel_ab::kexec_cargar(&bz, initrd, cmdline)?;
+    println!("✓ kernel cargado en memoria");
+    if load_only || !jump {
+        println!("  (no se salta: pasá --jump. El kernel queda cargado hasta el próximo reboot.)");
+        return Ok(());
+    }
+    println!("⚡ saltando — el userspace muere ACÁ. Esto no vuelve.");
+    kernel_ab::kexec_saltar()
+}
diff --git a/recipes/linux-metal-kexec.toml b/recipes/linux-metal-kexec.toml
new file mode 100644
index 00000000..5fca2fdd
--- /dev/null
+++ b/recipes/linux-metal-kexec.toml
@@ -0,0 +1,93 @@
+# linux-metal-kexec — VARIANTE de `linux-metal` cuya única diferencia es `CONFIG_KEXEC_FILE=y`.
+#
+# ── POR QUÉ UNA VARIANTE Y NO UN FLAG EN LA CANÓNICA ────────────────────────────────────────────
+# El `.config` ES la identidad del artefacto (SDD 22 §1): tocar `linux-metal` re-hashea el kernel
+# que hoy arranca las imágenes y el que reproduce bit a bit. El ADR 0017 deja esa decisión al
+# usuario, así que acá se paga el precio honesto —un artefacto más— en vez de mover el de todos.
+#
+# ── QUÉ DESTRABA ───────────────────────────────────────────────────────────────────────────────
+# Los seis kernels sellados traen `CONFIG_KEXEC=y`, que es el syscall VIEJO (`kexec_load`): recibe
+# los segmentos ya armados y el *purgatory* —el código que corre ENTRE los dos kernels—, o sea que
+# usarlo obliga a reimplementar kexec-tools entero.
+#
+# `kexec_file_load` invierte el reparto: se le pasan los **descriptores** del kernel y del initrd y
+# el trabajo lo hace el kernel. Son ~50 líneas en vez de miles, sin dependencias ajenas.
+#
+# Y de paso desata el nudo entre el ADR 0017 y el 0018: bajo *lockdown* —lo que trae Secure Boot—
+# el kernel RECHAZA `kexec_load` y sólo acepta `kexec_file_load`. Sin este flag, kexec y Secure Boot
+# no pueden coexistir.
+#
+# `-e CRYPTO_SHA256` va explícito porque `KEXEC_FILE` lo necesita para verificar la imagen y «al
+# azar del defconfig» no es un contrato.
+
+name    = "linux-metal-kexec"
+version = "6.16.12"
+license = "GPL-2.0-only WITH Linux-syscall-note"
+
+[source]
+tarball = "https://mirrors.edge.kernel.org/pub/linux/kernel/v6.x/linux-6.16.12.tar.gz"
+sha256  = "ffc6af80b014ddebd55e116aa29a9f7a5256c87a29a8a9dd97270b6d49625109"
+
+[build]
+compiler = "zig-cc"
+target   = "x86_64-linux-musl"
+link     = "dynamic"
+
+[deps]
+build = ["flex", "bison", "m4", "openssl", "elfutils", "make"]
+
+# SDD 25 §7-H1: `-e MEMCG -e PSI`. Sin MEMCG el fichero `memory.max` NO EXISTE y
+# `arje-incarnate::cgroup` sólo emite un `warn!` ⇒ la Card corre SIN tope de memoria. Va en la
+# fase configure porque el .config ES la identidad del artefacto (SDD 22 §1): esto re-hashea el
+# kernel a propósito. Comprobable con `takana kernel contract` sobre el config YA PRODUCIDO.
+[build.phases]
+configure = """
+make ARCH=x86_64 defconfig && \
+scripts/config -e KEXEC_FILE -e CRYPTO_SHA256 \
+  -d MODULE_SIG -d MODULE_SIG_ALL -d DEBUG_INFO_BTF -d DEBUG_INFO -d MODULES \
+  -d UNWINDER_ORC -e UNWINDER_FRAME_POINTER \
+  -e BLK_DEV_INITRD -e DEVTMPFS -e DEVTMPFS_MOUNT -e TMPFS \
+  -e OVERLAY_FS -e USER_NS -e NAMESPACES \
+  -e FANOTIFY -e FANOTIFY_ACCESS_PERMISSIONS \
+  -e OVERLAY_FS_REDIRECT_DIR -e OVERLAY_FS_INDEX -e OVERLAY_FS_XINO_AUTO -e OVERLAY_FS_METACOPY \
+  -e SECURITY -e SECURITY_LANDLOCK -e AUDIT -e IO_URING -e BPF_SYSCALL \
+  -e MEMCG -e PSI -d PSI_DEFAULT_DISABLED \
+  -e NTSYNC -d PREEMPT_VOLUNTARY -e PREEMPT -e HZ_1000 -e LRU_GEN -e LRU_GEN_ENABLED \
+  -e ZRAM -e ZSMALLOC -e EROFS_FS -e FS_VERITY \
+  -e VIRTIO -e VIRTIO_PCI -e VIRTIO_BLK -e VIRTIO_NET -e EXT4_FS \
+  -e PCI -e PCIEPORTBUS -e ACPI \
+  -e SATA_AHCI -e ATA -e ATA_PIIX -e SCSI -e BLK_DEV_SD -e BLK_DEV_LOOP \
+  -e NVME_CORE -e BLK_DEV_NVME \
+  -e USB_SUPPORT -e USB -e USB_PCI -e USB_XHCI_HCD -e USB_XHCI_PCI \
+  -e USB_EHCI_HCD -e USB_EHCI_PCI -e USB_OHCI_HCD -e USB_UHCI_HCD -e USB_STORAGE \
+  -e HID -e HID_GENERIC -e USB_HID -e INPUT_EVDEV \
+  -e INPUT_KEYBOARD -e KEYBOARD_ATKBD -e INPUT_MOUSE -e MOUSE_PS2 \
+  -e SERIO -e SERIO_I8042 -e VT -e VT_CONSOLE \
+  -e DRM -e DRM_SIMPLEDRM -e SYSFB_SIMPLEFB -e FB -e FB_EFI \
+  -e DRM_I915 -e DRM_FBDEV_EMULATION \
+  -e FRAMEBUFFER_CONSOLE -e FRAMEBUFFER_CONSOLE_DETECT_PRIMARY \
+  -e FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER \
+  -e EFI -e EFI_STUB -e EFI_PARTITION -e EFIVAR_FS -e CMDLINE_BOOL \
+  -e VFAT_FS -e FAT_FS -e MSDOS_FS -e NLS_CODEPAGE_437 -e NLS_ISO8859_1 -e NLS_UTF8 \
+  -e ISO9660_FS -e JOLIET \
+  -e WLAN -e WIRELESS -e CFG80211 -e MAC80211 -e RFKILL \
+  -e WLAN_VENDOR_INTEL -e IWLWIFI -e IWLMVM \
+  -e ETHERNET -e NET_VENDOR_INTEL -e E1000 -e E1000E -e IGB -e IGC \
+  -e NET_VENDOR_REALTEK -e R8169 -e NET_VENDOR_BROADCOM -e TG3 \
+  -e USB_NET_DRIVERS -e USB_USBNET -e USB_NET_CDCETHER -e USB_NET_CDC_NCM -e USB_NET_RNDIS_HOST \
+  -d DRM_AMDGPU -d DRM_NOUVEAU -d DRM_RADEON -d AGP \
+  -e SOUND -e SND -e SND_PCM -e SND_TIMER -e SND_HRTIMER -e SND_DYNAMIC_MINORS \
+  -e SND_PCI -e SND_HDA -e SND_HDA_INTEL -e SND_HDA_GENERIC -e SND_HDA_PATCH_LOADER \
+  -e SND_HDA_CODEC_REALTEK -e SND_HDA_CODEC_HDMI -e SND_HDA_CODEC_GENERIC \
+  -e SND_INTEL_DSP_CONFIG -e SND_SOC -e SND_SOC_INTEL_SOF_PCI_DEV \
+  -e SND_SOC_SOF_TOPLEVEL -e SND_SOC_SOF_PCI -e SND_SOC_SOF_INTEL_TOPLEVEL \
+  -e SND_SOC_SOF_TIGERLAKE -e SND_SOC_SOF_HDA_AUDIO_CODEC -e SND_SOC_SOF_HDA_LINK \
+  -e SND_USB -e SND_USB_AUDIO \
+  -d MEDIA_SUPPORT -d INFINIBAND -d BT -d NFC -d CAN \
+  -d WATCHDOG -d USB4 -d FIREWIRE -d DEBUG_WX \
+  -d XFS_FS -d BTRFS_FS -d F2FS_FS -d JFS_FS -d GFS2_FS -d NTFS3_FS && \
+scripts/config --set-str CMDLINE "console=tty0 console=ttyS0,115200 quiet loglevel=3 vt.global_cursor_default=0 efi=novamap split_lock_detect=off initrd=/initramfs.cpio.gz rdinit=/init" && \
+make ARCH=x86_64 olddefconfig
+"""
+compile = "make ARCH=x86_64 CC=gcc HOSTCC=gcc -j\"$(nproc)\" bzImage"
+install = "mkdir -p /out/boot && cp arch/x86/boot/bzImage /out/boot/bzImage && cp .config /out/boot/config-6.16.12-metal-kexec"