Skip to main content
Glama

SK Wwise MCP

Documentation

A modular suite of MCP (Model Context Protocol) servers for Audiokinetic Wwise, enabling AI agents to browse, edit, audition, profile, and build Wwise projects through the Wwise Authoring API (WAAPI).

Each server is capped at 15 tools to minimize LLM tool confusion, with Agent Skills routing for multi-agent orchestration.

Easy Setup (Windows, no Python required)

For Windows users who don't want to install Python or clone the repo:

  1. Download sk-wwise-mcp.zip from the latest release.

  2. Unzip anywhere on disk.

  3. Open Wwise with WAAPI enabled (Project Settings → Authoring API → "Enable Wwise Authoring API").

  4. Open a terminal in the unzipped folder and run:

    claude
  5. Approve the MCP servers when prompted.

That's it. The bundle ships a single sk-wwise-mcp.exe (no Python install needed), a pre-configured .mcp.json registering all 12 servers, and .claude/skills/ for routing — all auto-discovered by Claude CLI on launch.

First launch shows a Windows SmartScreen warning because the binary isn't code-signed. Click More info → Run anyway once and Windows remembers it.

Using the bundle with other agents

The sk-wwise-mcp.exe speaks standard MCP over stdio, so it works with any MCP-compatible agent — Cursor, VS Code Copilot, Windsurf, Continue, Gemini CLI, etc. Auto-detection of a top-level .mcp.json is Claude Code-specific; other agents need the entries copied into their own config file. Generic shape, point your agent's MCP config at the exe with the matching --server arg:

{
  "command": "C:/path/to/sk-wwise-mcp/sk-wwise-mcp.exe",
  "args": ["--server", "browse"]
}

Common locations for the MCP config:

Agent

Config path

Root key

Notes

Claude Code

.mcp.json (auto-detected in cwd)

mcpServers

Already in the bundle — no setup

Cursor

.cursor/mcp.json (project) or ~/.cursor/mcp.json (global)

mcpServers

~40-tool ceiling — see below

VS Code Copilot

.vscode/mcp.json or MCP: Add Server command

servers ⚠️

NOT mcpServers — most common setup mistake

Windsurf

~/.codeium/windsurf/mcp_config.json

mcpServers

User-level only; 100-tool ceiling

Gemini CLI

~/.gemini/settings.json or .gemini/settings.json

mcpServers

Supports project-level config

The bundled .mcp.json registers all 12 servers — copy entries from there into your agent's config and adjust the command path to where you unzipped the bundle. Agent Skills in .claude/skills/ follow the open spec and load automatically in tools that support it; agents that don't read skills still work, you'll just need to nudge tool selection in your prompts.

Cursor users: This bundle exposes 97 tools across 12 servers. Cursor caps active MCP tools at ~40 across all servers combined — register only the servers you need (e.g., browse + objects + audition covers most workflows at ~25 tools).

For development setup (Python, editable install, testing) see Quick Start below.

Related MCP server: Hayba

Features

  • 97 tools across 12 MCP servers, covering the full WAAPI surface

  • Agent Skills spec compliant — works with Claude Code, Cursor, VS Code Copilot, Gemini CLI, and 30+ other agent tools

  • Thread-safe WAAPI dispatcher with queue-based serialization and backpressure handling

  • WwiseConsole CLI integration for headless operations (project creation, SoundBank generation, migration)

  • 450 unit tests (mocked WAAPI) + 44 integration tests (live Wwise)

Servers

Server

Tools

Description

mcp_browse

14

Read-only project inspection, object queries, property discovery

mcp_objects

7

Create, delete, rename, move, copy objects; set properties and references

mcp_containers

9

Switch/Blend Container assignments, State Groups, randomizer, attenuations, Game Parameter ranges

mcp_pipeline

12

Audio import/conversion, SoundBank management, tab-delimited generation, project save, logs

mcp_audition

4

Transport-based playback preview

mcp_media_read

3

Audio source peaks, Media Pool queries

mcp_ui

13

Wwise UI automation — layouts, commands, selection, screenshots

mcp_profiling

12

Read-only profiler data — voices, busses, CPU, meters, RTPCs

mcp_profiling_control

7

Profiler capture control, meter registration, cursor navigation

mcp_remote

4

Remote connection to devkits and game instances

mcp_command_line

9

