The Music Was Generated. My Workbench Still Could Not Deliver It.

The music had already been generated. My workbench still couldn’t deliver it.

That distinction saved me from pressing the most tempting button in any failed job: run it again. The remote output existed. Starting another generation would’ve repeated the expensive stage while leaving the delivery bug intact.

On October 12, 2026, I connected a local music workbench to ACE-Step through ComfyUI. The end-to-end check produced one 20-second candidate. It also exposed three problems around process detection and file recovery before the candidate reached the player.

This wasn’t a benchmark of music quality. I was checking whether a job could survive the space between “the GPU finished” and “I can listen to the result.”

My job had more than one finish line

The workbench kept its catalog and player on one machine. Generation ran on another. AI assisted with the worker code; I reviewed the implementation against the recorded job and the actual output.

I needed to distinguish submission, generation, retrieval, processing, registration, and notification. One label saying “failed” couldn’t tell me which of those to repeat.

The concrete delivery failure came from a Windows output subfolder using backslashes. My path-allowance check rejected the representation. Generation had succeeded, but the next stage couldn’t retrieve the file through that path.

The correction normalized the folder representation and restricted recovery to the expected job and filename. The file came back through an allowed SSH/SFTP path. I didn’t solve a path check by accepting arbitrary remote paths.

The other two problems looked like missing processes

A Windows process-start check compared UTC and local time without bringing both to the same basis. The recorded raw comparison was false. Converting both sides to UTC made the comparison true.

Another query returned one CIM object. My check expected a collection count, but that object’s Count was null. The corresponding array count was one.

Neither observation meant the process hadn’t started. They meant my evidence-handling code couldn’t recognize what had started.

Boundary What the October check found Correction recorded
Process start time UTC/local comparison rejected the match Compare on one time basis
Process query shape One object had a null count Preserve collection shape
Output retrieval Windows subfolder representation failed validation Normalize, then validate the allowed path
Processing retry Original generated output was available Reuse it without another generation

I haven’t measured how common any of these failures are. This table describes one integration, not a failure-rate survey.

The retry had to keep its identity

My recovery rule was to preserve the job’s generation identity before submitting work. After an uncertain response, I’d inspect the existing job rather than immediately create another.

The isolated recovery check recorded one submission and two inspections. It also checked that a busy GPU didn’t receive a new submission, and that completion wasn’t announced before the work finished.

That’s different evidence from the real audio run. In that run, the original prompt identifier and seed stayed the same. The record contained one remote FLAC output, and processing completed by reusing it. Recovery worked after the studio process had shut down.

I didn’t rerun the GPU workload to write this article. I’m reporting the preserved October checks.

I checked the player, too

A completed metadata row wasn’t enough. The browser check opened the finished candidate and observed playback advancing: 1.377 seconds, then 1.915 seconds after switching views. There was one audio element, and playback wasn’t paused.

The delivered candidate was 20 seconds long. Its full decode check passed. That proved the recovery path reached something the player could consume.

It didn’t prove the music was good. It didn’t validate its beat grid, first beat, or suitability for a game chart. Those remained separate review steps.

I’d already learned another delivery lesson from MP3 true-peak checks. Here the question came earlier: could I recover the same artifact instead of generating another one?

Don’t turn every failure into a new generation

I wouldn’t retry the whole pipeline because a notification failed. The isolated notification check kept the music complete and retried only the message.

I wouldn’t infer “nothing happened” from a missing response either. If both history and output are unavailable, my worker leaves the result unresolved. It doesn’t have evidence for success, and it doesn’t have evidence that resubmitting is harmless.

This isn’t an exactly-once guarantee across every possible crash. I tested specific recovery cases and one real candidate. I didn’t test every network partition or storage failure.

The useful result was narrower and practical. A failed delivery didn’t force me to throw away a successful generation. I could say what had finished, what hadn’t, and which stage needed another attempt.

Similar Posts