ERA OF MINDS

What is earshot? Give Claude Code ears to hear and make sound effects

By Era of Minds ·

Short answer

earshot is a free, MIT-licensed tool by Leon Lin (@LexnLin / Leonxlnx) that gives Claude Code and other coding agents ears. It turns an audio file into evidence an agent can reason about: what it sounds like in words, how well it fits a description, where each sound lands against the video cuts, and a scorecard against 7 professional launch films. It can also make sound effects in code (earshot forge) and, since v0.2 on October 16, 2026, turn a recording into code (earshot fit). Runs locally on CPU as a CLI, Python API and MCP server. The launch post on X had about 117,900 views and 3,087 bookmarks when we checked on October 17.

Era of Minds cover: ‘AI agents can hear now.’ earshot v0.2 open-source audio tool by Leonxlnx, with an earshot sheet of its launch film.
Figure: the earshot sheet of its own 22-second launch film (frames, labelled sound events, spectrogram, loudness, sync), from the Leonxlnx/earshot README (MIT).

What is earshot for Claude Code?

Coding agents can now write the code that renders a product demo, a game or a launch video. They still can't hear the result. Ask Claude Code for a satisfying click and it can ship one that pops, clips or lands late, with no way to check.

That's the gap earshot goes after. The README puts it plainly: an agent can't tell a premium key press from a cheap one, notice that a hit lands 80 ms after the cut, or hear that the music swells in the wrong place. earshot gives it numbers and words instead: tags with confidence scores, loudness in LUFS, event timestamps and sync markers against the picture.

Leon Lin introduced earshot on X on October 15, 2026 (UTC) with a simple pitch: "Opus 5.5 can build a whole launch video in code but still produces sloppy sfx." Every sound in his 22-second launch film was made in code by earshot forge, with no recordings and no music track. When we checked on October 17 that post had about 117,900 views, 2,684 likes and 3,087 bookmarks. v0.2 followed a day later (about 12,400 views and 387 bookmarks). The repo, created October 15, had 409 stars and 25 forks on the morning of October 17. Leon is the same developer behind Taste-Skill.

What can earshot do?

Each command prints a plain-language summary first, and --json returns the full result for the agent. The main ones, per the README:

  • describe FILE: what the sound is, as calibrated tags (for example "a single mechanical keyboard key press, z +5.4") plus AudioSet labels and measurements.
  • match FILE "description": does it fit what you asked for? Returns a verdict (strong, plausible, weak, no match).
  • rank and find: pick the best of many downloaded files, or the best moments inside a long recording as start/end trims.
  • realness: real recording or code-synthesized, with per-window scores.
  • timeline and sheet: a second-by-second listening transcript of a whole film, and an annotated PNG (frames, events, spectrogram, loudness, sync) for agents that read images. The cover above is one of these sheets.
  • critique FILE --video V: a launch-video scorecard against a profile of 7 professional launch films, with timestamped fixes.
  • measure: model-free numbers only: LUFS, true peak, loudness range, spectrum, tempo and key.
  • forge, fit and gallery: make sounds in code, turn recordings into code, and build one HTML listening page of the results.
  • mcp: the same tools as an MCP server for Claude Code and other agents.

How do you install earshot and connect it to Claude Code?

You need Python 3.10 or newer and ffmpeg/ffprobe on your PATH. No GPU. From the README:

git clone https://github.com/Leonxlnx/earshot && cd earshot
python -m venv .venv
.venv/bin/python -m pip install torch --index-url https://download.pytorch.org/whl/cpu
.venv/bin/python -m pip install -e ".[mcp,llm,dev]"
.venv/bin/python -m earshot doctor --load

On Windows, swap .venv/bin/python for .venv/Scripts/python. The first model use downloads two open models, about 1.4 GB in total: CLAP laion/larger_clap_general for text-audio matching and the AudioSet tagger MIT/ast-finetuned-audioset-10-10-0.4593. After that, earshot works offline.

Then register the MCP server so Claude Code can call it:

claude mcp add earshot --scope user -e EARSHOT_THREADS=3 -- /path/to/earshot/.venv/bin/python -m earshot mcp

Use the MCP route if you plan more than a couple of calls. Each CLI call is a fresh process that loads the models first, which takes roughly 20 to 40 seconds; the MCP server keeps them warm, so repeat calls take seconds. On a slow machine, start Claude Code with MCP_TIMEOUT=60000.

Last step: the repo ships two agent skills. Copy or symlink skills/earshot (which command answers which question, and when not to trust a verdict) and skills/real-sound (a full process for soundtracks built from licensed recordings) into ~/.claude/skills/. The earshot skill is also listed on skills.sh with npx skills add https://github.com/leonxlnx/earshot --skill earshot, but it still needs the Python install above to do anything.

What's new in earshot v0.2?

Version 0.2.0 landed on October 16, 2026 (per the changelog) with two big additions.

earshot fit: audio to code. Give it a recording and it fits a small synthesis model until the render matches, then writes a Python recipe whose render() re-creates the sound. The file stores the structure of the sound, not its samples, so you get new takes, knobs for size, damping, pitch and decay, and morphs between two recordings. On 12 real recordings the README reports a median CLAP cosine of 0.945 between recording and render (minimum 0.881) and the same top describe tag in 10 of 12.

earshot fit click.wav -o made/click_fit.py --report
python made/click_fit.py 3 take3.wav
earshot fit --morph a.wav b.wav --amount 0.5 -o made/ab_morph.py

