# Agent Self-Reflection & Sentiment Scanner MCP for AI Agents AI Agent Connect

> Agent Self-Reflection & Sentiment Scanner Alternative helps you track how your agents react to errors and changes in tone by scanning execution logs for specific markers. It turns raw text logs into measurable data on self-correction frequency and agent state.

## Overview
- **Category:** observability
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_F2yFzx4CchXScg2i4EwfRYqrArVJ0UEEfstzE52Z/ai-agent-connect
- **Tags:** sentiment-analysis, self-reflection, agent-monitoring, log-analysis, error-detection

## Description

When you're running autonomous agents, it's hard to tell if they're actually fixing their mistakes or just stuck in a loop. You spend hours digging through text logs trying to find where things went sideways. This MCP changes that by automatically scanning your execution logs for specific phrases that signal an error or a success. It calculates how often your agent is correcting itself and tells you whether it's currently in a state of proceeding or correcting. You can also check the emotional tone of log entries to see if the process is becoming unstable. By connecting this to your workflow through Vinkius, you get a clear view of agent behavior without manual parsing.

## Tools

### analyze_sentiment
Checks the emotional tone of a text string. It helps you spot when log entries become unstable.

### detect_reflection
Scans text to find where an agent is expressing internal thoughts or reasoning.

## Prompt Examples

**Prompt:** 
```
Check these logs for any signs that the agent is stuck in an error loop.
```

**Response:** 
```
| Metric | Value |
| :--- | :--- |
| **Error Count** | 14 |
| **Success Count** | 2 |
| **Status** | Correcting |

Significant spike in error markers detected.
```

**Prompt:** 
```
Does the recent execution log show the agent reflecting on its mistakes?
```

**Response:** 
```
Yes, I found two instances of self-reflection:
* "I made a mistake in the previous step."
* "Let me try again."
```

**Prompt:** 
```
How has the sentiment of our agent's logs changed over the last ten runs?
```

**Response:** 
```
The sentiment has shifted from **Neutral** to **Negative**. The frequency of error-related phrases has increased by 30%.
```

## Capabilities

### Track self-correction rates
Quantify how often an agent identifies and fixes its own errors.

### Monitor agent state transitions
Determine if the process is currently correcting or proceeding based on log markers.

### Evaluate log sentiment
Check the emotional tone of execution entries to spot instability.

### Identify internal thought processes
Find instances where the agent expresses reasoning or reflection in its logs.

## Use Cases

### Detecting infinite loops in agentic workflows
An engineer notices an agent is stuck; they use the MCP to see if the self-correction frequency has spiked.

### Measuring prompt impact on error recovery
After updating a system prompt, a developer confirms the agent is reasoning more effectively through log analysis.

### Monitoring production agent stability
An Ops engineer uses sentiment checks to alert when logs show high levels of error-related instability.

## Benefits

- Stop manual log parsing by automatically identifying error and success markers.
- Measure self-correction frequency to see if your agents are actually learning from mistakes.
- Identify agent state shifts between correcting and proceeding during execution.
- Detect instability in long-running loops by checking the tone of log entries.
- Get structured observability for autonomous workflows without building a custom parser.

## How It Works

The bottom line is you get measurable metrics on agent reliability instead of just reading raw text.

1. Connect your execution logs to the MCP via Vinkius.
2. The engine scans for predefined error and success markers in your history.
3. You receive structured data on self-correction frequency and agent status.

## Frequently Asked Questions

**How can I track agent errors with Agent Self-Reflection & Sentiment Scanner?**
It scans your execution logs for specific phrases like 'I made a mistake' to quantify error rates automatically.

**Can Agent Self-Reflection & Sentiment Scanner help with monitoring agent loops?**
Yes, it identifies if an agent is stuck in a 'correcting' state by tracking self-correction frequency.

**Is Agent Self-Reflection & Sentiment Scanner useful for measuring prompt effectiveness?**
It allows you to see if new prompts increase the rate of successful task completions or improve reasoning detection.

**How does Agent Self-Reflection & Sentiment Scanner handle log sentiment?**
It analyzes the tone of your logs to help you spot instability in agentic workflows before they fail completely.

**Can I use Agent Self-Reflection & Sentiment Scanner with Claude or Cursor?**
Yes, any MCP-compatible client like Claude, Cursor, or Windsurf can use this to analyze your logs.

**How does the scanner identify self-correction?**
The scanner uses exact character-for-character comparison to find predefined error recognition phrases and success markers within your provided execution logs.

**Can I use this to monitor multiple agents?**
Yes, you can pass the raw log text from any agent execution loop into the tools to analyze patterns across different agents and sessions.

**What is the difference between `analyze_sentiment` and `detect_reflection`?**
`analyze_sentiment` evaluates whether text is positive, negative, or neutral, while `detect_reflection` specifically looks for markers of internal thought or self-awareness.