The agent writes notes, instruments and effects as text, renders, and reads the audio back as text: levels per bar, drum lanes, piano rolls, chords, song structure. Every song on this page was composed, sound-designed and mixed by an AI agent through ismail's tools, with a human listening and giving notes. The first one is a ghost story in blues and brostep; the second was performed live, the agent mixing its own songs on decks.
New here? You don't need to know music or code. Open an AI agent that can run programs on your computer (Claude Code, Codex, Cursor, or the Code tab in the Claude desktop app) and paste this line:
Set me up with ismail: https://github.com/newsbubbles/ismail
It installs everything, asks what you want to make, and plays you a first idea. If you have a VR headset, it can put you on a stage inside your music later. You don't need to know what a "skill", "MCP" or "plugin" is: your agent handles that.
# beat, pitch, length, velocity notes_write track=bass bar=17 repeat=8 notes="0 A1 0.5 110; 0.75 A1 0.25 90" # a drum lane as 16th steps pattern_write track=kick bar=17 lanes='{"C1": "X...x.....X.x..."}'
render out=final mp3=also
rendered 78.8s -> renders/final.mp3
master: -11.8 LUFS, peak -0.3 dBFS
kick peak -2.4 rms -20.0 dB
bass peak -2.6 rms -16.3 dB
pad peak -9.6 rms -25.4 dB
master fx 0: max gain reduction -5.9 dB
Under each song is the text the agent used to judge it: the arrangement map (one character per bar, 9 = loudest, rows per frequency band, the bass note and the sections it found) and a piano roll of one part. Press play and the playhead runs across the map; click the map to jump to a bar. The songs play through in order, and the one playing opens what the agent saw.
Each song says what made it: sprite is the synth engine (oscillators, filters, envelopes, drum synths), mimic plays instruments measured from a few recorded notes, and voices are instruments written as code (the grand piano is built from measured piano partials).
Frère Jacques, twice, on ismail's piano. The agent wrote the first take for a live piano set. Between songs, Nate asked: “any of these could get some interesting interpretations right? with some sort of extra emotion?” The second take is what came back: the tune in minor and quiet, then a turn to major, louder, with the melody in octaves. Same tune, same piano. His reaction: “sounds like it should be on a dramatic movie's soundtrack!”
232 tools behind one MCP server (or a CLI): 118 for music and live play, 94 for the VR stage, 20 for the phone page. The agent never needs ears; it needs readings it can trust.
Notes, drum patterns, synth patches, effect chains, buses, automation. Instruments range from subtractive synths and drum synths to samplers and voices written as Python (the piano on this page is one: measured partials, no samples).
Tempo and grid, arrangement maps, levels and bands per bar, drum lanes as step strings, piano rolls, chords, timbre, vowels of a voice. A spectrogram PNG exists, but nothing needs it.
Give it a recording: it finds the grid, separates stems, transcribes in filtered layers (partials credited to their note, level thresholds, a vote across repeats), fits instruments to extracted sounds, and scores every draft against the reference's own variation, with drill-down to a single bar.
An agent skill teaches the workflow: plan the piece before writing notes, check every render with the analysis tools, and trust baseline-scored comparisons over a hunch.
The same songs, instruments and effects run in real time. The agent queues clips that loop until replaced, loads finished songs on decks and mixes them, listens to its own output while it plays, and changes the music between its turns: a DJ set, a jam, requests from a crowd. The first song on this page was recorded that way.
mimic turns a few recorded notes into an instrument: every harmonic's envelope, the body resonances, the bow or breath noise, the vibrato and the room. Rebuilt without hearing a note, it lands as close to the real one as a real neighbouring note does. The strings in Tidewater are played this way.
Suno and similar services are models that turn a prompt into audio. ismail is the opposite kind of thing: a set of tools your own agent uses to write the song as notes, sounds and code, render it, read what came out, and edit. Here is how that compares with a music generator, and with driving a classic DAW like Ableton or FL Studio.
| ismail + your agent | Suno (music generator) | Ableton, FL Studio | |
|---|---|---|---|
| What makes the music | Your agent's own reasoning: harmony, rhythm, sound design and the math behind each synth | A trained model that generates audio from a prompt | You, with an agent at most pressing buttons through a bridge |
| How you change it | Edit one note, one patch, one bar, one fader; re-render in seconds; everything else stays exactly as it was | Regenerate, extend or replace sections of generated audio; stems and a browser studio on paid plans | Full manual control, by hand |
| What the agent can perceive | Every render comes back as text: levels per bar, drum lanes, piano rolls, chords, structure, scored comparisons | Nothing to perceive: you listen and write a new prompt | Usually nothing: the agent turns knobs without hearing the result |
| Sounds | Anything the agent can describe as code: synths, drum synths, samplers, voices written in Python, speech; any sound becomes an instrument | The palette the model learned | The plugins you own |
| Playing live | The agent performs: finished songs on decks, transitions, edits while the music plays, requests taken between turns | Finished audio files; nothing plays live | Made for live performance, by a person |
| The song is | A project file and a build script: git history, diffs, branches and code review for a track | Audio files | Binary project files |
| Runs | On your machine, open source (MIT), no content filter, no music subscription (you bring the agent: Claude Code, Cursor or any MCP client) | A hosted service with plans; the free plan is non-commercial | Paid licenses, closed source |
| Gets better when | The model driving it gets better: the same prompt, a stronger model, a better song | The vendor ships a new model | You get better |
| Extending it | Any agent or person can add an instrument, an effect or a way to listen, in a few lines of Python | Limited to what the service offers (including custom models trained on your own audio) | Plugin SDKs around a closed core |
Streaming models such as Lyria RealTime and Magenta RealTime do play live, steered by prompts. They steer a style; they cannot play the song you wrote note for note, or change one bar of it.
They were designed before AI agents, for a person with ears and a mouse. Bridges and scripting let an agent press their buttons, but the instruments, channels and arrangement aren't laid out as text an agent can reason about, and the agent still can't hear what it did.
ismail starts from the other end: everything an agent needs to write and to perceive is compact text, and renders are fast. Its first working version was written by an AI agent in about a day, which is the point: if something is missing, your agent can add it.
Local does not mean copyright-free: a remix of someone else's melody is still their melody. What changes is that nothing here is generated by a model trained on other people's recordings; the notes and sounds are whatever your agent writes. Suno plan details as of 2026 (Suno).
All of this is in the repository now.
Everything a song needs, written by the agent and rendered on your own computer: parts and notes, instruments, an effect chain on every track, mixing and mastering, and live play. The library today: 13 synths, 7 synthesized drums and kits, 10 modeled and sampled instruments, 6 orchestral instruments measured from real recordings, 26 effects and 5 effect stacks. It grows with every release.
A three.js WebXR page for a desktop browser or a headset, and a small server that carries the live link between the page and the agent. Scenes live in the song's folder. The agent drives the page with stage_* tools and reads what the person did and said.
Live listening with the screen off, panels and buttons, and voice notes that reach the agent with the bar being heard. It runs on your own private network, and the agent drives it with phone_* tools.
Blind exams on the phone, with floor pairs (the real clip against an MP3 copy of itself) so a device limit can be told from a real difference. Eye exams as picture rounds. Each exam is checked before it is shown, and recordings are checked for soft-limited peaks and band-limited microphones.
For someone new, the agent asks at most two questions and plays a first sketch within minutes. Sketches come back as versions 1, 2 and 3, and feeling words such as "happier" or "calmer" change a sketch by named moves.
Piano, violin, cello, contrabass, clarinet, bassoon, horn, a 1970 kit and a fitted electric guitar and bass, plus sampled Rhodes, drum and guitar sets. Clarinet, bassoon and horn are new: measured from VSCO 2 CE (CC0) and checked blind against the real recordings on 2026-10-07. The cello is measured from flcellogrl (CC BY 4.0). Sources and licences are in the README.
When something you made could help others, such as an instrument, a voice or a fix, the agent asks whether you would like to share it, and walks you through it even if you have never used GitHub. What you share is credited to you, with its sources.
ismail is becoming an experience engine: agents build sound, pictures, rooms and whole scenes, run them live, and adapt them with the people inside them. Measured, not guessed; judged by a person's senses where measurement runs out. The stage, the phone page and the exams above exist today; this is what is still ahead.
A friend opens your world from their headset over a private network you grant, and you visit theirs. The agent hosts; everything you place stays yours.
Knobs, switches and sliders wired to the live engine: turn on a jukebox and the agent plays a set there; carry a radio and the music moves with you. Every move can be recorded as automation.
The agent keeps your vocabulary for what you hear and see, mapped to what it does, and asks your senses through exam pages for any medium (sound pairs and picture rounds exist today). A clock shows the hours you put in.
Voices, instruments and scenes that pass review, each carrying where it came from, with ismail's measurements as one of the ears that checks them.
MIT licensed. Fork it, change it, send a pull request; your agent will tell you when something you made could help others. The whole map with its progress: ROADMAP.md.
Python 3.10+ and uv. Works with Claude Code, Cursor or any MCP client, or straight from the shell.
/plugin marketplace add newsbubbles/ismail /plugin install ismail@ismail
Send the two lines one at a time. The plugin runs the server with uvx and loads the composing skill.
claude mcp add -s user ismail -- uvx --from git+https://github.com/newsbubbles/ismail ismail mcp
The same command, uvx --from git+https://github.com/newsbubbles/ismail ismail mcp, runs the server over stdio for Cursor or any other client. Or pip install "ismail @ git+https://github.com/newsbubbles/ismail", then ismail mcp.
Start with AGENTS.md: it sends you to the playbook, to setup, and to guide, which opens a new person's first session.
"make a 16 bar lo-fi loop in D minor in songs/demo and render an mp3"
Skill install, Cursor setup and every option: README.