forge v2. Recipes now come as 34 motion-design categories (whooshes, risers, impacts, sub drops, logo stings, clicks, toggles, notification dings, glitches, key presses and more), 16 of them modelled on designed effects from professional launch films, with 4 to 6 variants each. Leon's follow-up post counts 183 sounds, all made with code. Re-scored with v2 sounds, the launch film went from 16 to 19 of 22 critique metrics in range, and cues with an onset within one frame went from 86% to 98% of 43.

How accurate is earshot?

The repo backs each number with the command that produced it in docs/VALIDATION.md. The highlights:

  • Matching descriptions on a held-out library of 125 real recordings: a "strong" verdict is the right kind of sound 98% of the time and the exact variant 61% of the time.
  • Real vs code-synthesized: held-out ROC-AUC of 0.92. About a fifth of clips come back "uncertain".
  • Listening through a soundtrack: 93% of the sound effects placed in a 60-second film mix are detected as events, 89% of the quiet ones under music. A 60 to 90 second film takes about 1.5 minutes on a laptop CPU.
  • Blind test (v1 recipes): the author tried to pick the code-made sound out of real recordings and got it right 8 times out of 15, a coin flip. The README is upfront that one listener and 15 trials is a small test, not proof.

What are earshot's limits?

The README has an unusually honest limits section. Trust it for loudness, timing, sync to picture, "is this the kind of sound I asked for" on single exposed sounds, and picking among candidates. Treat tags inside a busy mix, genre and mood as hints. It can't judge taste or emotion, provenance or licences, speech content, or anything above 14 kHz from the models.

There's also a Goodhart problem the author calls out himself: forge optimises against earshot's own models, which can be pleased without the sound actually improving, and the realness model is easy to fool. His advice is to judge made sounds by the model-free measurements, spectrograms next to references and a human blind test. The reference recordings forge learns from are licensed and not in the repo, so for the best results you bring your own with --refs.

Privacy is simple: audio stays on your machine. The only exception is the optional llm command, which sends audio to Gemini with your own key and only with the --yes-upload flag.

Who should try earshot?

Anyone already making video with code. If your agent renders explainers with ManimGX, builds MP4s with Claude Motion, or ships product demos and small games, sound is usually the part nobody checks. earshot closes that loop: the agent writes a sound, listens, reads the critique and tries again.

It pairs naturally with Leon's other project, Taste-Skill, which does the same kind of quality check for landing pages, and with Anatomy for interactive diagrams. If you just want to hear the results first, watch the launch film linked from the repo with the sound on.

Key facts

  • Product: earshot, an open-source toolkit that lets AI coding agents hear, review and make sound. CLI, Python API and MCP server.
  • Author / repo: Leonxlnx/earshot by Leon Lin, created October 15, 2026. MIT. 409 stars / 25 forks on the morning of October 17, 2026.
  • Versions: v0.1.0 (October 15, 2026 UTC) and v0.2.0 (October 16, 2026), which added earshot fit (audio to code) and forge v2 (34 categories).
  • X buzz: launch post about 117,900 views / 2,684 likes / 3,087 bookmarks; v0.2 post about 12,400 views / 435 likes / 387 bookmarks (checked October 17).
  • Requirements: Python 3.10+, ffmpeg/ffprobe, CPU only. About 1.4 GB of open models on first use, then offline.
  • Claude Code: claude mcp add earshot --scope user -e EARSHOT_THREADS=3 -- /path/to/earshot/.venv/bin/python -m earshot mcp

FAQ

What is earshot?

earshot is a free, MIT-licensed tool by Leon Lin (@LexnLin, GitHub Leonxlnx) that gives AI coding agents a way to hear. It describes what an audio file sounds like, scores how well it matches a description, finds moments inside long recordings, checks sound against video cuts and critiques a launch video against 7 professional launch films. It can also make sound effects in code (earshot forge) and turn a recording into code (earshot fit). It runs locally on CPU as a CLI, a Python API and an MCP server.

How do I add earshot to Claude Code?

Clone github.com/Leonxlnx/earshot, create a Python venv, install CPU PyTorch, then pip install -e ".[mcp,llm,dev]" and run python -m earshot doctor --load. Register the MCP server with: claude mcp add earshot --scope user -e EARSHOT_THREADS=3 -- /path/to/earshot/.venv/bin/python -m earshot mcp. Optionally copy skills/earshot and skills/real-sound into ~/.claude/skills/ so the agent knows when to use each command.

Does earshot need a GPU or an API key?

No. earshot is CPU-only and uses no GPU. It needs Python 3.10+ and ffmpeg/ffprobe on PATH. The first run downloads two open models (about 1.4 GB), then it works offline. Only the optional llm command calls an outside service: it sends audio to Gemini with your own GEMINI_API_KEY and only with the --yes-upload flag.

What does earshot fit do?

earshot fit, added in v0.2 on October 16, 2026, translates a recording into code. It fits a small synthesis model to the sound and writes a Python recipe whose render() function re-creates it, with knobs for variations and morphs between two recordings. On 12 real recordings the README reports a median CLAP cosine of 0.945 between recording and render, and the same top describe tag in 10 of 12.

Is earshot free and open source?

Yes. The code is MIT-licensed. The two models it downloads keep their own licences: CLAP (laion/larger_clap_general) is Apache-2.0 and the AudioSet tagger (MIT/ast-finetuned-audioset-10-10-0.4593) is BSD-3-Clause. The repo stores no audio or video; reference recordings for forge are licensed and you bring your own.

Who made earshot, and is it related to Taste-Skill?

earshot is by Leon Lin (@LexnLin on X, Leonxlnx on GitHub), the same developer behind Taste-Skill, the Claude Code skill that steers agents away from generic AI landing pages. The repo was created on October 15, 2026, and the launch post on X passed 117,000 views in about a day.

Sources

Keep reading