-
-
Dashboard 2
-
Dashboard 1
-
Home
Inspiration
I'm a music producer myself, and my workflow was scattered everywhere. I'd be working on a beat in my DAW, then switch to Spotify to check how a reference track sounds, then open Freesound to hunt for samples, then Google "how to sidechain in FL Studio" for the hundredth time. Meanwhile, half-finished projects piled up because nothing was reminding me to go back to them.
The thing that really pushed me was mix feedback. Getting a professional opinion on your mix costs real money, and most bedroom producers just guess. They export a track, play it in the car, and hope. I kept thinking — the tools to actually measure a mix exist, they're just locked away in expensive plugins and mastering studios.
Slack felt like the right home for this because producers already collaborate there — sharing bounces, arguing about the kick, planning EPs. So I asked: what if the workspace where producers already talk could also analyze their music, find their samples, teach their DAW, and keep their projects on track?
What it does
Wavmind is an AI music production agent that lives entirely inside Slack. You just talk to it — no commands to memorize.
Real audio analysis. Upload any MP3 or WAV and Wavmind measures it — actual LUFS loudness, stereo width, low/mid/high frequency balance, and vocal clarity. These are real signal-processing measurements, not an LLM guessing what your track probably sounds like. The AI then interprets those real numbers into feedback a producer can act on.
Track comparison. Upload your beat, then upload the song you're trying to sound like. Wavmind compares the measurements side by side, flags every gap (louder, wider, brighter), and gives specific fixes — EQ ranges, compression moves, real plugin names.
Natural language everything. DM it "find piano samples" and it searches 500K+ Creative Commons sounds from Freesound. "Teach me FL Studio" starts DAW Guru, which learns your skill level and sends personalized daily lessons. "What's new in trap" pulls fresh Spotify releases. Plain sentences, no syntax.
It works while you're away. Upload a track and Wavmind DMs you a check-in 24 hours later asking if you've worked on it. Daily DAW lessons arrive every morning at 9am. Weekly production reports land every Monday. Project tracking nudges you on unfinished tracks. It's an agent that follows up, not a chatbot that waits.
Team collab sessions. In a shared channel, teams can log ideas, notes and decisions on a track, then get an AI summary of the whole session — like meeting notes for music.
Beyond Slack. Wavmind ships with an MCP server and a bridge for Claude Desktop, so the same tools — sample search, mix analysis, DAW help, artist comparison — work from any MCP-compatible client.
How we built it
The core is a Node.js app built on Slack's Bolt framework with Socket Mode, deployed on Railway. It handles everything Slack throws at it — messages, 37+ interactive button handlers, slash commands, file uploads, the App Home tab, and app mentions.
The audio engine is a separate Python pipeline using librosa and pyloudnorm. When a file lands in Slack, the Node app downloads it and spawns the Python analyzer, which returns measured LUFS, mid/side stereo ratio, spectral band energy, and a presence-band vocal clarity estimate as JSON. That measured data then gets fed to Groq (running Llama) with the instruction to interpret real numbers — which produces dramatically better feedback than asking an LLM to imagine what a track sounds like.
Around that core: Spotify's API powers reference lookups, artist comparisons and genre-based new releases. Freesound's API powers sample search, with a page-rotation trick so repeat searches return different results every time. Tavily adds real web results to DAW tutorials.
The autonomous layer is a scheduler that checks a persistent reminder queue, fires 24-hour follow-ups after uploads, sends DAW Guru lessons daily, and compiles weekly digests — all surviving restarts through file-based state.
Finally, the MCP layer: the Railway app exposes an HTTP tool-execution endpoint, and a small local bridge script translates Claude Desktop's JSON-RPC stdio protocol into calls against it. Six tools, usable from any MCP client.
Challenges we ran into
Honestly, this project nearly broke me a couple of times.
The crash loop. Early on, the app kept dying on Railway in an endless restart cycle. The logs pointed to two separate killers: Slack rejecting Home tab blocks with empty field text, and a socket-mode reconnection bug where a dropped connection threw an uncaught exception that took down the whole process. Fixing it meant rebuilding the Home tab rendering and adding process-level crash guards so one bad event could never kill the agent again.
Python packaging on Railway. Getting librosa and pyloudnorm installed inside Railway's environment fought me hard — externally-managed-environment errors, missing soundfile dependencies, silent scan failures where Slack just... said nothing. I learned to read deploy logs line by line and to always make failures loud instead of silent.
The day I broke production. At one point a big update crashed the deployed app entirely, and I was debugging from my phone where I couldn't even edit code on GitHub. The save was Railway's rollback — redeploying a 3-day-old build got users working again while I fixed the new version properly from a laptop. Lesson burned in: get stable first, add features second.
Slack's invisible walls. The bot worked perfectly in DMs but was completely silent in channels — turned out mentions and plain messages need entirely different OAuth scopes, and missing channels:history means Slack never even delivers channel messages to your app. And Spotify deprecating their audio-features endpoint mid-build forced a redesign of how reference track data gets assembled.
Tiny bugs, invisible failures. A single typo — calling trackName() as a function when it was a string — made the collab note feature fail silently: data saved, but no confirmation ever appeared. Finding it required tracing why a feature "worked but didn't respond," which taught me more about Slack's error-swallowing than any tutorial.
Accomplishments that we're proud of
The analysis is real. Most AI music tools ask an LLM to imagine your mix. Wavmind actually measures it — the LUFS number on screen came from pyloudnorm processing your actual audio. Building a working signal-processing pipeline inside a Slack bot, on a hackathon timeline, is the thing I'm proudest of.
It's genuinely autonomous. Wavmind initiates. It checks in on your tracks, delivers lessons before you ask, and reports on your week. That's the difference between an agent and a chatbot, and it works reliably across restarts.
No commands required. After watching how confusing command syntax gets, I built natural language routing so "find me some drum loops" just works. The whole app is also navigable by buttons alone — a producer can use every feature without typing a single slash command.
It survived its own disasters. The app that exists today went through crash loops, broken deploys, and a full production rollback — and came out with crash guards, friendly error states, and persistence that survives restarts. It's battle-tested in a way a first draft never is.
It reaches beyond Slack. The MCP integration means Wavmind's tools work inside Claude Desktop too — one backend, multiple AI surfaces.
What we learned
Real data beats clever prompts. The single biggest quality jump came from feeding the LLM measured numbers instead of asking it to guess. Ground your AI in real inputs and everything downstream improves.
Silence is the worst bug. Nearly every hard problem in this build showed up as "nothing happened" in Slack — swallowed exceptions, missing scopes, failed spawns. I learned to make every failure visible: loud logs, friendly error messages, never a dead end for the user.
Stability before features. I broke a working app by shipping too much at once. Rollback saved me, but the real lesson is deploy small, verify, then build.
Platform details are the product. OAuth scopes, event subscriptions, Block Kit's empty-string rules, socket reconnection behavior — the difference between "demo" and "works" lives entirely in these details.
Users don't memorize; design for it. Natural language routing and button-first navigation came directly from asking "how will anyone remember all this?" The honest answer — they won't — became a feature.
What's next for WAVMIND
Proper persistence. The demo uses file-based storage; the next step is Postgres so projects, profiles and history survive anything.
Deeper analysis. BPM and key detection from the audio itself, dynamic range measurement, and per-section analysis (does the drop actually hit harder than the verse?).
Reference matching by URL. Paste a Spotify link as your reference instead of uploading a file — Wavmind fetches, analyzes, and compares automatically.
Team analytics. Extend collab sessions into full project dashboards: who contributed what, how the mix evolved across versions, and release-readiness scoring for the whole EP.
More surfaces. The MCP layer already proves the tools travel — Discord, a web dashboard, and DAW plugins that talk to the same backend are all natural extensions.
The long-term vision stays the same as day one: every bedroom producer deserves the feedback loop that used to require a studio budget — right inside the place they already work.
Log in or sign up for Devpost to join the conversation.