Skip to main content
Glama
jlivingston-Cipher

iamf-sentinel-mcp

by jlivingston-Cipher
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Local

iamf-sentinel-mcp

An MCP server exposing iamf-sentinel (IAMF conformance validator) and iamf-loom (IAMF packager) to MCP clients — Claude Desktop, Claude Code, and any other agent runtime that speaks the protocol.

IAMF is the Alliance for Open Media's Immersive Audio Model and Formats (v1.1.0). This server lets an agent validate IAMF files against the spec's conformance rules and compile packaging manifests into inspectable, deterministic plans — without executing anything (execution is a separate, per-launch opt-in — see below).

Code comments throughout cite an internal numbered design docset (doc NN), ADRs, and pre-registered expectation labels — DESIGN-NOTES.md explains the notation and indexes every cited document.

Tools

Tool

What it does

Needs toolchain

iamf_validate

Full conformance report on a .iamf / IAMF-in-MP4 file: S-code findings with severities, summary, stream facts. strict promotes WARN to failing.

no

iamf_inspect

Structure orientation: profiles, codec configs (incl. Opus pre-skip), element/presentation/frame counts, OBU trim totals, MP4 edts/elst presence.

no

loom_compile

Compile a Loom manifest (YAML/JSON) to its packaging plan — validate-only. Per-target backend/muxer routing with rationale, or M-code diagnostics.

no

loom_explain

loom explain as text: the compiled plan as its own justification.

no

loom_run

Compile and execute a manifest: encode, mux, measure, and gate every output through the Sentinel validator. Returns per-target outputs (sha256), gate verdicts, measured loudness, and the run-ledger path. Only registered when the server is launched with --enable-run.

yes

Related MCP server: simple-fal-mcp

Resources

  • checks://catalog — every S-code check the validator can emit: severity, layer, title, description, related F-register entries.

  • mcodes://catalog — every M-code compile diagnostic the packager can report, with its stable summary (retired codes kept for the record).

  • fregister://catalog — the failure-mode register (F_TO_CHECK.md): the WP1/WP3 failure catalogue mapped to Sentinel checks, as markdown.

Verified platforms. Every push runs this server's test suite on Linux, macOS, and Windows against Python 3.11 and 3.12 — ci.yml is the claim; the matrix is the evidence. Two boundaries come with it. First, this package is a thin wrapper: a green matrix here says the server behaves on those platforms, not that the conformance logic does — that is gated in iamf-sentinel and iamf-loom by their own matrices. Second, no encoder toolchain is installed in CI, so loom_run's execution path is exercised only through its failure behaviour — that a missing binary yields an actionable error rather than a traceback. Its subprocess half is unverified here by design; iamf-loom owns that claim. The matrix additionally carries a wheel-only leg with no sibling source checkout, which is what pip install iamf-sentinel-mcp actually gives you. Sample-gated tests skip in that environment by design. Nothing here is claimed for a platform that does not have a green leg.

Run

pip install iamf-sentinel-mcp
iamf-sentinel-mcp                # stdio transport, read-only (default)
iamf-sentinel-mcp --enable-run   # additionally registers loom_run (executes)

Claude Desktop / Code config:

{ "mcpServers": { "iamf-sentinel-mcp": { "command": "iamf-sentinel-mcp" } } }

Scope and posture

  • Read-only by default. Without --enable-run, tools parse and compile; nothing is executed, no files are written, no network is touched.

  • Execution is opt-in, per launch. --enable-run registers loom_run, which runs the encoder toolchain as subprocesses and writes files; the Sentinel gate inside loom run stays on by default. A missing toolchain is an actionable error naming the expected binary path. Sentinel L3 rendered-loudness QC remains unexposed.

  • The server is a thin wrapper over the products' public APIs; conformance logic lives in the products, behind their own test gates.

Apache-2.0 (see LICENSE / NOTICE), like everything else in the iamf-sentinel / iamf-loom stack. Support posture: see the core repo's SUPPORT.md.

Related projects

  • Inseglet — the authoring-side companion: a native REAPER MCP extension for immersive authoring (beds, ambisonics, ADM) whose spatial.export_loom_manifest writes manifests this server's loom_compile / loom_run accept. Run both servers in one agent session for an author → package → validate loop.

Available Tools

4 tools
iamf_inspectA

Summarize an IAMF file's structure without judging conformance.

Returns the container kind, IA sequence header profiles, codec configs (codec, samples/frame, sample rate, Opus pre-skip), element and presentation counts, audio-frame count, and start/end trim totals as parsed from the OBUs — plus, for MP4, whether edts/elst is present. Use iamf_validate for conformance findings; this tool is for orientation.

ParametersJSON Schema
NameRequiredDescriptionDefault
pathYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.7/5.0
Behavior4/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 discloses that the tool parses OBUs and returns specific structural details, that it does not judge conformance, and notes MP4-specific behavior (edts/elst presence). This is transparent for an inspection tool, though it does not explicitly mention error behavior or non-mutating nature.

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 well-structured and concise: the first sentence states the core purpose, the second lists return details, and the third provides alternative guidance. Every sentence earns its place without fluff or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has one input parameter and an output schema exists, the description sufficiently explains what the tool does, what it returns, when to use it, and how it differs from siblings. It even includes format-specific details (MP4 edts/elst), making it complete for its simple scope.

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 schema has a single 'path' parameter with no description (0% coverage), but the description compensates by indicating the path points to an IAMF file ('an IAMF file's structure'). The implication is clear, though the description could have explicitly stated 'path to the IAMF file' for even greater precision.

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 and resource: 'Summarize an IAMF file's structure.' It explicitly differentiates from the sibling iamf_validate by saying 'without judging conformance' and 'this tool is for orientation,' making its 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 Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly directs users to 'Use iamf_validate for conformance findings; this tool is for orientation,' providing a clear when-to-use versus alternative-guidelines. It also establishes the boundary by stating it does not judge conformance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

iamf_validateA

Validate an IAMF file (raw .iamf or IAMF-in-MP4) with iamf-sentinel.

Runs the structural (L1) and semantic (L2) conformance checks — including the container trim-carriage checks S-407/S-408/S-409 — and returns the full report: a summary (PASS/FAIL/ERROR, finding counts, stream facts) and every finding with its S-code, severity, message, and offsets. strict treats WARN findings as failing. profile selects a validation profile (default "generic"). L3 rendered-loudness QC needs the decoder toolchain and is not exposed by this server version.

ParametersJSON Schema
NameRequiredDescriptionDefault
pathYes
strictNo
profileNogeneric

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully carries the burden. It details the checks performed (structural L1, semantic L2, including S-407/S-408/S-409), the full report structure, parameter effects (strict, profile), and the L3 limitation, offering rich behavioral context.

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 well-structured: a clear opening, then a detailed but focused paragraph on checks and output, followed by parameter notes. Every sentence adds value with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity, the description covers input scope, validation levels, output report contents, parameter behavior, and an explicit limitation about L3. This is fully sufficient for an agent to select and invoke the tool correctly.

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?

Schema coverage is 0%, but the description explains the meaning of 'strict' and 'profile', and the first sentence makes it clear that 'path' is the target IAMF file. This compensates for the schema's lack of descriptions, though possible profile values are not enumerated.

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 opens with 'Validate an IAMF file (raw .iamf or IAMF-in-MP4) with iamf-sentinel', clearly stating the verb and resource. It distinguishes from sibling tools by focusing on conformance validation rather than inspection or compilation.

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?

The description states it runs L1/L2 checks and explicitly notes 'L3 rendered-loudness QC ... is not exposed', providing a clear exclusion. However, it does not directly compare with sibling tools or give 'when to use' scenarios, so it stops short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

loom_compileA

Compile an iamf-loom manifest (YAML/JSON) to its packaging plan.

Validate-only: nothing is executed and no files are written. Returns ok=true with a plan summary — per-target backend/muxer routing with the ADR-grounded rationale, and each step's id/kind/tool — or ok=false with the M-code diagnostics exactly as loom compile would report them. variables fills {variable} placeholders (the CLI's --var).

ParametersJSON Schema
NameRequiredDescriptionDefault
variablesNo
manifest_pathYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully discloses behavioral traits: no execution, no file writes, ok=true/false return shapes, M-code diagnostics exactly as the CLI, and variable placeholder filling. This is comprehensive and adds significant context beyond the schema.

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 concise and front-loaded with the primary purpose. It then covers safety, return details, and parameter behavior in a logical structure. Every sentence earns its place, with no redundant or filler content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having an output schema, the description provides a complete picture: operation, side-effect-free nature, return format, diagnostics behavior, and parameter semantics. It is fully adequate for the tool's complexity and leaves no significant gaps.

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?

Schema description coverage is 0%, so the description must compensate. It explicitly explains the `variables` parameter as filling `{variable}` placeholders (CLI --var). `manifest_path` is self-explanatory given the tool's purpose, though it is not directly described. Partial compensation, with the most ambiguous parameter addressed.

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 the tool compiles an iamf-loom manifest (YAML/JSON) to a packaging plan. It uses a specific verb (compile), identifies the resource, and distinguishes from sibling tools by focusing on plan generation and validation.

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?

The description provides clear context: it is validate-only, executes nothing, and writes no files. This implies usage for planning/side-effect-free inspection, but it does not explicitly compare with sibling tools like iamf_validate or loom_explain. A brief explicit alternative would make it a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

loom_explainA

Render loom explain for a manifest: the compiled plan as its own justification, in plain text.

The output walks every target: why it routed to its backend/muxer (ADR grounding, F-number references), what every step does and why it exists, and which values resolve only at execution time. Returns ok=true with the text, or ok=false with M-code diagnostics.

ParametersJSON Schema
NameRequiredDescriptionDefault
variablesNo
manifest_pathYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.7/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description takes on the full burden. It transparently discloses the output format (plain text), the content scope (ADR grounding, F-number references, execution-time values), and the return envelope (ok=true with text, ok=false with M-code diagnostics). This covers key behavioral traits, though it stops short of stating side-effects or permission needs, which are likely immaterial for an explain operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is efficient: the first sentence states the core purpose, and the second adds key output characteristics and error behavior. No wasted words or redundant restatements of the tool name. A slight lack of structured details about parameters keeps it from a perfect score, but it remains compact and readable.

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 provides a solid overview of what the tool does and what the output contains, and the output schema likely covers return details. However, it does not explain the optional variables parameter, nor does it clarify whether the manifest must be pre-compiled or if the tool compiles it on the fly. These gaps leave the description incomplete for a tool with two parameters and a complex explanation output.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for parameter meaning. It mentions the manifest ('for a manifest') but does not explain the required manifest_path parameter beyond the tool's focus, and it completely omits the optional 'variables' parameter. The description adds minimal value over the raw schema, leaving an important parameter undocumented.

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 action: 'Render `loom explain` for a manifest' – depicting the compiled plan as its own justification. It distinguishes itself from siblings like loom_compile by focusing on explanation and justification rather than compilation, and from iamf_validate/inspect by outputting a walkthrough of every target's routing and step rationale.

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 implies usage context by describing the output ('walks every target', 'why it routed'), suggesting when a user would want to understand plan decisions. However, it does not explicitly state when to use this tool versus alternatives, nor any exclusions or prerequisites, so guidance remains implicit rather than explicit.

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. 4 tool updatesv0.2.0
    • First observediamf_inspect
    • First observediamf_validate
    • First observedloom_compile
    • First observedloom_explain
Deploy Server
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.4/5.0

Scored across 4 tools

Disambiguation5/5

Each tool has a clear, distinct purpose: iamf_inspect provides orientation, iamf_validate checks conformance, loom_compile builds the packaging plan, and loom_explain justifies that plan. No two tools overlap in intent, even within the same domain.

Naming Consistency5/5

All tool names follow the pattern {domain}_{verb}: iamf_inspect, iamf_validate, loom_compile, loom_explain. The convention is consistent and predictable, making it easy for agents to infer functionality.

Tool Count5/5

With only 4 tools, the server is well-scoped and each tool earns its place. The count is neither minimal nor excessive for covering the two core workflows (IAMF analysis and loom manifest compilation).

Completeness5/5

The server covers the full intended surface: inspection and validation for IAMF files, and compilation and explanation for loom manifests. There are no obvious dead ends or missing operations within the stated scope.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers