TidalCycles MCP Server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@TidalCycles MCP ServerCreate a funky drum pattern"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
π TidalCycles MCP Server
Conversational live coding with Claude AI + TidalCycles
This MCP (Model Context Protocol) server enables Claude to control TidalCycles through natural conversation, creating a powerful AI-assisted live coding experience for algorithmic music composition.
β¨ Features
π΅ Evaluate TidalCycles patterns through conversational AI
π State awareness - Claude knows what's currently playing
π°οΈ Pattern history - Track and recall previous patterns
ποΈ Channel management - Solo, silence, or hush specific channels
π¬ Natural conversation - Talk to Claude about your music in plain English
π Real-time feedback - Immediate pattern evaluation
π Dual transport modes: stdio for Claude Desktop + WebSocket for external clients
π Network accessible - Web UIs and remote clients can connect via WebSocket
π Auto-recovery - Robust GHCi process management with automatic reconnection
Related MCP server: supercollider-mcp
π Prerequisites
Before installing, ensure you have:
TidalCycles - Install from tidalcycles.org
Includes GHCi (Glasgow Haskell Compiler Interactive)
Haskell Stack or Cabal
SuperCollider + SuperDirt - Required for audio output
Download from supercollider.github.io
Install SuperDirt: In SuperCollider, run
Quarks.install("SuperDirt")Install samples:
Quarks.install("Dirt-Samples")
Claude Desktop - Get from claude.ai
Node.js 18+ - For running the MCP server
Download from nodejs.org
Verify:
node --version
π Quick Start
1. Installation
# Clone the repository
git clone https://github.com/yourusername/tidal-mcp-server.git
cd tidal-mcp-server
# Install dependencies
npm install
# Build the server
npm run build2. Start SuperCollider
Open SuperCollider and run:
// Start SuperDirt
SuperDirt.start;
// Verify it's listening
// Should see: "SuperDirt: listening to Tidal on port 57120"3. Configure Claude Desktop
Add this to your Claude Desktop configuration file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
File-based Mode (Recommended for stability):
{
"mcpServers": {
"tidal": {
"command": "node",
"args": [
"/absolute/path/to/tidal-mcp-server/dist/index.js"
],
"env": {
"TIDAL_FILE": "/absolute/path/to/tidal-mcp-server/tidal-mcp-output.tidal"
}
}
}
}Direct GHCi Mode (Experimental - no restarts):
{
"mcpServers": {
"tidal": {
"command": "node",
"args": [
"/absolute/path/to/tidal-mcp-server/dist/index.js"
],
"env": {
"TIDAL_FILE": "/absolute/path/to/tidal-mcp-server/tidal-mcp-output.tidal",
"TIDAL_USE_GHCI": "true",
"TIDAL_BOOT_PATH": "/absolute/path/to/tidal-mcp-server/BootTidal.hs",
"GHCI_PATH": "/usr/local/bin/ghci"
}
}
}
}Finding your ghci path:
which ghci
# Use this path for GHCI_PATHReplace /absolute/path/to/ with the actual path to your installation.
4. File Watching Setup (File-based mode only)
For file-based mode, you need to watch the output file and evaluate it in TidalCycles:
Option A: Using watchexec (recommended)
# Install watchexec
brew install watchexec # macOS
# or
cargo install watchexec-cli # Any OS with Rust
# Watch and auto-reload patterns
cd /path/to/tidal-mcp-server
watchexec --restart -w tidal-mcp-output.tidal \
"ghci -ghci-script BootTidal.hs -ghci-script tidal-mcp-output.tidal"Option B: Using your editor
Open tidal-mcp-output.tidal in your preferred editor with TidalCycles support and manually evaluate patterns when Claude writes them.
5. Start Using
Restart Claude Desktop to load the MCP server
Start a new conversation
Make music!
You: Create a funky drum pattern
Claude: [calls tidal_eval]
I'll create a syncopated funk groove:
d1 $ sound "bd ~ bd ~ bd ~ ~ ~"
You: Add a bassline
Claude: [calls tidal_eval on d2]
Added a groovy bassline:
d2 $ sound "bass2*8" # n "0 3 5 7"πΉ Usage Examples
Basic Patterns
You: Play a simple drum beat
You: Make it faster
You: Add some hi-hats
You: What's playing right now?Advanced Composition
You: Create a glitchy breakbeat with euclidean rhythms
You: Add a wobbling bassline with filter sweeps
You: Layer some atmospheric pads over the top
You: Make the whole thing more sparseLive Performance
You: Solo channel d2
You: Bring back everything
You: Hush
You: Show me the last 5 patterns I evaluatedπ οΈ Available Tools
The MCP server exposes these tools to Claude:
tidal_eval
Evaluate a TidalCycles pattern on a specific channel (d1-d9).
Parameters:
channel: String (d1-d9)pattern: String (TidalCycles code without thed1 $prefix)
Example:
{
"channel": "d1",
"pattern": "sound \"bd sd bd sd\" # gain \"1.2\""
}tidal_hush
Stop all currently playing patterns immediately.
tidal_silence
Stop a specific channel gracefully.
Parameters:
channel: String (d1-d9)
tidal_get_state
Get current state of all channels - what's playing and when it started.
tidal_solo
Solo a specific channel, muting all others.
Parameters:
channel: String (d1-d9)
tidal_unsolo
Restore all channels after soloing.
tidal_get_history
Get pattern history from the current session.
Parameters:
limit: Number (optional, default: 10)
π Project Structure
tidal-mcp-server/
βββ src/
β βββ index.ts # Main MCP server implementation
β βββ websocket-transport.ts # WebSocket transport layer
βββ dist/ # Compiled JavaScript output
βββ BootTidal.hs # TidalCycles initialization
βββ tidal-mcp-output.tidal # Generated pattern output file
βββ start-websocket.sh # WebSocket server startup script
βββ test-websocket-client.js # WebSocket connection test
βββ examples.tidal # Example patterns
βββ WEBSOCKET-USAGE.md # WebSocket setup and usage guide
βββ package.json # Node.js dependencies
βββ tsconfig.json # TypeScript configuration
βββ README.md # This file
βββ QUICKSTART.md # Quick reference guide
βββ CONTRIBUTING.md # Contribution guidelines
βββ LICENSE # MIT License
π¨ Use Cases
Live Performance
Generate patterns on the fly during algoraves
Quick iterations and experimentation
Emergency pattern generation when stuck
AI-assisted improvisation
Learning & Exploration
Ask Claude to explain TidalCycles concepts
Generate example patterns for specific techniques
Explore new rhythmic and harmonic ideas
Learn by conversation
Composition
Rapid prototyping of musical ideas
Generate pattern variations
Collaborative composition with AI
Build complex layered arrangements
π§ Architecture
βββββββββββ ββββββββββββββββ ββββββββββββββββ
β Claude β ββMCPββΊ β MCP Server β βββββββΊ β TidalCycles β
β AI β β (Node.js) β β (GHCi) β
βββββββββββ ββββββββββββββββ ββββββββββββββββ
β β
β (File mode) β
βΌ βΌ
ββββββββββββββββ ββββββββββββββββ
β .tidal file β β SuperColliderβ
β (watch) β β SuperDirt β
ββββββββββββββββ ββββββββββββββββFlow:
You talk to Claude in natural language
Claude uses MCP tools to generate Tidal code
MCP server either:
File mode: Writes code to
.tidalfile β File watcher evaluates itDirect mode: Sends directly to running GHCi process
TidalCycles/GHCi sends OSC messages to SuperDirt
SuperCollider/SuperDirt plays the audio
π Troubleshooting
"MCP server not connecting"
Check the path in
claude_desktop_config.jsonis absoluteRestart Claude Desktop after config changes
Check Node.js version:
node --version(need 18+)Check MCP server logs in Claude Desktop
"Patterns not playing" (File mode)
Ensure SuperCollider is running:
SuperDirt.startVerify file watcher (watchexec) is running
Check the TIDAL_FILE path is correct
Try manually evaluating the file in your editor
"Patterns not playing" (Direct GHCi mode)
Check ghci is in PATH:
which ghciVerify GHCI_PATH in config matches
which ghciCheck MCP server logs for "GHCi/TidalCycles started and connected"
Ensure only one GHCi instance is running
"spawn ghci ENOENT"
GHCi not found in PATH
Set GHCI_PATH environment variable with full path
On macOS with ghcup: usually
/Users/username/.ghcup/bin/ghci
"No samples found" / Empty sound library
Install Dirt-Samples in SuperCollider:
Quarks.install("Dirt-Samples"); // Recompile (Cmd+K) SuperDirt.start;Verify:
~dirt.soundLibrary.buffers.keys.do({|x| x.postln});
"Late" messages in SuperCollider
Normal at fast tempos (jungle/DnB)
If severe (>1 second), restart SuperDirt
Check system audio settings
Reduce pattern complexity
Music continues after stopping MCP server
Patterns run in SuperCollider, independent of MCP server
Stop in SuperCollider:
s.freeAll;Or in any GHCi/Tidal session:
hushKill all ghci processes:
pkill -9 ghci
π§ Known Limitations
File mode: Restarts GHCi on every change (causes brief audio dropout)
Direct GHCi mode: Experimental, may have edge cases
No visual feedback: Pattern changes aren't visible in editor (file mode)
Single instance: Can't run multiple MCP servers simultaneously
No undo: Pattern changes are immediate and can't be undone
πΊοΈ Roadmap
β Completed Features
Direct GHCi integration - Real-time pattern evaluation without file watching
WebSocket transport - Network-accessible server for web UIs and collaboration
Robust error handling - GHCi process recovery and connection monitoring
Session logging - Complete pattern history with timestamps
π Next Up (Priority Features)
MIDI Controller Input - Physical knobs/faders control Tidal parameters
MIDI learn mode for easy mapping
Support for popular controllers (Push, Launchpad, etc.)
Macro controls for complex parameter automation
Pattern Version Control - Git-like history for your patterns
Undo/redo system with branching
Save/restore snapshots
Compare pattern versions
Browser-based UI - Real-time pattern visualization
Live waveform display
Channel timeline view
WebSocket integration for multiple UIs
π Advanced Features
Real-time Audio Analysis - AI gets audio feedback
Frequency analysis to inform pattern choices
Beat detection for tempo sync
Amplitude monitoring for mix balance
AI Pattern Suggestions - Context-aware recommendations
ML-based pattern generation
Style-specific suggestions (techno, ambient, breaks)
Automatic complementary pattern creation
Multi-user Collaboration - Live coding sessions
Multiple users control different channels
Turn-based jamming modes
Shared pattern library
π¨ Creative Integrations
Hydra Visual Integration - Reactive visuals
Auto-generate visuals from audio patterns
Synchronized visual effects with beat events
Live visual coding alongside audio
DAW Integration - Professional workflow
MIDI output to hardware synths
Audio recording of Tidal sessions
Timeline sync with Ableton Live/Logic
AI Composition Tools - Advanced creativity
Generate full track structures
Style transfer between genres
Harmony analysis and suggestions
π€ Contributing
Contributions are welcome! Please see CONTRIBUTING.md for guidelines.
Quick start for contributors:
# Clone and setup
git clone https://github.com/yourusername/tidal-mcp-server.git
cd tidal-mcp-server
npm install
# Development mode (with auto-rebuild)
npm run dev
# Run tests
npm test
# Build for production
npm run buildπ Resources
π License
MIT License - see LICENSE file for details.
π Acknowledgments
Alex McLean (yaxu) for creating TidalCycles
The TOPLAP and algorave communities for live coding culture
Anthropic for the Model Context Protocol and Claude
Everyone who live codes and makes weird music with computers
π Support
Issues: GitHub Issues
Discussions: GitHub Discussions
TidalCycles Community: Discord
Made with π for the live coding community
Go forth and make some algorithmic noise!
Available Tools
7 toolstidal_evalB
Evaluate a TidalCycles pattern on a specific channel (d1-d9). This is the main way to make music with Tidal.
| Name | Required | Description | Default |
|---|---|---|---|
| channel | Yes | The channel to evaluate on (d1, d2, ... d9) | |
| pattern | Yes | The TidalCycles pattern to evaluate (without the 'd1 $' prefix) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations and no output schema, the description must disclose behavioral traits itself, but it does not. It does not say whether evaluating a pattern replaces the previous pattern on that channel, whether evaluation immediately affects sound, how errors are surfaced, or whether the pattern persists until changed or silenced. 'Evaluate' implies sending a command, but the runtime effects and side effects are undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the core action and scope. Every clause earns its place; the 'main way' comment is useful orienting context, not filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is relatively simple, but it lacks any behavioral or result context, and there are no annotations or output schema to compensate. An agent is not told what to expect after evaluation, whether the action is additive or replacing, or how to stop or alter the result. The parameter schema is complete, but the overall operational picture is incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the tool description adds no meaningful parameter semantics beyond what the schema already states. The channel range and the note that pattern excludes the 'd1 $' prefix are both already present in the schema properties, so the description provides no extra value here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('Evaluate'), a clear resource ('a TidalCycles pattern'), and a precise scope ('on a specific channel (d1-d9)'). The statement 'This is the main way to make music with Tidal' distinguishes it from the surrounding utility siblings like tidal_hush and tidal_silence, so an agent can recognize it as the core sound-producing tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'main way to make music' phrase implies this is the primary tool for expressing patterns, but the description gives no explicit guidance about when to prefer it over siblings or when to use alternatives like tidal_silence or tidal_solo. The intended usage is clear enough, but exclusions and alternatives are left unstated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tidal_get_historyA
Get the history of patterns evaluated in this session.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of history items to return (default: 10) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. The verb 'Get' implies a read-only operation, and the phrase 'evaluated in this session' adds scoping context. However, it does not disclose the return format, ordering, or explicitly state that no state is modified, which is only minimally adequate for a simple getter.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. Every word contributes to understanding the tool's purpose and scope, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple tool with one optional parameter and no output schema. The description plus schema is sufficient for basic invocation, but the return format of the history is not described, leaving some ambiguity about what an agent should expect in the response.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, as the only parameter 'limit' is fully described with its default value and meaning. The description adds no additional parameter information, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('Get') and resource ('history of patterns evaluated in this session'). It distinguishes itself from sibling getter tools like tidal_get_state and tidal_get_samples by scoping to session-evaluated patterns, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or sibling tools, so an agent must infer appropriate usage solely from the name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tidal_get_stateA
Get the current state of all channels - what patterns are playing and when they started.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full behavioral burden. It communicates a read-only intent via 'get' and specifies scope (all channels) and content (patterns, start times), which separates it from mutating siblings. However, it does not explicitly state non-destructiveness, session requirements, or edge-case behavior, leaving the safety profile implicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence front-loaded with verb and resource, with a dash clause that disambiguates what 'state' means (patterns + start times). No filler; every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter query tool with no output schema, the description covers the essentials: operation, scope, and return content. Minor gaps β return format and behavior when no channels are active β would require an output schema or one more clause, but they do not jeopardize correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters and 100% schema coverage, the baseline is 4. The description adds nothing about parameters because there are none to document; instead it clarifies what the tool returns, which is the relevant semantic content for an agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Uses a specific verb 'get' with a specific resource 'current state of all channels' and specifies the return content (patterns and start times). This clearly distinguishes it from sibling query tools like tidal_get_history (past) and tidal_get_samples, and from the mutation tools (tidal_hush, tidal_silence, tidal_solo, tidal_unsolo, tidal_eval).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The word 'current' implies this is for live-state queries, and the contrast with tidal_get_history (history vs. current) is evident but never made explicit. No alternatives are named and no exclusion criteria are given β the routing guidance is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tidal_hushA
Stop all currently playing patterns immediately. Use this to clear everything.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It clearly discloses the core behavior (stops all currently playing patterns) and the urgency ('immediately'), but it does not explain side effects, reversibility, or what 'clear everything' means for the Tidal state beyond stopping patterns. This is a moderate gap for a mutating tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two short sentences that are front-loaded with the action. Every word earns its place, and there is no redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, no-output-schema tool, the description covers the essential action and the intended usage context. It could be more complete by noting whether the stop is reversible or what happens to the pattern definitions afterwards, but for a simple stop-all command it is largely sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the baseline 4 applies. There is no parameter meaning to add, and the description correctly avoids referencing nonexistent arguments.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Stop'), a specific resource ('all currently playing patterns'), and a timing qualifier ('immediately'). The phrase 'clear everything' reinforces the scope. It does not explicitly distinguish from siblings like tidal_silence, but the action is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a direct instruction: 'Use this to clear everything.' This tells an agent when the tool is the right choice. It does not mention when not to use it or name alternatives such as tidal_silence, so falls short of an explicit routing guide.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tidal_silenceA
Stop a specific channel. More graceful than hush for single channels.
| Name | Required | Description | Default |
|---|---|---|---|
| channel | Yes | The channel to silence (d1-d9) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description states the core behavior (stop/silence) and adds a graceful-vs-hush nuance. However, it does not clarify whether stop is reversible, what state changes occur, or whether any side effects affect playback.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence with two clauses, front-loaded action, no filler. Every word contributes either the action or the sibling comparison.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a single required enum parameter and no output schema, the description is nearly complete for invocation. It could be slightly stronger by saying explicitly what the resulting channel state is or how this differs from hush behaviorally, but the tool is simple enough that little is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the channel parameter is fully enumerated (d1-d9), so the schema already carries the parameter meaning. The description adds little beyond the singular 'specific channel' notion, which is consistent with the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses a specific verb 'Stop' with a specific resource 'a specific channel' and the required channel parameter is documented via enum. It also explicitly distinguishes itself from sibling tidal_hush by positioning itself as 'more graceful' for one channel, so an agent can tell them apart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear comparative guidance: use this over tidal_hush for single channels. It does not spell out exclusions or mention other sibling tools like tidal_solo/tidal_unsolo, but the context is sufficient for basic routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tidal_soloA
Solo a specific channel, muting all others temporarily.
| Name | Required | Description | Default |
|---|---|---|---|
| channel | Yes | The channel to solo |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly reveals that calling the tool mutes all other channels and that the effect is temporary, which is key behavioral information beyond the schema. It does not mention edge cases like toggling an already-soloed channel, but 'temporarily' signals reversibility sufficiently for a simple tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with zero wasted words, and it front-loads the primary action ('Solo a specific channel') before the side effect. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool with a complete schema and no output schema, the description covers the core behavior and the temporary nature of the effect. It could have explicitly pointed to tidal_unsolo for reverting, but the 'temporarily' phrasing combined with the sibling-tool list gives an agent enough context to select and invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter 'channel' is already fully documented by the schema (enum d1βd9 with description 'The channel to solo'), so schema coverage is 100%. The description's phrase 'a specific channel' aligns with the schema but adds no new semantic detail beyond what the schema already provides, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Solo a specific channel') and resource ('channel'), and discloses the key side effect ('muting all others temporarily'), which differentiates it from siblings like tidal_unsolo and tidal_hush. This is unambiguous and distinguishes the tool without needing to open the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description conveys the usage context (when you want to isolate one channel) but does not explicitly mention alternatives or conditions that would select tidal_hush or tidal_unsolo. The context is clear, but there is no exclusion or alternative routing, only an implied use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tidal_unsoloB
Restore all channels after soloing.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that all channels are restored, but it does not mention what happens if nothing was soloed, whether the action is idempotent, or how it interacts with previous mute or silence states.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. For a zero-parameter tool, this length is appropriate and every word contributes to meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate for a simple zero-parameter inverse action: an agent can infer that this undoes the soloed state. However, with no annotations or output schema, some behavioral edge cases remain ambiguous, such as behavior when no channels are soloed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and 100% schema description coverage, so no parameter documentation is required. The phrase 'all channels' adds a small amount of semantic clarity about the operation's scope.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the operation: restore all channels after soloing. It is specific about the action and scope, though it does not explicitly differentiate itself from sibling tools like tidal_solo.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'after soloing' implies when to use the tool, giving some contextual guidance. However, it does not explicitly explain when not to use it or how it compares to alternatives like tidal_hush or tidal_silence.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
7 tool updates
v1.0.0- First observed
tidal_eval - First observed
tidal_get_history - First observed
tidal_get_state - First observed
tidal_hush - First observed
tidal_silence - First observed
tidal_solo - First observed
tidal_unsolo
TDQS
Scored across 7 tools
Each tool has a distinct, non-overlapping purpose: evaluating patterns, retrieving history, checking state, stopping all, stopping a specific channel, soloing, and unsoloing. No two tools could be confused.
All tools follow a consistent pattern: the 'tidal_' prefix followed by a verb (eval, hush, silence, solo, unsolo) or verb_noun (get_history, get_state). The naming is uniform and predictable.
With 7 tools, the count is well-scoped for the domain. Each tool serves a clear purpose in the workflow of evaluating and controlling TidalCycles patterns, without being excessive or lacking.
The tool set covers the main operations: evaluating patterns, stopping playback, managing solo, and inspecting state/history. A minor gap is the lack of a tool to list available channels, but this is not critical and the set is otherwise complete.
Maintenance
Related MCP Connectors
Generate AI music via the Lacuna Music API from MCP clients like Claude Desktop & Code.
Create projects, nodes, and tasks in UluP Spaces by conversation with Claude.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
Deploy, monitor, and manage your OpenClaw AI assistants via natural language.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables natural language control over Ableton Live for generating musical patterns, melodies, and full song arrangements. It also provides tools for sample searching and mixing assistance through an OSC-based connection with Claude Desktop.1MIT
- AlicenseNot gradedqualityBmaintenanceConnects Claude Code to SuperCollider for AI-driven music composition, supporting real-time playback and non-realtime audio rendering at 50-150x realtime speed.MIT
- FlicenseNot gradedqualityBmaintenanceControl Ableton Live using natural language via Claude Code, with music theory engine for progressions, project persistence, and song cloning.-
- AlicenseAqualityDmaintenanceEnables conversational live coding with Claude AI and TidalCycles for algorithmic music composition, allowing natural language control of patterns, channels, and state.8MIT