# Chain-of-Thought Skeleton Verifier MCP for AI Agents MCP

> Chain-of-Thought Skeleton Verifier MCP audits the structural integrity and parsing patterns of agentic reasoning processes. It detects broken XML tags, verifies keyword-based prefixes, and tracks reasoning density to ensure your ReAct or Chain-of-Thought outputs follow strict parsing rules.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_SX8YQK6VgxKp2lw0GPkgcOK1OaBkpL1WDfLIicKS/mcp
- **Tags:** react, chain-of-thought, parsing, agent-auditing, structural-integrity

## Description

This MCP audits the structural integrity and parsing patterns of agentic reasoning processes. When you are building complex agents, the hardest part is making sure the output does not break your parser. You spend hours debugging why an agent failed because a closing tag was missing or a prefix did not appear where expected. This tool lets you programmatically audit those reasoning loops. You can check if actions actually have corresponding observations and pull metrics on how dense the reasoning steps are. It turns manual log inspection into a structured validation step. Since Vintius manages this, you just connect your client and start verifying patterns immediately.

## Tools

### check_structural_integrity
Checks for matching XML tags and ensures every action is followed by an observation. This helps prevent broken loops in your parser.

### get_reasoning_stats
Calculates quantitative metrics like thought step counts and reasoning efficiency. Use this to measure the density of your agentic workflows.

### verify_parsing_pattern
Confirms if text follows specific XML or keyword-based prefix patterns. It ensures your outputs adhere to expected structural families.

## Prompt Examples

**Prompt:** 
```
Check if this output is valid: <thought>Searching...</thought><action>search('weather')</action>
```

**Response:** 
```
The structure looks correct, but the loop is incomplete. The action was initiated without a corresponding observation to close the sequence.
```

**Prompt:** 
```
Does this text follow the keyword prefix pattern? Text: Thought: I will check the price. Action: get_price()
```

**Response:** 
```
Yes, this follows the keyword-based prefix pattern using 'Thought:' and 'Action:' markers.
```

**Prompt:** 
```
How many steps were in this reasoning process? Text: Thought: Step 1. Action: Run. Observation: Done.
```

**Response:** 
```
The reasoning process contained 1 thought step with a completed action/observation cycle.
```

## Capabilities

### Detect broken XML tags
Find unclosed or mismatched tags in agent outputs before they break your parser.

### Verify keyword prefixes
Confirm that your text follows specific patterns like Thought or Action markers.

### Audit action sequences
Ensure every action taken by an agent is paired with a corresponding observation.

### Calculate reasoning density
Get quantitative metrics on how many thought steps occur within your workflows.

### Identify pattern mismatches
Spot deviations from expected ReAct or Chain-of-Thought structural families.

## Use Cases

### Broken XML tags in production
An agent fails to parse because a tag was not closed. Use check_structural_integrity to find the exact breakage point.

### Inconsistent prefixing
You switched from XML to keyword prefixes and need to verify all outputs follow the new rule using verify_parsing_pattern.

### Measuring agent efficiency
You want to know if your agents are over-thinking or being too brief by using get_reasoning_stats to track step counts.

### Auditing ReAct loops
An engineer needs to ensure every action taken by the agent is paired with a valid observation via check_structural_integrity.

## Benefits

- Eliminate parser errors by catching unclosed XML tags with check_structural_integrity.
- Ensure consistent formatting using verify_parsing_pattern to check for keyword prefixes.
- Detect broken agent loops with check_structural_integrity when actions lack observations.
- Monitor reasoning quality through quantitative metrics from get_reasoning_stats.
- Automate the auditing of ReAct and Chain-of-Thought output patterns.

## How It Works

The bottom line is you stop guessing why your parser failed and start seeing exactly where the logic broke.

1. Connect the MCP to your preferred AI client via Vinkius.
2. Pass your agent's raw text logs or reasoning outputs to the verification tools.
3. Receive structured reports on structural integrity and reasoning statistics.

## Frequently Asked Questions

**What does it mean if `check_structural_integrity` returns broken loops?**
A broken loop indicates that an action segment was detected in the text, but it was not followed by a corresponding observation segment, meaning the agent's execution cycle was interrupted.

**What does it mean if `check_structural_integrity` returns broken loops?**
A broken loop indicates that an action segment was detected in the text, but it was not followed by a corresponding observation segment, meaning the agent's execution cycle was interrupted.

**Can I use this to detect if an agent is using XML tags or keyword prefixes?**
Yes, the `verify_parsing_pattern` tool specifically identifies whether the input text follows the XML-style tag family or the keyword-based prefix family.

**Can I use this to detect if an agent is using XML tags or keyword prefixes?**
Yes, the `verify_parsing_pattern` tool specifically identifies whether the input text follows the XML-style tag family or the keyword-based prefix family.

**How is reasoning density calculated?**
The `get_reasoning_stats` tool calculates efficiency by comparing the number of completed thought blocks to the number of action blocks, providing a qualitative score like 'High' or 'Low'.

**How is reasoning density calculated?**
The `get_reasoning_stats` tool calculates efficiency by comparing the number of completed thought blocks to the number of action blocks, providing a qualitative score like 'High' or 'Low'.