# claude-task-completion-verifier MCP for AI Agents AI Agent Connect

> claude-task-completion-verifier MCP provides a deterministic way to prove an AI agent actually finished its work. Instead of guessing if a task is done, it checks for real evidence like file existence, specific text patterns, and successful shell command execution. It turns subjective AI claims into verifiable facts.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_e2inUoyONP8P4BUpdHTyRbYsrK5jEtq5a30o6pFC/ai-agent-connect
- **Tags:** verification, deterministic, testing, automation, audit

## Description

Stop taking your AI's word for it. When you ask an agent to refactor a codebase or update a configuration file, it might tell you it's finished, but how do you know the changes actually stuck? This MCP replaces guesswork with hard evidence. It allows your agent to look at the actual state of the workspace to confirm its work. It can scan files for specific patterns, check if new files were created where they should be, and even run your existing test suites or build commands to ensure everything still works. It acts as a bridge between what the agent thinks it did and the reality of your file system and environment. By connecting this to your workflow through the Vinkius catalog, you add a layer of accountability that prevents silent failures. You move from hoping the agent succeeded to knowing it did because the tests passed and the files match the requirements.

## Tools

### verify_task_completion
Performs a full audit of a task by evaluating all provided criteria. It ensures every requirement is met through objective checks.

### check_file_integrity
Verifies that specific files exist and contain expected content patterns. This prevents errors caused by missing or malformed files.

### execute_environment_check
Runs shell commands to verify the technical health of the workspace. It's used to trigger tests or builds to confirm system stability.

## Prompt Examples

**Prompt:** 
```
Did the agent actually update the database schema in the models folder?
```

**Response:** 
```
I've checked the files. The `schema.sql` file has been updated with the new `user_preferences` table, and the migration script is present in the `/migrations` directory. 

**Verification Status:**
- File existence: **Passed**
- Schema pattern match: **Passed**
```

**Prompt:** 
```
Check if the recent changes broke the build.
```

**Response:** 
```
I ran the build command in your current environment. 

| Step | Result | Details |
| :--- | :--- | :--- |
| Compilation | **Success** | No syntax errors found. |
| Linting | **Success** | All rules satisfied. |
| Unit Tests | **Failed** | 2 tests failed in `auth_service.test.ts`. |

**Action Required:** The build failed due to two failing tests in the authentication service.
```

**Prompt:** 
```
Verify that the new API endpoint was implemented correctly.
```

**Response:** 
```
I performed a full audit of the task. 

*   **Endpoint existence:** Found `/api/v1/status` in the router.
*   **Logic check:** The handler correctly processes the request and returns a 200 status.
*   **Documentation:** The Swagger spec has been updated to include the new route.

**Task Status: 100% Complete**
```

## Capabilities

### Audit task fulfillment
Confirm a task is complete by checking all requirements against the actual workspace state.

### Validate file contents
Check that specific files exist and contain the exact text or patterns you expected.

### Verify environment health
Run shell commands to make sure the local environment or build process is functioning correctly.

### Detect silent failures
Catch instances where an agent claims success but failed to actually write the necessary files.

### Automate technical checks
Trigger build tools or test runners to validate code changes immediately after they happen.

## Use Cases

### Automated Refactoring Audits
An engineer asks an agent to move a function to a new module. The agent uses check_file_integrity to prove the function is gone from the old file and present in the new one.

### CI/CD Pipeline Validation
After an agent modifies a Dockerfile or config, it uses execute_environment_check to run a build command and confirm the environment is still healthy.

### Feature Implementation Proof
A developer tasks an agent with adding a new API endpoint. The agent uses verify_task_completion to check that the route exists and the handler logic is present.

### Dependency Update Verification
When an agent updates a package, it uses execute_environment_check to run the project's test suite to ensure no breaking changes occurred.

## Benefits

- Eliminate uncertainty by replacing AI intuition with hard evidence from file and command checks.
- Catch broken builds early by using execute_environment_check to run tests automatically.
- Ensure code accuracy by using check_file_integrity to hunt for specific regex patterns in your files.
- Reduce manual oversight by letting verify_task_completion handle the final audit of complex tasks.
- Prevent silent failures where an agent claims a task is done but the files are missing or incorrect.

## How It Works

The bottom line is you get objective proof of work instead of just an AI's optimistic confirmation.

1. Connect the MCP to your preferred AI client via Vinkius.
2. Instruct your agent to use the verification tools after completing a coding or system task.
3. Receive a deterministic pass or fail report based on real file and command output.

## Frequently Asked Questions

**How can I use claude-task-completion-verifier to check my code?**
You can instruct your agent to check for specific file changes or run your existing test suites to confirm that the code it wrote actually works as intended.

**Can claude-task-completion-verifier run my local tests?**
Yes, it allows your agent to execute shell commands, meaning it can trigger your local test runners, build tools, or any other command-line utility in your workspace.

**Does claude-task-completion-verifier work with any AI client?**
It works with any MCP-compatible client, including Claude, Cursor, and Windsurf, as long as you have it connected through Vinkius.

**How does claude-task-completion-verifier prevent AI errors?**
It prevents errors by providing objective proof. Instead of trusting an agent's claim, it uses real-world checks like file existence and command exit codes to confirm success.

**Is claude-task-completion-verifier useful for DevOps tasks?**
Absolutely. It's perfect for verifying that configuration changes, environment updates, or deployment scripts were applied correctly to your system.

**How does the verification work?**
The engine uses `verify_task_completion` to evaluate specific criteria such as file existence, content matching, or command exit codes to provide a mathematical completion percentage.

**Can I run shell commands?**
Yes, you can use `execute_environment_check` to run any shell command and verify its exit code.

**What is the difference between the tools?**
Use `check_file_integrity` for simple file/pattern checks, `execute_environment_check` for running commands, and `verify_task_completion` for a comprehensive multi-criteria audit.