Foundry Turns Stable Audio Into a Drum Machine. Its Two-Second Pads Sit Outside the Model's Own Minimum Length.

A free, notarized macOS drum machine that renders every pad from a local Stable Audio 3 checkpoint, why it exports straight into Ableton, and the one number in Stability's own config file that should make you test it before you trust it.

Foundry is a 16-pad drum machine where every pad is a text field. You type "tight room snare, close mic, short decay" and the pad renders its own sample on your Mac's GPU, offline, in a couple of seconds. No account. No API key. The card says "none" under Network. The weights are inside the 3.39 GB download.

That is already a more interesting object than most of what gets called an AI music tool, because it is not a website with a generate button. It has choke groups, a pitch envelope per pad, MIDI in over CoreMIDI on notes 36 through 51, and it exports an Ableton .adg Drum Rack with a DrumCell on every pad already mapped to its note. Somebody who makes instruments made this.

And there is a number in it that does not line up. Foundry generates two seconds by default, clamped between one and three. The checkpoint it runs is stabilityai/stable-audio-3-small-sfx, which is a finetune of stable-audio-3-small-sfx-base, and the base repo ships a config file that sets min_length to 256 latent frames. At 44.1 kHz with a downsampling ratio of 4096, one latent frame is about 93 milliseconds, so 256 frames is 23.8 seconds. Foundry's default pad is roughly twenty-one frames, about eight percent of that.

I should say up front what I could and could not check. Stability gates the finetuned repo, so its own model_config.json is not fetchable and I am reading the base model's config. A finetune can move that setting. What follows is a question worth asking, not a verdict.

I want to be careful about what that does and does not mean, because the honest version of this is more interesting than the accusatory one.

Who made it, and why that changes how you read it

Foundry comes from Petals, which is Sheryar Hyatt, and Petals' main product is Folium, a microtonal FM synthesizer that sells for eighty dollars as a VST3 and CLAP plugin. Folium's whole premise is that a tuning should be a material rather than a pitch chart: load a Scala file and the oscillator ratios come straight from your scale's intervals. The filters go further if you ask them to. Click the petal mark beside a cutoff knob and that filter quantizes to the loaded tuning, landing only on in-scale partials of the note you played, and past 70% resonance it self-oscillates on that degree. That part is opt-in per filter rather than automatic.

That context matters, because it explains Foundry's odd feature list. In his own journal entry, which the full page dates September 1 while the site's own journal index dates it September 2, published under a page that carries an explicit "not affiliated with, sponsored by, or endorsed by Stability AI" disclaimer, Hyatt writes that when Stable Audio arrived he had a simple question: "What would it feel like as an instrument?" He describes Foundry as "a drum machine that dreams up its own sounds from a small model, then lets me tune and sculpt each one into a kit I can play," and says the core interface with the model is "a surface you can move around to shape the sound (a bit like a traditional synthesizer)."

So the tuning support in a drum machine is not a gimmick. Foundry ships 12-TET, KORA PYTH 7, JUST 27 and PYTH 31, and it will load any .scl file. It detects the pitch of a generated sample and shifts it onto the scale degree. That is a synth designer's instinct applied to a generative model, and I have not seen anyone else do it.

There is a second instrument in that journal entry worth knowing about. Bloomscroll is described as a focus synthesizer that reads your local weather and the moon's phase, uses a gen/RNBO synth for pure intonation chords, and routes slowed-down Stable Audio generations through a resonant filter tuned to those same chords. It never blooms the same way twice, and it is free to listen to. Somebody at Music Hackspace in Montreal called it a lamp, which Hyatt says he loves. Two instruments, same experiment.

The mechanism, and where the surface lives

Each pad is an independent generation at a fixed operating point: eight steps, CFG scale 1.0, two seconds, fp32 on MPS with a CPU fallback, sample rate from the model at 44100. The bundled runtime is CPython 3.12 with PyTorch and torchaudio, driven by a uvicorn sidecar on localhost, and the front end is a Next.js static export inside a Tauri 2 shell. The app is signed with a Developer ID under team 6X9YTXU3M9 and notarized with the ticket stapled, which is more distribution hygiene than most one-person Mac releases bother with.

