# IAMF Sentinel [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/jlivingston-Cipher/iamf-sentinel-mcp  
**GitHub Stars:** 0  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/iamf-sentinel

## Description
MCP server for the iamf-sentinel IAMF conformance validator and the iamf-loom packager

## Tools
Capabilities this server exposes over MCP:

- **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.
- **iamf_inspect** — Structure orientation: profiles, codec configs (incl. Opus pre-skip), element/presentation/frame counts, OBU trim totals, MP4 edts/elst presence.
- **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.
- **loom_explain** — loom explain` as text: the compiled plan as its own justification.
- **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`.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "iamf-sentinel": {
    "command": "uvx",
    "args": ["iamf-sentinel-mcp"]
  }
}
```

## Documentation

## What IAMF Sentinel MCP server does

The IAMF Sentinel MCP server connects MCP clients to two underlying projects: `iamf-sentinel`, which validates IAMF content, and `iamf-loom`, which packages IAMF according to a manifest. It is intended for agent workflows that need inspectable validation results or packaging decisions rather than a general-purpose media editor.

Validation accepts `.iamf` files and IAMF stored in MP4. The server can return S-code findings with severities, a summary, and stream facts. A strict validation option treats warnings as failures. Inspection is separate from conformance checking and reports structural details such as profiles, codec configuration, Opus pre-skip, element and presentation counts, frame counts, OBU trim totals, and MP4 edit-list information.

Loom operations accept YAML or JSON manifests. Compilation is validation-only and reports target-specific backend and muxer routing with its rationale, or M-code diagnostics when the manifest cannot be compiled.

## How it works

The IAMF Sentinel MCP server runs as a Python command-line MCP service over stdio. Its default launch exposes parsing, validation, and plan-generation operations without executing an encoder toolchain. `loom_explain` presents the compiled plan as explanatory text, allowing an agent or developer to review the packaging decisions before any run is attempted.

The optional `loom_run` operation combines compilation and execution. It encodes and muxes the requested targets, measures them, and sends every output through the Sentinel validator. Results include per-target output paths and SHA-256 values, gate verdicts, measured loudness, and the path to the run ledger. This operation is registered only when the process starts with `--enable-run`.

## Setup and configuration

Install the package with pip, then start the default read-only service:

```bash
pip install iamf-sentinel-mcp
iamf-sentinel-mcp
```

To expose execution, start it explicitly with:

```bash
iamf-sentinel-mcp --enable-run
```

An MCP client can launch the command as its server process. For Claude Desktop or Claude Code, the configuration uses the command `iamf-sentinel-mcp` under an MCP server entry. No environment variables are specified in the provided setup material.

## Tools and capabilities

The IAMF Sentinel MCP server provides these tools:

- `iamf_validate`: Produces a full conformance report, including S-code findings, severities, summaries, and stream facts. `strict` promotes warnings to failing results.
- `iamf_inspect`: Reports IAMF and MP4 structure for orientation and troubleshooting.
- `loom_compile`: Validates a Loom manifest and returns its packaging plan, target routing, or M-code diagnostics.
- `loom_explain`: Returns the compiled plan as text with its justification.
- `loom_run`: Executes the compiled workflow when enabled at launch, then measures and gates each output.

The server also exposes catalogs for S-code checks, M-code compile diagnostics, and the failure-mode register through `checks://catalog`, `mcodes://catalog`, and `fregister://catalog`.

## Limitations and notes

Read-only mode performs no execution, file writes, or network access. Enabling `loom_run` changes that posture: it invokes encoder subprocesses and writes output files. The required encoder toolchain must be available; a missing binary produces an actionable error. The Sentinel gate remains enabled for runs, while rendered-loudness L3 quality control is not exposed.

The package is a thin MCP wrapper; core conformance and packaging behavior belongs to `iamf-sentinel` and `iamf-loom`. IAMF v2.0.0 streams can be read, including object-based elements and v2 rendering settings, but positions over time and parameter blocks remain unvalidated. The package is licensed under Apache-2.0.

_Full upstream README: https://allmcps.com/mcp/iamf-sentinel/readme_