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

> 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/ai-agent-connect
- **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

### analyze_structure
Performs a deep structural scan of a raw agent output string to validate its skeleton

### get_ratio_metrics
Calculates higher-level behavioral metrics derived from the structural analysis

### validate_sequence_flow
Checks if the order of identified blocks adheres to the logical ReAct loop

## 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'.

**What does `analyze_structure` do?**
The `analyze_structure` tool performs a deep scan of raw agent text to verify if it follows tag-based or keyword-based patterns, checking for complete reasoning blocks.

**How can I detect impulsive agent behavior?**
You can use `get_ratio_metrics` to calculate the action-to-thought ratio. A high ratio indicates the agent is acting without sufficient reasoning.

**Does this support both XML tags and keyword prefixes?**
Yes, the `analyze_structure` tool supports both `tag_based` mode for XML-style tags and `keyword_based` mode for prefix-style keywords.