The morph pad is the part that earns the word instrument. Four corner prompts, blended bilinearly, so instead of generating "brushed snare" and "gated snare" as two separate takes you move around a continuous field between them and pull out whatever sits at a given coordinate. That is the "surface you can move around" from the journal entry, and it is a genuinely different interaction model from a prompt box with a re-roll button.

Then there is a retry rule that tells you the author actually used this thing in anger. Three attempts, triggered by a spectral-flatness floor of 0.55. Spectral flatness measures how noise-like a signal is: a pure tone sits near zero, white noise sits near one. The card says "floor" and nothing else, so read the direction as my inference rather than the author's statement. A floor most naturally means Foundry rejects and re-rolls output whose flatness comes in under the threshold, which would be a numeric way of saying "that came back as a hum, not a drum." For percussion, where broadband transient energy is the point, that is a sensible reject condition to automate. The card does not spell it out either way, and it should.

Export closes the loop. Twenty-four-bit WAV per pad in a STORE zip, and the .adg Drum Rack with per-pad DrumCell mapping. Rendering runs through OfflineAudioContext using the same buffer and effects graph as playback, so the file you export is the sound you auditioned. That last detail is not glamorous and it is the thing that most often goes wrong in home-built audio tools.

The number that should make you test before you trust

Now back to the length question, because I think it is the most useful thing anyone can tell you about this app.

I pulled model_config.json from stabilityai/stable-audio-3-small-sfx-base, the ungated base repo that Foundry's bundled checkpoint is a finetune of. The finetuned repo is gated, so this is the closest readable config rather than the exact one. Three fields matter. sample_rate is 44100. The autoencoder's downsampling_ratio is 4096. And under the diffusion block, distribution_shift_options reads {"type": "full", "min_length": 256, "max_length": 4096}. Do the arithmetic and 256 frames is 23.78 seconds, 4096 frames is 380.4 seconds. Those are the endpoints the model's own schedule was set up around.

Independently, and this is the part that turns arithmetic into a question, somebody converting the same checkpoint family to Apple's Core AI format published a measurement of what happens below that floor. Their card is blunt about it: generate at 256 latent frames or longer, because below that the output "picks up gross high-frequency content," and they measured 16 to 27 percent of total energy landing above 10 kHz against roughly 1 percent for correct output. They list that alongside two other non-optional settings, including a warning that using an Euler sampler on this rectified-flow model drives output to +7.8 dBFS and squeezes about 10 dB out of the gap between its loudest and quietest moments.

So here are three facts sitting next to each other. The base config declares a 23.8-second minimum. Foundry generates two. And Foundry ships an automatic re-roll keyed to a spectral statistic.

I am not going to tell you those are the same fact, because I cannot prove it and neither can anyone else right now. There is a real argument that Foundry found the exception. Percussion is the one content class where extra high-frequency energy is not obviously a defect. A snare is broadband noise. A hi-hat is mostly energy above 10 kHz by design. If you are going to violate a minimum-length constraint on a generative audio model, one-shot percussion is the smartest possible place to do it, and a synth designer would know that.

What I am saying is that nobody has published a spectral comparison of Foundry's two-second pads against the same prompts generated at 24 seconds and trimmed, and until someone does, "the model is being run an order of magnitude outside its declared range" is an open question rather than a settled one. Foundry's card also does not name which sampler it uses, which matters given the Euler warning above.

Put this into practice

The fastest path to a usable kit is about fifteen minutes.

1. Download and open it. Grab Foundry.dmg from petalsfm/foundry. It is 3,391,504,096 bytes and Apple silicon only. Because it is signed and notarized you will not have to fight Gatekeeper. There is no signup and no network call after the download.

2. Write four prompts, not sixteen. Kick, snare, closed hat, open hat. Be physical rather than genre-ish: "dusty vinyl kick, short tail" gets you further than "lo-fi hip hop drums." The model underneath is Stability's sound-effects tier, so it responds to descriptions of objects and rooms.

3. Set the choke group on your hats before anything else. Put the closed and open hat in the same group so they cut each other. This is the difference between a kit and sixteen unrelated samples, and it takes ten seconds.

4. Run the A/B that nobody has run. Generate a pad at the default two seconds. Then generate the same prompt at the three-second maximum. Drop both into any spectrum analyzer you already own and look above 10 kHz. If the two-second version carries visibly more energy up there than the three-second one, you have found the tail of the min-length effect and you now know to write longer prompts for cymbals and shorter ones for kicks. If they look the same, Foundry has answered the question in its favor and you should say so publicly.

