Skip to main content
Glama
Benedict

TidalCycles MCP Server

by Benedict

πŸŒ€ TidalCycles MCP Server

Conversational live coding with Claude AI + TidalCycles

License: MIT Node Version

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:

  1. TidalCycles - Install from tidalcycles.org

    • Includes GHCi (Glasgow Haskell Compiler Interactive)

    • Haskell Stack or Cabal

  2. 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")

  3. Claude Desktop - Get from claude.ai

  4. Node.js 18+ - For running the MCP server

πŸš€ 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 build

2. 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

{
  "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_PATH

Replace /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

  1. Restart Claude Desktop to load the MCP server

  2. Start a new conversation

  3. 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 sparse

Live 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 the d1 $ 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:

  1. You talk to Claude in natural language

  2. Claude uses MCP tools to generate Tidal code

  3. MCP server either:

    • File mode: Writes code to .tidal file β†’ File watcher evaluates it

    • Direct mode: Sends directly to running GHCi process

  4. TidalCycles/GHCi sends OSC messages to SuperDirt

  5. SuperCollider/SuperDirt plays the audio

πŸ› Troubleshooting

"MCP server not connecting"

  • Check the path in claude_desktop_config.json is absolute

  • Restart 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.start

  • Verify 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 ghci

  • Verify GHCI_PATH in config matches which ghci

  • Check 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: hush

  • Kill 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


Made with πŸŒ€ for the live coding community

Go forth and make some algorithmic noise!

Available Tools

7 tools
tidal_evalB

Evaluate a TidalCycles pattern on a specific channel (d1-d9). This is the main way to make music with Tidal.

ParametersJSON Schema
NameRequiredDescriptionDefault
channelYesThe channel to evaluate on (d1, d2, ... d9)
patternYesThe TidalCycles pattern to evaluate (without the 'd1 $' prefix)

TDQS

B3.4/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoMaximum number of history items to return (default: 10)

TDQS

A3.5/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A3.9/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose4/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
channelYesThe channel to silence (d1-d9)

TDQS

A4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
channelYesThe channel to solo

TDQS

A4/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.4/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters4/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

  1. 7 tool updatesv1.0.0
    • First observedtidal_eval
    • First observedtidal_get_history
    • First observedtidal_get_state
    • First observedtidal_hush
    • First observedtidal_silence
    • First observedtidal_solo
    • First observedtidal_unsolo

TDQS

A3.9/5.0

Scored across 7 tools

Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness4/5

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

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers