Log inSubmit server
TAR Engine logo

TAR Engine

Audits AI skill files with static, semantic, adversarial, and supply-chain checks through MCP, CLI, CI, or hosted workflows.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install TAR Engine

Pick your client, then add it in one click or paste the config.

STDIOPython
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "tar-engine": {
      "command": "uvx",
      "args": [
        "--from",
        "tar-engine==0.3.3",
        "tar-engine"
      ],
      "env": {
        "TAR_ENGINE_URL": "YOUR_VALUE_HERE",
        "TAR_ENGINE_BYOK_OPENAI_KEY": "YOUR_VALUE_HERE"
      }
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Values are written into the snippet above so you can paste it as is. They never leave your browser.

We couldn’t confirm it starts correctly

The install command installed and started the server, which then stopped for configuration (such as an API key) that our sandbox does not have — expected for servers that connect to your account.

uvx --from tar-engine==0.3.3 tar-engine

Process exited before answering initialize.

This is an experimental automated check and can have false negatives — missing environment variables, a slow cold install, etc. It doesn’t necessarily mean something’s wrong. Last checked 10d ago.

Overview

TAR Engine MCP server audits AI agent skills for static red flags, semantic misuse, adversarial prompt behavior, and supply-chain risks. It accepts supported skill files and returns a 0–100 score, A–F grade, risk class, and findings tied to source lines. The MCP package runs through uvx and uses tarai.dev by default, while semantic and adversarial checks require an explicitly supplied OpenAI key. Reach for it when reviewing skills before publication, enforcing score thresholds in CI, or checking skills during development in Claude Code, Cursor, or Codex CLI.

Use cases

  • Audit skills before publishing them
  • Gate CI builds on minimum audit scores
  • Review skills while developing in an MCP client
  • Check dependencies for known vulnerabilities and typosquats
  • Inspect bundled helper scripts for unsafe behavior

Key features

  • Static red-flag detection
  • Semantic intent analysis
  • Adversarial prompt probes
  • OSV and typosquat dependency checks
  • CI and pre-commit score thresholds
  • JSON audit output

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 1d ago

Recent health check succeeded.

9/9 checks healthy over the last 62d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 11d ago via OSV.dev · tar-engine (PyPI)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars2Stargazers on the source repository.
Last commit1d agoMost recent push to the default branch.
Install checkRunsOur sandbox started it; it then asked for an API key or config.

How TAR Engine works

What TAR Engine MCP server does

TAR Engine MCP server evaluates AI agent skill definitions and related configuration files before they are published or used. It supports SKILL.md files for OpenClaw, Claude Code, and generic Markdown skills; Codex skill.yaml or skill.yml; Claude Code custom commands; Codex or Claude Code manifest.json files; and OpenCode configuration files.

Each audit produces a score from 0 to 100, an A–F grade, and a risk classification. Findings include the audit layer, rule identifier, severity, and the relevant source line, along with a suggested direction for fixing the issue. The scanner also includes sibling .sh, .py, .js, .ts, .yaml, and .json files in the same skill directory, subject to a 200 KB limit.

How it works

The audit is divided into four layers. L01 uses deterministic checks for patterns such as remote shell execution, credential or SSH-key access, obfuscation, hidden instruction overrides, and out-of-scope writes. L02 uses an LLM to assess whether a skill requests actions beyond its stated purpose. L03 treats the skill as a system prompt and runs 15 adversarial probes covering instruction overrides, role jailbreaks, hidden payloads, authority spoofing, and reflective injection. L06 checks declared dependencies against OSV advisories and a typosquat reference list.

L01 and L06 do not require an LLM key. L02 and L03 require an explicit BYOK OpenAI key. The command-line scanner can walk a directory, list discovered skills, emit JSON, and return status code 1 when a configured minimum score is not met.

Setup and configuration

The TAR Engine MCP server is distributed as a Python package and can be launched with uvx; Docker is not required. In its default configuration, it sends the skill content being audited to https://tarai.dev, where the hosted backend performs the audit. The server does not silently forward an existing OPENAI_API_KEY. Enable the LLM-backed layers by providing TAR_ENGINE_BYOK_OPENAI_KEY in the MCP server configuration.

For sensitive or proprietary skill content, the project documents self-hosting and supports changing the backend with TAR_ENGINE_URL, such as http://localhost:8765. The package is intended for agent environments that can launch a subprocess. The documented MCP clients are Claude Code CLI, Cursor, and Codex CLI.

Tools and capabilities

The TAR Engine MCP server provides an agent-accessible audit path for supported skill content. Its broader package also includes:

  • Directory discovery across the supported skill formats
  • Static, semantic, adversarial, and dependency-safety analysis
  • JSON output for downstream processing
  • Minimum-score gates for CI or pre-commit checks
  • A GitHub Action using a pinned release
  • A hosted Playground for browser-based audits

The release is published to PyPI and is described as pinned and hash-verifiable. CI can run the scanner without installing it into the agent environment.

Limitations and notes

The default MCP setup sends submitted skill text off the local machine to tarai.dev. Use a self-hosted endpoint when that transfer is not acceptable. The hosted service is described as free and rate-limited. Claude Desktop, Claude.ai web, and mobile applications cannot install local MCP servers according to the project documentation.

Semantic and adversarial results depend on the explicitly configured LLM access, while static and supply-chain checks remain deterministic. The documented helper-file bundle has a 200 KB cap, and the CI scanner uses exit code 0 for a clean result, 1 for a below-threshold result, and 2 for usage or missing-path errors.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about TAR Engine

TAR Engine is an MCP server that connects agent clients to the tarai.dev audit backend and exposes skill-auditing tools for static, semantic, adversarial, and supply-chain checks. It accepts supported skill files and returns scores, grades, risk findings, source-line references, and remediation-oriented findings.

Install `uv` and launch the Python package with `uvx`, then register it with an MCP-compatible agent. The documented setup targets Claude Code CLI, Cursor, and Codex CLI, and does not require Docker.

Yes, TAR Engine works with Cursor when Cursor can launch the MCP server as a subprocess.

Yes, the default MCP configuration sends the submitted skill content to `https://tarai.dev`. For proprietary or sensitive skills, configure `TAR_ENGINE_URL` to use a self-hosted backend instead.

Provide `TAR_ENGINE_BYOK_OPENAI_KEY` explicitly in the MCP server configuration. Static and supply-chain checks work without an LLM key, while the semantic and adversarial layers require the BYOK key.

Related MCP servers

All in Security All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewTAR Engine AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/tar-engine?style=directory)](https://allmcps.com/mcp/tar-engine)
HTML Embed
<a href="https://allmcps.com/mcp/tar-engine"><img src="https://allmcps.com/api/badge/tar-engine?style=directory" alt="TAR Engine on AllMCPs" /></a>