5. Use the morph pad for one sound, not for exploration. Pick your snare. Put "tight room snare" and "gated eighties snare" on two corners, "brushed snare" and "clipped digital snare" on the other two, and walk the surface. This is where the app stops feeling like a generator.

6. Export the .adg and open it in Ableton. Every pad arrives mapped to its note. If you are not in Ableton, take the 24-bit WAVs and load them into whatever sampler you use; the note mapping is notes 36 to 51 in order.

The whole loop costs nothing per generation, which changes how you work more than any single feature does. Nobody auditions two hundred snare variations at a nickel apiece. Everybody does it when it is free and the machine is right there.

Honest limitations

Two seconds, maximum three. This is percussion, one-shots and short stabs. It is not a loop generator, it is not a pad generator, and there is no path to either inside the app.

Apple silicon only. No Intel Mac, no Windows, no Linux. The fp32-on-MPS choice makes that non-negotiable rather than a packaging convenience.

The licence is not as free as the download. Foundry's own source is MIT, and its NOTICE file is careful to state that the weights are redistributed unmodified and that no derivative work of the model was created. But the bundled weights carry the Stability AI Community License, which is free for research, non-commercial and limited commercial use, asks you to register with Stability for commercial use, and terminates above one million dollars in annual revenue. The T5Gemma text conditioner inside the checkpoint adds the Gemma Terms of Use on top, including their prohibited use policy. Both texts ship inside the app bundle at Foundry.app/Contents/Resources/resources/. Installing Foundry means accepting both. Read them if you are selling sample packs.

You are getting the model through a side door. Stability gates stable-audio-3-small-sfx on Hugging Face behind a registration form. Foundry ships the same weights ungated inside a .dmg. Redistribution with attribution is what the Community License permits and the NOTICE does it properly, so this is legitimate. It does mean the practical effect of Stability's gate is now optional, and that is worth knowing rather than pretending otherwise.

The sampler is unstated. Given a published measurement that Euler on this rectified-flow family clips output by nearly 8 dB, "which sampler does Foundry use" is a question the card should answer and does not.

No published quality evaluation exists. Not from Petals, not from anyone. There are no A/B samples, no spectra, no comparison against the same prompts run through stable-audio-tools at the documented operating point. The retry-on-flatness rule is the only quality gate anyone has described, and it catches one specific failure shape.

What I would actually do with it

I would use Foundry for percussion and texture and stop there. The two-second ceiling is not a bug to work around, it is the shape of the tool, and the shape matches what a drum machine is for.

The larger thing I keep turning over is the design question Hyatt actually asked, which is not "can a model make a drum sound" but "what would it feel like as an instrument." The answer he arrived at involves a morph surface, a Scala file, choke groups and a .adg export, and almost none of that is about the model. It is about everything wrapped around the model. That seems right to me, and it is the opposite of how most generative audio products are built, where the model is the product and the interface is a text box with a spinner.

The open question is whether a fixed operating point counts as a design decision you are allowed to hide. Foundry's eight steps at CFG 1.0 for two seconds is a choice made once, on your behalf, that you cannot see or change, and it sits well outside the range its base checkpoint's configuration declares. Maybe that is fine and percussion is the exception that proves it. Maybe it explains something you would hear on a hi-hat if you listened for it.

Somebody with a spectrum analyzer and twenty minutes can settle that. If you run the comparison in step four, I want to see the plots.

---

Medium metadata

Recommended reading time: 8 minutes

Primary sources:

• Foundry model card and download: https://huggingface.co/petalsfm/foundry
• Foundry NOTICE (licence chain): https://huggingface.co/petalsfm/foundry/raw/main/NOTICE.txt
• Petals journal entry, "Designing instruments for small diffusion models": https://petals.fm/journal/designing-instruments-for-small-diffusion-models/ and https://stability.petals.fm
• Checkpoint config with min_length: https://huggingface.co/stabilityai/stable-audio-3-small-sfx-base/raw/main/model_config.json
• Upstream checkpoint: https://huggingface.co/stabilityai/stable-audio-3-small-sfx
• Core AI conversion card with the below-minimum measurement: https://huggingface.co/arraypress/stable-audio-3-small-sfx-coreai
• Folium (for Petals' instrument-design context): https://petals.fm/