WwiseConsole CLI — no WAAPI needed

mcp_generic

3

Fallback — discover and call any WAAPI function

Requirements

  • Python 3.12+

  • Wwise 2024.1+ (with WAAPI enabled for most servers)

  • uv (recommended) or pip for dependency management

Wwise 2025.1 Hierarchy Rename

Wwise 2025.1 renamed the top-level hierarchies:

Pre-2025.1

2025.1+

\Actor-Mixer Hierarchy

\Containers

\Master-Mixer Hierarchy

\Busses

All paths in this project (tool descriptions, test cases, examples) use the 2025.1+ names. If you're running Wwise 2024.x or earlier, replace \Containers with \Actor-Mixer Hierarchy and \Busses with \Master-Mixer Hierarchy in your queries.

Quick Start

1. Clone and run setup

Windows:

git clone https://github.com/silver-rain-dev/sk-wwise-mcp
cd sk-wwise-mcp/sk-wwise-mcp
setup.bat

macOS / Linux:

git clone https://github.com/silver-rain-dev/sk-wwise-mcp
cd sk-wwise-mcp/sk-wwise-mcp
./setup.sh

The setup script will:

  • Install dependencies (via uv or pip)

  • Let you choose which servers to enable

  • Generate a .mcp.json with the correct paths for your machine

2. Start Wwise

Open Wwise with a project and ensure WAAPI is enabled (Project > User Preferences > Enable Wwise Authoring API).

The servers connect to ws://127.0.0.1:8080/waapi. To use a different URL, set the SK_WWISE_WAAPI_URL environment variable before starting the server. Empty or unset means the default.

3. Verify connectivity

In Claude Code or your agent:

Ping Wwise to check if it's available
cd sk-wwise-mcp/sk-wwise-mcp
uv sync   # or: python -m venv .venv && .venv/Scripts/pip install -e .

Then add servers to your .mcp.json (project root) or ~/.claude.json (global):

{
  "mcpServers": {
    "sk-wwise-browse": {
      "command": "/path/to/.venv/Scripts/python.exe",
      "args": ["/path/to/mcp_browse/server.py"]
    }
  }
}

Use forward slashes on Windows. Repeat for each server — see .mcp.json in the repo root for the full list.

Project Structure

sk-wwise-mcp/
├── .claude/skills/         # Agent Skills (SKILL.md per server)
│   ├── wwise-global/       # Global rules and workflows
│   ├── wwise-browse/       # Browse server skill
│   ├── wwise-objects/      # Objects server skill
│   └── ...                 # One per server
├── core/                   # Shared business logic
│   ├── waapi_util.py       # WAAPI connection, dispatcher, ping
│   ├── query.py            # Object queries, property inspection
│   ├── objects.py          # Object CRUD operations
│   ├── pipeline.py         # Import, SoundBank, save
│   ├── transport.py        # Transport playback
│   ├── media.py            # Audio peaks, Media Pool
│   ├── profiling.py        # Profiler data retrieval
│   ├── ui.py               # UI automation
│   ├── wwise_cli.py        # WwiseConsole CLI wrapper
│   ├── audio_convert.py    # Non-WAV to WAV conversion (ffmpeg)
│   └── generic_handling.py # Generic WAAPI passthrough
├── mcp_browse/             # Read-only project inspection
├── mcp_objects/            # Object editing
├── mcp_containers/         # Container-specific config
├── mcp_pipeline/           # Import and build pipeline
├── mcp_audition/           # Transport playback
├── mcp_media_read/         # Audio analysis
├── mcp_ui/                 # UI automation
├── mcp_profiling/          # Profiler data (read-only)
├── mcp_profiling_control/  # Profiler control
├── mcp_remote/             # Remote connection
├── mcp_command_line/       # WwiseConsole CLI
├── mcp_generic/            # Fallback WAAPI passthrough
└── tests/                  # 450 unit + 44 integration tests

Philosophy

This project is an exploration of how AI agents can assist with large-scale Wwise production work — the tedious, repetitive tasks that eat hours (bulk renaming, auditing property consistency across hundreds of objects, generating SoundBanks, diffing configurations) — while minimizing the risk of unwanted changes to the project.

The core tension: AI is most useful when it can take action, but Wwise projects are complex and a wrong edit can silently break audio behavior in ways that surface much later. This project's architecture is designed around that tension — let the agent help with the heavy lifting, but make it structurally difficult for it to do things it shouldn't.

This is not a finished product. It's a working experiment in finding the right boundary between AI assistance and human control for audio middleware.

Why no Sound Engine (ak.soundengine) coverage

WAAPI exposes both authoring functions (ak.wwise.*) and sound engine functions (ak.soundengine.*). This project deliberately covers only the authoring side.

The sound engine API triggers real-time audio behavior — posting events, setting RTPCs, setting states and switches, seeking — the same operations that the game runtime performs. Exposing these to an AI agent creates a debugging nightmare: if something sounds wrong during a session, was it the game posting an event, or the LLM? With authoring operations the scope is clear — the agent changed a property in the project, and the change is visible in the UI and saved to the work unit. Sound engine calls leave no such trail.

Sound engine interaction belongs in a more controlled environment: game-side tooling, automated test harnesses, or direct scripting where every call is logged and traceable. Not behind an AI agent whose decision-making is opaque by nature.

The one exception is transport-based playback (mcp_audition), which uses ak.wwise.core.transport.* — an authoring API that previews sounds within the Wwise editor without affecting game-side state.

Architecture

Server Separation Philosophy

Most MCP projects expose one server with all tools. This project deliberately splits into 12 servers for three reasons:

Role-based access control

Not every user needs every tool. By separating servers along permission boundaries, teams can grant access by role:

Pick one with sk-wwise-mcp --profile <name> (defined in core/profiles.py). --server a,b still mounts an exact list.

Profile

Servers

Can do

listen

browse, audition, media-read

Explore the project, preview sounds, inspect audio

author

browse, audition, media-read, objects, containers, pipeline, ui

Create/edit objects, configure containers, import audio, generate SoundBanks, drive the UI

build

browse, audition, media-read, objects, containers, pipeline, ui, command-line

Everything in author, plus WwiseConsole operations

qa

browse, audition, profiling, profiling-control, remote

Profile performance, connect to devkits

admin

browse, audition, media-read, objects, containers, pipeline, ui, command-line, generic, profiling, profiling-control, remote

Full access, including generic WAAPI

The old role names are renamed: viewer and designer are now listen; editor is now author.

An agent with only browse enabled physically cannot delete objects or overwrite SoundBank settings — the tools don't exist in its context. This is a stronger guarantee than relying on prompt instructions like "don't modify anything."

Read/write separation

Servers are split by intent and access level, not by WAAPI namespace:

  • Read-only servers (browse, profiling, media_read) cannot modify the project. Safe to give to any agent or user without risk.

  • Edit servers (objects, containers) modify project state — object creation, deletion, property changes.

  • Pipeline servers (pipeline, command_line) handle import/build operations that affect files on disk.

  • Runtime servers (audition, remote, profiling_control) control playback, profiling, and remote connections through the authoring tool.

This means you can build a "read-only assistant" by enabling only the read servers, or a "full authoring agent" by enabling everything. The separation is enforced at the transport level — there's no way to accidentally call a write tool from a read-only server.

LLM tool routing accuracy

LLMs get worse at selecting the right tool as the tool count grows. By capping each server at ~15 tools, the model sees a focused set of tools relevant to the task. Agent Skills (.claude/skills/) route the LLM to the correct server based on the user's intent, keeping the active tool set small even though 95 tools exist across the suite.

Thread-Safe WAAPI Dispatcher

All WAAPI calls are serialized through a queue-based dispatcher (core/waapi_util.py), ensuring:

  • Thread-safe access to the WebSocket connection

  • Backpressure handling (queue max: 10,000)

  • Automatic reconnection on stale connections

Agent Skills

The .claude/skills/ directory contains Agent Skills files that route LLMs to the correct server based on the task. The wwise-global skill contains shared rules and workflow patterns.

Testing

Unit Tests

cd sk-wwise-mcp
uv run pytest tests/ -v

Unit tests use mocked WAAPI calls — no Wwise instance needed.

Integration / Eval Tests

The tests/eval/ directory contains an integration test suite that verifies MCP tool routing against a live Wwise project. It checks that the LLM selects the correct tools for each prompt.

39 test cases across 6 categories: browse, audition, generic, objects, media-read, cross-server.

Running the eval

  1. Setup — create a test project with known objects via the eval-setup Claude Code skill:

    /eval-setup

    This creates a headless WwiseConsole project at tests/eval/EvalTestProject/ with:

    • Actor-Mixer hierarchy (Sounds, Random Container, Switch Container)

    • Events, State Groups, Switch Groups with assignments

    • Audio files imported into all Sounds (for media/peaks tests)

    • Attenuation ShareSet with volume curve

    • Differing properties on Footstep_01/02 (for diff tests)

  2. Run — iterate through all test cases using either skill:

    /eval-batch — runs up to 10 cases per invocation (recommended):

    /loop 60s /eval-batch

    Finishes all 39 cases in ~4 iterations. Each invocation picks up where the last left off.

    /eval-routing — runs 1 case per invocation (fine-grained):

    /loop 30s /eval-routing

    Both log which MCP tools were called and verify against expected tools.

  3. Report — view results:

    python tests/eval/report.py
  4. Teardown — clean up:

    /eval-teardown

Eval architecture

  • test_cases.json — prompt + expected tools for each case

  • verify.py — compares actual tool calls against expected, writes test_results.json

  • report.py — generates pass/fail summary by category

  • log_tool.py — PostToolUse hook that logs MCP tool calls to tool_log.jsonl

  • .claude/settings.json — configures the PostToolUse hook

Connection resilience

core/waapi_util.py includes self-healing connection logic:

  • Ping before call — detects stale WAAPI connections

  • Auto-reconnect — creates a fresh WaapiClient if the connection is dead

  • Auto-restart headless server — if a .waapi_server.lock file exists (written by cli_start_waapi_server), the server is automatically restarted when unresponsive

  • No-op for UI sessions — if the user runs Wwise with the UI (no lockfile), connection failures surface as clear errors without attempting restart

Example Prompts

Show me all Events in my Wwise project
How many Sound objects are under Containers?
Compare the settings between Footstep_Walk and Footstep_Run
Import all .wav files from C:/audio/ into a Random Container
Play the sound at \Containers\Default Work Unit\Footstep
What's the CPU usage in the profiler right now?
Create a new Wwise project at C:/MyGame/MyGame.wproj for Windows and PS5

Contributing

This project is not accepting direct tool contributions. Adding or modifying MCP tools affects LLM routing accuracy across the entire suite — each change requires running the eval framework against a live Wwise project, which involves LLM API costs and manual verification.

If you'd like to extend the tool suite:

  • Bug reports and feature requests — please open an issue

  • Custom tools for your team — fork the repo and add tools to your fork. Use the eval framework (tests/eval/) to validate that your changes don't break routing accuracy

Why not automate routing tests in CI? Full routing validation requires sending prompts to an LLM to see which tools it selects — results aren't fully deterministic, and each run takes time to verify. The current eval framework runs interactively via Claude Code skills, validating routing accuracy across 39 test cases with manual review. If you're already on a Claude Max/Pro subscription, running the eval incurs no additional API costs.

License

See LICENSE for details.

Available Tools

15 tools
build_object_info_queryA
Read-onlyIdempotent

Builds a WAAPI ak.wwise.core.object.get query dict from structured parameters. Use this to construct a query before calling execute_waapi_query.

Args: from_path: Root paths to query from. e.g. ["\Containers"] or ["\Events"] from_type: Object types to query from. e.g. ["Sound", "Event", "RandomSequenceContainer"] return_fields: Fields to return per object. Common: "id", "name", "type", "path", "shortId", "parent" select_transform: Traversal direction. One of: "descendants", "ancestors", "children", "parent" where_name_contains: Filter results to objects whose name contains this string. where_type_is: Filter results to specific object types. e.g. ["Sound", "BlendContainer"]

Examples: All descendants of Containers: from_path=["\Containers"], select_transform="descendants"

All Events containing "footstep":
    from_path=["\Events"], select_transform="descendants",
    where_name_contains="footstep", where_type_is=["Event"]

All busses:
    from_path=["\Busses"], select_transform="descendants",
    where_type_is=["Bus", "AuxBus"]

Children of a specific container:
    from_path=["\Containers\Default Work Unit\SFX"],
    select_transform="children"

IMPORTANT — Inherited properties: Properties like @OutputBus return the LOCAL value, not the effective (inherited) value. If @OverrideOutput is false, the object inherits its output bus from an ancestor. To find the actual routing, query the object's ancestors (select_transform="ancestors") and return @OutputBus and @OverrideOutput to find the nearest ancestor that sets the effective bus.

Inputs: from_path, from_type, return_fields, select_transform, +2 more.

diff_wwise_objectsA
Read-onlyIdempotent

Compare two Wwise objects and return the properties, references, and lists that differ between them.

Useful for auditing ("do these two sounds have the same settings?") and Paste Properties workflows.

Args: source_path: Project path of source object. source_guid: GUID of source object. source_name_with_type: type:name of source object. e.g. "Sound:Footstep_Walk" target_path: Project path of target object. target_guid: GUID of target object. target_name_with_type: type:name of target object. e.g. "Sound:Footstep_Run"

Provide exactly one source identifier and one target identifier.

Object identification (same for source and target): - path: "\Containers\Default Work Unit\Footstep" - GUID: "{aabbcc00-1122-3344-5566-77889900aabb}" - type:name: "Sound:Footstep_Walk", "Event:Play_Sound_01", "Global:245489792"

Returns: properties: array of property/reference names that differ (e.g. ["Volume", "Pitch", "Lowpass"]) lists: array of list names that differ (e.g. ["Effects", "RTPC"])

Inputs: source_path, source_guid, source_name_with_type, target_path, +2 more.

get_blend_track_assignmentsA
Read-onlyIdempotent

Get the list of assignments for a Blend Track. Only accepts GUIDs.

Use this to inspect which children are assigned to a Blend Track and their crossfade edge config.

Args: blend_track_guid: The GUID of the Blend Track. e.g. "{aabbcc00-1122-3344-5566-77889900aabb}"

Returns {"return": [...]} — array of assignments, each containing: child: GUID of the assigned child object index: position among the Blend Track's assignments edges: array of 2 edge configs [left, right], each with: fadeMode: "None", "Manual", or "Automatic" fadeShape: curve shape (Linear, SCurve, etc.) edgePosition: position within the Game Parameter range fadePosition: fade curve start/end (Manual mode only)

Inputs: blend_track_guid (required).

get_effective_output_busA
Read-onlyIdempotent

Resolve the effective (inherited) output bus for an Actor-Mixer hierarchy object.

WAAPI's @OutputBus returns the LOCAL value, which defaults to "Master Audio Bus" when an object has not set Override Output. This tool walks the ancestor chain to find the first non-default @OutputBus assignment and returns its full bus path.

Args: object_path: Project path. e.g. "\Actor-Mixer Hierarchy\Default Work Unit\SFX\Barrage" object_guid: GUID. e.g. "{aabbcc00-1122-3344-5566-77889900aabb}" object_name_with_type: type:name. e.g. "Sound:Barrage"

Provide exactly one of object_path, object_guid, or object_name_with_type.

Returns: object: {name, path, type} of the queried object effective_bus: {id, name} of the resolved output bus bus_path: full project path of the bus (e.g. "\Master-Mixer Hierarchy\Default Work Unit\Master Audio Bus\SFX") is_hdr: whether the object is inside an HDR window (true if the resolved bus or any of its bus ancestors has HdrEnable=true) hdr_bus: {id, name, path} of the bus that establishes the HDR window, or null if not in one set_by: "self", the ancestor path that sets the override, or "default (no ancestor overrides)"

Inputs: object_path, object_guid, object_name_with_type.

get_property_and_reference_namesA
Read-onlyIdempotent

Get all valid property and reference names for a Wwise object.

Returns lists of properties (e.g. Volume, Pitch) and references (e.g. Attenuation, OutputBus) that can be used with setProperty / setReference calls.

Args: object_path: Project path to the object. e.g. "\Containers\Default Work Unit\Footstep" object_guid: GUID of the object. e.g. "{aabbcc00-1122-3344-5566-77889900aabb}" object_name_with_type: Name qualified by type or short ID. e.g. "Sound:Footstep_Walk", "Event:Play_Sound_01", "Global:245489792" Supported types: StateGroup, SwitchGroup, SoundBank, GameParameter, Event, Effect, AudioDevice, Trigger, Attenuation, DialogueEvent, Bus, AuxBus, Conversion, ModulatorLfo, ModulatorEnvelope, ModulatorTime, Platform, Language, AcousticTexture, Global class_id: Class ID (unsigned 32-bit integer) of the object type.

Provide exactly one of object_path, object_guid, object_name_with_type, or class_id.

Inputs: object_path, object_guid, object_name_with_type, class_id.

get_switch_container_assignmentsA
Read-onlyIdempotent

Get the switch/state-to-child assignments for a Switch Container.

Returns which child object plays for each switch or state value. Use this to audit assignments, find unassigned switches, or document switch mappings.

Args: object_path: Project path to the Switch Container. e.g. "\Containers\Default Work Unit\Footstep_Switch" object_guid: GUID of the Switch Container. object_name_with_type: type:name. e.g. "Global:245489792"

Provide exactly one of object_path, object_guid, or object_name_with_type.

Returns {"return": [...]} — array of assignment pairs, each containing: child: GUID/name/path of the child object assigned to a switch/state stateOrSwitch: GUID/name/path of the switch or state value

Inputs: object_path, object_guid, object_name_with_type.

get_wwise_attenuation_curveA
Read-onlyIdempotent

Get the curve points for an attenuation object.

Args: curve_type: Type of attenuation curve. One of: Volume: "VolumeDryUsage", "VolumeWetGameUsage", "VolumeWetUserUsage" Filter: "LowPassFilterUsage", "HighPassFilterUsage", "DualShelfUsage" Spatial: "SpreadUsage", "FocusUsage" Obstruction: "ObstructionVolumeUsage", "ObstructionHPFUsage", "ObstructionLPFUsage", "ObstructionDSFUsage" Occlusion: "OcclusionVolumeUsage", "OcclusionHPFUsage", "OcclusionLPFUsage", "OcclusionDSFUsage" Diffraction: "DiffractionVolumeUsage", "DiffractionHPFUsage", "DiffractionLPFUsage", "DiffractionDSFUsage" Transmission:"TransmissionVolumeUsage", "TransmissionHPFUsage", "TransmissionLPFUsage", "TransmissionDSFUsage" object_path: Project path to the attenuation object. e.g. "\Attenuations\Default Work Unit\Att_Footstep" object_guid: GUID of the attenuation object. object_name_with_type: type:name. e.g. "Attenuation:Att_Footstep" platform: Platform name or GUID. Optional — omit for linked/default curve.

Provide exactly one of object_path, object_guid, or object_name_with_type.

Returns: curveType: the curve type name use: "None" (no points), "Custom" (own points), "UseVolumeDry" (shares VolumeDry curve), or "UseProject" (uses global Project Settings curve) points: array of {x, y, shape} where x=distance, y=value, shape=curve segment type (Constant, Linear, Log1-3, Exp1-3, SCurve, InvertedSCurve)

Inputs: curve_type (required), object_path, object_guid, object_name_with_type, +1 more.

get_wwise_installation_infoA
Read-onlyIdempotent

Get information about the running Wwise installation, including version, platform, and build number.

Use this to verify which version of Wwise is running and confirm connectivity to the authoring tool.

Inputs: no named parameters.

get_wwise_object_infoA
Read-onlyIdempotent

Query Wwise objects and return a summary preview.

IMPORTANT: Always use build_object_info_query() first to construct the query dict, then pass its output to this function. Do NOT hand-craft the query dict directly — the WAAPI query format is complex and error-prone; build_object_info_query() ensures correct structure (from, transform, options) every time.

IMPORTANT: The returned 'preview' only contains the first 10 results. The COMPLETE results are saved to the file path in 'output_file'. You MUST read that file to see all results — do not treat the preview as the full dataset.

Example workflow: query = build_object_info_query( from_path=["\Events"], select_transform="descendants", where_type_is=["Event"], ) results = get_wwise_object_info(query=query)

Inputs: query (required).

get_wwise_object_typesA
Read-onlyIdempotent

Get all available Wwise object types. No arguments required.

Use this to discover valid type names for queries — pass them to build_object_info_query's from_type or where_type_is parameters. Also useful for getting classId values for build_property_reference_query and build_property_info_query.

Returns {"return": [{"classId": int, "name": str, "type": str}, ...]} Each entry contains: classId: The class ID (unsigned 32-bit integer) of the object type. name: The display name of the object type. type: The type identifier string (e.g. "Sound", "Event", "Bus").

Inputs: no named parameters.

get_wwise_project_infoA
Read-onlyIdempotent

Get metadata about the currently open Wwise project, including project name, default language, and available platforms.

