# Silent Change Detector MCP for AI Agents AI Agent Connect

> Silent Change Detector monitors your AI agent's workspace to catch unauthorized or unintended code modifications. It uses cryptographic snapshots to compare the state of your files before and after an agent's turn, identifying exactly where code drifted from your instructions or outdated documentation.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_Oz4Zwzg7pWkrtNhDPEqtx4klHnEKYS6fUWy9wzTG/ai-agent-connect
- **Tags:** git, sha256, ai-agents, code-integrity, audit

## Description

When you give an AI agent a task, it doesn't just fix the one line you asked for. It often refactors surrounding logic, cleans up variables, or updates files to match documentation that is actually three versions out of date. These small, silent changes can break your build or introduce subtle bugs that are a nightmare to debug later. This MCP acts as a watchdog for your codebase. It takes a digital fingerprint of your files before the agent starts working and compares it to the state once the agent is finished. You'll see exactly what was changed, what was an accidental side effect, and what was a direct result of your prompt. By connecting this to your workflow through the Vinkius catalog, you gain a layer of oversight that ensures your agent stays on task without overstepping its bounds. It turns the black box of agent execution into a transparent, auditable process where every modification is accounted for.

## Tools

### analyze_documentation_drift
Checks if the agent modified code to match outdated or incorrect documentation. It helps prevent logic errors caused by stale docs.

### detect_changes
Compares a previous snapshot against the current state to see if changes match your intent. It identifies unintended side effects in the code.

### snapshot_state
Captures the current state of your workspace to create a baseline. This provides the reference point for all future comparisons.

## Prompt Examples

**Prompt:** 
```
Did the agent change anything besides the typo I asked it to fix?
```

**Response:** 
```
No, the changes are isolated. 

| File | Status | Change Type |
| :--- | :--- | :--- |
| `src/main.ts` | Modified | **Intended** (Typo fix) |
| `src/utils.ts` | Unchanged | N/A |

Only one modification was detected, which matches your request.
```

**Prompt:** 
```
Check if the agent's recent changes match our current documentation.
```

**Response:** 
```
I found a discrepancy. The agent modified `api_handler.py` to follow the logic in `docs/old_spec.md`, but that documentation is outdated. 

**Drift Detected:**
* **File:** `api_handler.py` 
* **Issue:** Logic aligns with deprecated authentication flow in old docs.
```

**Prompt:** 
```
Show me a summary of all modifications made during this session.
```

**Response:** 
```
Here is the summary of the agent's activity:

* **Total Files Modified:** 3
* **Intended Changes:** 2 (Refactoring `auth.ts` and `user.ts`)
* **Unintended Changes:** 1 (Added an unused import in `config.json`)

I recommend removing the extra import in `config.json` to keep the workspace clean.
```

## Capabilities

### Capture workspace fingerprints
Create a cryptographic baseline of your current files to use as a reference point.

### Classify code modifications
Distinguish between intended fixes, accidental side effects, and unintended changes.

### Identify documentation drift
Find instances where an agent changed code to match outdated or incorrect documentation.

### Audit agent execution cycles
Review the exact delta between file states to verify agent compliance with instructions.

## Use Cases

### Catching accidental refactors
You ask an agent to fix a single bug in a function, but it decides to rename five other variables. Use detect_changes to see those extra moves.

### Preventing stale doc errors
An agent updates a service to match an old API spec found in your docs. analyze_documentation_drift flags this mismatch.

### Verifying agent autonomy
After a long autonomous run, use snapshot_state and detect_changes to audit every single file the agent touched.

### Validating large refactors
When an agent performs a massive sweep of a directory, use these tools to ensure it didn't touch files outside the target scope.

## Benefits

- Stop silent regressions by catching unintended code changes immediately using detect_changes.
- Ensure code stays accurate to current requirements instead of stale docs with analyze_documentation_drift.
- Establish a reliable baseline for every agent task using snapshot_state.
- Reduce debugging time by pinpointing exactly which files an agent modified during a turn.
- Maintain strict code integrity when using autonomous agents for large-scale refactoring.

## How It Works

The bottom line is you get a clear audit trail of every line of code an agent touches.

1. Take a snapshot of your current workspace to set a baseline.
2. Let your AI agent perform its task or code modification.
3. Run a comparison to see exactly what changed and why.

## Frequently Asked Questions

**How does Silent Change Detector prevent code errors?**
It identifies unintended side effects by comparing a pre-task snapshot to the post-task state, ensuring the agent only touches what you asked it to.

**Can Silent Change Detector catch errors caused by old documentation?**
Yes, it specifically detects when an agent modifies code to match outdated or incorrect documentation, preventing logic drift.

**Is Silent Change Detector useful for large refactors?**
Absolutely. It's designed to help you audit large-scale changes to ensure the agent didn't drift away from the intended scope.

**How do I use Silent Change Detector with my existing AI tools?**
You connect it via Vinkius to any MCP-compatible client like Claude or Cursor, allowing your agent to use its tools directly.

**Does Silent Change Detector work with any coding agent?**
Yes, it works with any agent or client that supports the Model Context Protocol, giving you oversight regardless of the specific model you use.

**What is a silent change?**
A silent change is any modification categorized as unintended or any change that occurs without a corresponding instruction in the user's prompt.

**How does the tool classify changes?**
Changes are classified into three types: Intended (direct goal), Cascading (necessary side effects), and Unintended (unrequested refactors or rogue changes).

**Which files are monitored?**
The system only monitors files that are actively tracked by Git to avoid noise from build artifacts or local environment files.