# How to Use Omarchy's Crash Diagnosis to Debug Segfaults With an AI Agent > Source: > Published: 2026-09-08 00:00:00+00:00 # How to Use Omarchy's Crash Diagnosis to Debug Segfaults With an AI Agent Omarchy watches systemd-coredump and hands crash dumps to your coding agent. Here's how the handoff works, the commands behind it, and how to mute noisy apps. ## How does crash diagnosis work in Omarchy? Omarchy monitors `systemd-coredump`, the service that captures a core dump when a program crashes. When one appears, you get a desktop notification. Clicking it hands the crash to your default coding agent along with a `diagnose-crash` skill that tells the agent how to read it. You can also invoke it directly for a process you already know crashed: ``` omarchy agent crash ``` And if an application crashes often enough that the notifications become noise: ``` omarchy crash mute hyprland ``` That silences notifications for the named program without disabling crash capture for anything else. For the wider context on what [Omarchy](/blog/what-is-omarchy-linux) is, start with the overview. ## TL;DR - **Omarchy watches `systemd-coredump`** and raises a notification when a program crashes. - **Clicking the notification sends the dump to your default agent** with the`diagnose-crash` skill attached. - **`omarchy agent crash ` triggers the same analysis manually.** - **`omarchy crash mute ` silences a chronically crashy application** while leaving the rest of the system reporting. - **The agent is whichever you set as default** with`omarchy default agent ` . - **This is the clearest example of Omarchy’s “agents as OS citizens” claim** — the operating system routes a failure to an agent without you assembling the pipeline. ## Why is this more than a shortcut? Because of what it removes, not what it adds. ## Remy is new. The platform isn't. Remy is the latest expression of years of platform work. Not a hastily wrapped LLM. Investigating a core dump on a conventional Linux desktop is not hard, but it is tedious enough that most people skip it. You have to notice the crash happened. Find the dump with `coredumpctl list`. Load it in a debugger. Get a backtrace. Work out which frame matters. Then decide whether it is your problem or an upstream bug. Every one of those steps is a place to give up, and the usual outcome is that a program crashes, you relaunch it, and nothing is learned. The crash was diagnosable; you just did not have twenty minutes. Omarchy collapses that into one click. The change is not that an agent reads a backtrace better than you would — often it will not. The change is that the analysis happens at all, on crashes you would otherwise have shrugged at. ## What does the agent actually receive? The dump, plus a skill that tells it what to do with one. The `diagnose-crash` skill is what makes this work reliably rather than occasionally. Handed a raw core dump with no instructions, an agent has to infer what kind of artefact it is looking at and which tools to reach for. The skill supplies that context — how to extract a backtrace, what to look for, how to present the result — so the analysis is consistent instead of depending on the model’s guess. This is worth noting for anyone evaluating “AI in the OS” claims generally. The integration is not a chat box with system access. It is a specific failure signal, routed to a specific handler, with instructions for that handler. That is ordinary software design, and it is why the feature works rather than being a demo. ## Which agent handles the crash? Whichever one is your default. Omarchy pre-wires ten agent CLIs and routes crash diagnosis to the selected one, so: ``` omarchy default agent claude ``` also changes who investigates your segfaults. The same setting governs the `Super + Shift + Ctrl + A` keybinding and the usage panel in the top bar. This is a genuine reason to think about the default rather than leaving it wherever it landed during setup. Crash diagnosis is a task where model capability matters — reading a backtrace and reasoning about memory state is harder than most day-to-day agent work — so the agent you would pick for quick edits may not be the one you want here. ## When should you mute an application? When it crashes predictably and you have already decided not to fix it. ``` omarchy crash mute hyprland ``` The honest use case is a known upstream bug you are waiting on. A program that crashes on exit, or on a specific unsupported file, generates a notification every time and quickly trains you to dismiss notifications without reading them — which is worse than having none, because you will dismiss the important one too. Muting is per-program, so the rest of the system keeps reporting. It suppresses the notification rather than the capture, so the dumps still exist if you later want to investigate. The thing to avoid is muting something because it is noisy *today* and forgetting you did; a muted program that starts crashing for a new reason tells you nothing. ## Frequently Asked Questions ### What is systemd-coredump? ## Remy doesn't write the code. It manages the agents who do. Remy runs the project. The specialists do the work. You work with the PM, not the implementers. It is the systemd component that catches a crashing process and writes its memory state to disk as a core dump. Omarchy watches it rather than implementing its own crash capture, which means it inherits standard Linux behaviour and the dumps remain readable by ordinary tools like `coredumpctl`. ### How do I manually run crash diagnosis in Omarchy? Run `omarchy agent crash `, substituting the process ID of the crashed program. This performs the same analysis the notification triggers, which is useful when you dismissed the notification or want to re-run it. ### How do I stop crash notifications for one program? Use `omarchy crash mute ` — for example `omarchy crash mute hyprland`. Other programs continue to report normally. ### Does crash diagnosis send my data anywhere? The dump is passed to whichever agent you have configured, and those agents call their providers’ APIs. A core dump can contain whatever was in the program’s memory, so treat it as you would any other data you send to a model provider. If that is a concern for a particular application, mute it or use a locally-hosted agent. ### Can I change which agent diagnoses crashes? Yes. It follows your default agent, set with `omarchy default agent ` or through Setup › Defaults › Agent in the Omarchy Menu (`Super + Space`). ### Does this work for crashes in my own code? Yes, provided the crash produces a core dump that `systemd-coredump` captures. It is not limited to bundled applications — anything that segfaults on the system is eligible, which makes it useful when developing native code.