Use this to understand the project context before performing queries or modifications.

Inputs: no named parameters.

get_wwise_property_infoA
Read-onlyIdempotent

Get detailed info about a specific property on a Wwise object (type, min, max, default).

Use get_property_and_reference_names first to discover valid property names. Use this to validate values before calling setProperty.

Args: property_name: The property name to get info for. e.g. "Volume", "Pitch", "Lowpass", "IsLoopingEnabled" object_path: Project path to the object. e.g. "\Containers\Default Work Unit\Footstep" object_guid: GUID of the object. e.g. "{aabbcc00-1122-3344-5566-77889900aabb}" object_name_with_type: Name qualified by type or short ID. e.g. "Sound:Footstep_Walk", "Event:Play_Sound_01", "Global:245489792" class_id: Class ID (unsigned 32-bit integer) as an alternative to object.

Provide property_name plus one of object_path, object_guid, object_name_with_type, or class_id.

Returns the property's type, default value, min/max range, and display name.

Inputs: property_name (required), object_path, object_guid, object_name_with_type, +1 more.

is_wwise_property_enabledA
Read-onlyIdempotent

Check if a property is enabled on a Wwise object for a given platform.

A property can be disabled when it's overridden by a parent or not applicable on a specific platform. All three arguments (object, property, platform) are required.

Args: property_name: The property to check. e.g. "Volume", "Pitch", "Lowpass" platform: Platform name or GUID. e.g. "Windows", "Mac", "iOS", "Android", "PS5", "XboxSeriesX" or a GUID "{aabbcc00-1122-3344-5566-77889900aabb}" object_path: Project path. e.g. "\Containers\Default Work Unit\Footstep" object_guid: GUID. e.g. "{aabbcc00-1122-3344-5566-77889900aabb}" object_name_with_type: type:name. e.g. "Sound:Footstep_Walk"

Provide exactly one of object_path, object_guid, or object_name_with_type.

Returns {"return": true} if the property is enabled, or {"return": false} if the property is disabled.

Inputs: property_name (required), platform (required), object_path, object_guid, +1 more.

is_wwise_property_linkedA
Read-onlyIdempotent

Check if a property on a Wwise object is linked (shared across all platforms) or unlinked (has platform-specific values).

All three arguments (object, property, platform) are required.

Args: property_name: The property to check. e.g. "Volume", "Pitch", "Lowpass" platform: Platform name or GUID to check against. e.g. "Windows", "Mac", "iOS", "Android", "PS5", "XboxSeriesX" or a platform GUID "{aabbcc00-1122-3344-5566-77889900aabb}" object_path: Project path. e.g. "\Containers\Default Work Unit\Footstep" object_guid: GUID. e.g. "{aabbcc00-1122-3344-5566-77889900aabb}" object_name_with_type: type:name. e.g. "Sound:Footstep_Walk"

Provide exactly one of object_path, object_guid, or object_name_with_type.

Returns {"linked": true} if the property is linked (shared across platforms), or {"linked": false} if it has a platform-specific override for the given platform.

Inputs: property_name (required), platform (required), object_path, object_guid, +1 more.

ping_wwiseA
Read-onlyIdempotent

Check if WAAPI is currently available. No arguments required.

Returns {"isAvailable": true} if Wwise is running and WAAPI is ready. Returns {"isAvailable": false} if Wwise is not running, WAAPI is disabled, or a modal dialog is blocking WAAPI access.

Use this before other calls to verify connectivity.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 15 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: query building, object comparison, assignment inspection, property info, connectivity checks, etc. No two tools overlap significantly; even closely related tools like build_object_info_query and get_wwise_object_info serve different roles (constructor vs executor).

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern in snake_case. Groupings like 'get_wwise_*' and 'is_wwise_*' are predictable, and each verb clearly indicates the action (ping, build, diff, get). No mixed conventions or vague verbs.

    Tool Count5/5

    15 tools is an appropriate scope for a Wwise middleware server. It covers essential query, inspection, and validation operations without being overwhelming. Each tool earns its place, providing a focused but useful interface.

    Completeness3/5

    The tool set is strong on inspection (query, diff, property info) but lacks any mutation tools (create, update, delete, setProperty). Given that the domain includes audio project editing, the absence of write operations is a notable gap that forces agents into a read-only workflow, limiting practical use.

    Maintenance

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers