apple-crash-rca-8b

A compact 8B model that performs root-cause analysis of Apple crash reports. Given a report, it explains why the process crashed and how the failure propagated, following the sequence of environment, trigger, mechanism, propagation, and termination. It runs locally, either as full-precision weights with Transformers or as a 4-bit MLX build on Apple Silicon.

How it works

The model is specialised for the crash and diagnostic forms described in Apple's developer documentation, such as watchdog terminations, jetsam and memory-pressure kills, EXC_BAD_ACCESS, EXC_RESOURCE, EXC_GUARD, Swift runtime traps, kernel panics, spindumps, application hangs, etc. It learns to read each form in the platform's own terms and to connect the visible signals in a report to the underlying cause.

The training set is built by distillation with a verification gate. A frontier model generates synthetic crash cases that span the Apple taxonomy, seeded from the structure of a small set of real reports (redacted, and used only for their shape) so the cases match the layout of genuine diagnostics. Each generated case includes an analysis. However, it is only admitted into the training set after a verification step confirms that the analysis is supported by visible evidence and rejects anything that overreaches. This verified synthetic construction is what makes the approach work. It distils the analysis behaviour of a much larger model into a compact one, at a data scale a small set of real reports could never supply, while keeping every training target checkable rather than merely plausible. Qwen3-8B is then fine-tuned over this set with QLoRA, across several seeds to confirm the behaviour is stable. More detail on this methodology, together with metrics, may be released in the future, and this card will be updated accordingly.

In practice, the model has proven to be very capable in this area, despite its compact size. On real crash reports it returns valid structured analysis about 95% of the time and identifies the correct mechanism about 75% of the time. It reads several input shapes, including Apple .ips JSON, classic text, Markdown, and dirty copy-paste, and it declines input that is not a crash report rather than inventing an answer. It does not overtake frontier models, matching them on clearer reports and falling short on the more ambiguous ones, where it can reach past the evidence, but for a model this small it is a fast, local and reliable first pass that a researcher then confirms.

Files

• model.safetensors with config.json and tokenizer at the repository root, the full-precision weights in standard Transformers format for any platform.
• mlx-4bit/, the 4-bit quantised build for MLX on Apple Silicon, for fast local inference on a Mac.
• adapters/seed1, adapters/seed2, adapters/seed3, the three LoRA adapters from the training runs. Seed 2 is the released model and is the one merged into the weights above, the other two are provided for completeness.

Usage

Paste a crash report on its own, or wrap it in the instruction below for the most consistent results. A small robustness layer was included during training, so the model also handles a report given directly, formatted in Markdown, or dirty copy-pasted, whether it is Apple .ips JSON or classic text.

You are an Apple crash-analysis expert. Given the diagnostic report, explain why the crash occurred and how it propagated, grounded only in visible evidence. Use UNRESOLVED where the evidence does not license a specific cause. Respond in the required JSON schema.

### Report
<paste the crash report here>

### Analysis

Two ways to run it:

1. In any chat interface. Load the full-precision weights with Transformers, or the MLX build in a local chat application, then send one message containing the instruction above followed by the crash report. Send the whole report as a single message rather than line by line.
2. On a Mac, with the included script. apple_crash_rca.py wraps the prompt and prints the JSON analysis:

python apple_crash_rca.py crash.ips --model mlx-4bit --pretty

To check behaviour, pass a normal crash report and confirm a structured analysis, then pass a short non-crash message and confirm the model declines it.

License and provenance

The model is released under Apache 2.0, matching its base model Qwen3-8B (no naming requirement).

The training data was produced by distilling DeepSeek V4 Pro, whose license explicitly permits using its outputs to train other models, and that permission is what makes the distillation here allowed.

A limited set of real Apple crash reports, collected via private research, was used only to seed and shape the structure of the synthetic data. Those reports were redacted before any use, they never appear in the training data.