Skip to main content
Glama

Elenchus MCP Server

English | 한국어

Adversarial Code Verification System using Verifier↔Critic Debate Loop

Elenchus (ἔλεγχος): Socrates' method of refutation through systematic questioning - exposing contradictions to reach truth.

npm version License: MIT Node.js TypeScript MCP MCP Badge

Related MCP server: vibe-gate-mcp

Table of Contents


Overview

Elenchus is a Model Context Protocol (MCP) server that implements adversarial code verification. Unlike simple linting or static analysis, Elenchus orchestrates a debate between Verifier and Critic agents to systematically uncover issues through dialectical reasoning.

Why Adversarial Verification?

Traditional Approach

Elenchus Approach

Single-pass analysis

Multi-round debate

Checklist-based

Intent-based semantic analysis

Fixed rules

Adaptive convergence

Silent on clean code

Explicit negative assertions

The Verifier↔Critic Loop

┌──────────────────────────────────────────────────────────────┐
│                    VERIFICATION LOOP                          │
├──────────────────────────────────────────────────────────────┤
│  Round 1: Verifier → Examines code, RAISES issues            │
│  Round 2: Critic   → Challenges issues (VALID/INVALID/PARTIAL)│
│  Round 3: Verifier → Defends, resolves, or finds new issues  │
│  Round 4: Critic   → Re-evaluates, checks coverage           │
│  ...continues until convergence...                            │
│  Final: Verdict (PASS / FAIL / CONDITIONAL)                  │
└──────────────────────────────────────────────────────────────┘

Key Features

🔄 Adversarial Debate System

  • Verifier: Finds issues with evidence

  • Critic: Challenges findings, validates claims

  • Role Enforcement: Strict alternation with compliance scoring

📊 Intent-Based Convergence

  • Semantic understanding instead of keyword matching

  • 5 category coverage (Security, Correctness, Reliability, Maintainability, Performance)

  • Edge case documentation requirements

  • Negative assertions for clean code

🧠 LLM-Based Evaluation (Optional)

  • Convergence Assessment: LLM judges verification quality (vs rigid boolean checks)

  • Severity Classification: Context-aware impact analysis

  • Edge Case Validation: Verifies actual analysis, not just keyword presence

  • False Positive Detection: Evidence-based issue validation

🔍 Automatic Impact Analysis

  • Multi-language dependency graph (15 languages via tree-sitter)

  • Ripple effect prediction

  • Cascade depth calculation

  • Risk level assessment

🌐 Multi-Language Support

Dependency analysis powered by tree-sitter AST parsing:

Category

Languages

Web

TypeScript, TSX, JavaScript, CSS

Systems

Rust, Go, C, C++

Enterprise

Java, C#

Scripting

Python, Ruby, PHP, Bash, PowerShell

💾 Session Management

  • Checkpoint/rollback support

  • Global session storage

  • Audit trail preservation

⚡ Token Optimization (Optional)

  • Differential analysis (verify only changed code)

  • Response caching

  • Selective chunking

  • Tiered verification pipeline


Quick Start

Add to your MCP client configuration:

{
  "mcpServers": {
    "elenchus": {
      "command": "npx",
      "args": ["-y", "@jhlee0409/elenchus-mcp"]
    }
  }
}

Then use naturally with your AI assistant:

"Please verify src/auth for security issues"

See Installation for client-specific setup instructions.


Installation

Supported Clients

Client

Status

Notes

Claude Desktop

✅ Supported

macOS, Windows

Claude Code

✅ Supported

CLI tool

VS Code (Copilot)

✅ Supported

Requires v1.102+

Cursor

✅ Supported

40 tool limit applies

Other MCP Clients

✅ Compatible

Any stdio-based client

Claude Desktop

Add to your Claude Desktop configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "elenchus": {
      "command": "npx",
      "args": ["-y", "@jhlee0409/elenchus-mcp"]
    }
  }
}

Claude Code

Add to your Claude Code settings (.mcp.json or ~/.claude/settings.json):

{
  "mcpServers": {
    "elenchus": {
      "command": "npx",
      "args": ["-y", "@jhlee0409/elenchus-mcp"]
    }
  }
}

VS Code (GitHub Copilot)

Add to .vscode/mcp.json:

{
  "mcp": {
    "servers": {
      "elenchus": {
        "command": "npx",
        "args": ["-y", "@jhlee0409/elenchus-mcp"]
      }
    }
  }
}

Cursor

Go to Settings > MCP > Add new global MCP Server:

{
  "mcpServers": {
    "elenchus": {
      "command": "npx",
      "args": ["-y", "@jhlee0409/elenchus-mcp"]
    }
  }
}

Usage

Simply describe what you want to verify:

"Verify src/auth for security vulnerabilities"
"Check the payment module for edge cases"
"Review src/api for correctness and reliability issues"

Your AI assistant will automatically use Elenchus tools.

For structured workflows, see MCP Prompts.


MCP Tools Reference

Session Lifecycle

elenchus_start_session

Initialize a new verification session.

Inputs:

  • target (string, required): Target path to verify (file or directory)

  • requirements (string, required): Verification requirements/focus areas

  • workingDir (string, required): Working directory for relative paths

  • maxRounds (number, optional): Maximum rounds before stopping (default: 10)

  • verificationMode (object, optional): Mode configuration

    • mode: "standard" | "fast-track" | "single-pass"

    • skipCriticForCleanCode: boolean

  • differentialConfig (object, optional): Verify only changed files

  • cacheConfig (object, optional): Cache previous verifications

  • chunkingConfig (object, optional): Split large files into chunks

  • pipelineConfig (object, optional): Tiered verification

  • llmEvalConfig (object, optional): LLM-based evaluation settings

    • enabled: boolean - Enable LLM evaluation

    • convergenceEval: boolean - Use LLM for convergence quality

    • severityEval: boolean - Use LLM for severity classification

    • edgeCaseEval: boolean - Use LLM for edge case validation

    • falsePositiveEval: boolean - Use LLM for false positive detection

Returns: Session ID and initial context including files collected, dependency graph stats, and role configuration.

Example:

elenchus_start_session({
  target: "src/auth",
  requirements: "Security audit for authentication",
  workingDir: "/path/to/project",
  verificationMode: { mode: "fast-track" }
})

elenchus_get_context

Get current session context including files, issues, and proactive guidance.

Inputs:

  • sessionId (string, required): The session ID

Returns: Files, issues summary, focus areas, unreviewed files, recommendations.

elenchus_submit_round

Submit a Verifier or Critic round.

Inputs:

  • sessionId (string, required): The session ID

  • role ("verifier" | "critic", required): Role for this round

  • output (string, required): Full agent analysis output

  • issuesRaised (Issue[], optional): New issues (Verifier role)

  • issuesResolved (string[], optional): Resolved issue IDs (Critic role)

Issue Schema:

{
  id: string,
  category: "SECURITY" | "CORRECTNESS" | "RELIABILITY" | "MAINTAINABILITY" | "PERFORMANCE",
  severity: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW",
  summary: string,
  location: string,        // "file:line" format
  description: string,
  evidence: string         // Code snippet or proof
}

Returns: Round number, convergence status, mediator interventions, role compliance score.

elenchus_end_session

End session with final verdict.

Inputs:

  • sessionId (string, required): The session ID

  • verdict ("PASS" | "FAIL" | "CONDITIONAL", required): Final verdict

Returns: Session summary including total rounds, issues by category and severity.

elenchus_get_issues

Query issues with optional filtering.

Inputs:

  • sessionId (string, required): The session ID

  • status ("all" | "unresolved" | "critical", optional): Filter by status

Returns: Array of issues matching the filter.

Additional Tools (31 more)

Beyond the core tools above, Elenchus provides 31 additional tools for advanced workflows:

Category

Tools

LLM Evaluation

elenchus_evaluate_convergence, elenchus_evaluate_severity, elenchus_evaluate_edge_cases, elenchus_submit_llm_evaluation

State Management

elenchus_checkpoint, elenchus_rollback, elenchus_apply_fix

Analysis

elenchus_ripple_effect, elenchus_mediator_summary

Role Enforcement

elenchus_get_role_prompt, elenchus_role_summary, elenchus_update_role_config

Re-verification

elenchus_start_reverification

Differential

elenchus_save_baseline, elenchus_get_diff_summary, elenchus_get_project_history

Cache

elenchus_get_cache_stats, elenchus_clear_cache

Pipeline

elenchus_get_pipeline_status, elenchus_escalate_tier, elenchus_complete_tier

Safeguards

elenchus_get_safeguards_status, elenchus_update_confidence, elenchus_record_sampling_result, elenchus_check_convergence_allowed

Optimization

elenchus_set_compression_mode, elenchus_get_optimization_stats, elenchus_configure_optimization, elenchus_estimate_savings

Dynamic Roles

elenchus_generate_roles, elenchus_set_dynamic_roles

All tools are auto-discovered by MCP clients. Use MCP Inspector (npm run inspector) for detailed schemas.


MCP Resources

Access session data via URI-based resources:

URI Pattern

Description

elenchus://sessions/

List all active sessions

elenchus://sessions/{sessionId}

Get specific session details

Usage:

Read elenchus://sessions/
Read elenchus://sessions/2026-01-17_src-auth_abc123

MCP Prompts (Slash Commands)

Prompt Name

Description

verify

Run complete Verifier↔Critic loop

consolidate

Create prioritized fix plan

apply

Apply fixes with verification

complete

Full pipeline until zero issues

cross-verify

Adversarial cross-verification

Invocation format varies by client. Check your MCP client's documentation.


Verification Modes

Three modes for different use cases:

Mode

Min Rounds

Critic Required

Best For

standard

3

Yes

Thorough verification

fast-track

1

Optional

Quick validation

single-pass

1

No

Fastest, Verifier-only

Example:

elenchus_start_session({
  target: "src/",
  requirements: "Security audit",
  workingDir: "/project",
  verificationMode: {
    mode: "fast-track",
    skipCriticForCleanCode: true
  }
})

Issues transition through states:

RAISED → CHALLENGED → RESOLVED
           ↓
        DISMISSED (false positive)
           ↓
        MERGED (combined)
           ↓
        SPLIT (divided)

Issue States

Status

Description

RAISED

Initially discovered by Verifier

CHALLENGED

Under debate between Verifier and Critic

RESOLVED

Fixed and verified

DISMISSED

Invalidated as false positive

MERGED

Combined with another issue

SPLIT

Divided into multiple issues

Critic Verdicts

Verdict

Meaning

VALID

Issue is legitimate

INVALID

False positive

PARTIAL

Partially valid, needs refinement

A session converges when ALL criteria are met:

  • No CRITICAL or HIGH severity unresolved issues

  • Stable for 2+ rounds (no new issues)

  • Minimum rounds completed (varies by mode)

  • All 5 categories examined

  • No recent issue state transitions

  • Edge cases documented

  • Clean areas explicitly stated (negative assertions)

  • High-risk impacted files reviewed

Category Coverage

All 5 categories must be examined:

  1. SECURITY - Authentication, authorization, injection

  2. CORRECTNESS - Logic errors, type mismatches

  3. RELIABILITY - Error handling, resource management

  4. MAINTAINABILITY - Code structure, documentation

  5. PERFORMANCE - Efficiency, resource usage


Token Optimization

Verify only changed files:

{
  differentialConfig: {
    enabled: true,
    baseRef: "main"  // Compare against main branch
  }
}

Cache previous verification results:

{
  cacheConfig: {
    enabled: true,
    ttlSeconds: 3600  // Cache for 1 hour
  }
}

Split large files into focused chunks:

{
  chunkingConfig: {
    enabled: true,
    maxChunkSize: 500  // Lines per chunk
  }
}

Start with quick analysis, escalate if needed:

{
  pipelineConfig: {
    enabled: true,
    startTier: "screen"  // screen → focused → exhaustive
  }
}

Configuration

Environment Variables

Variable

Description

Default

ELENCHUS_DATA_DIR

Custom storage directory

~/.elenchus

XDG_DATA_HOME

XDG base directory (Linux/macOS)

-

LOCALAPPDATA

Windows AppData location

-

Storage Location

Sessions and data are stored in a client-agnostic location:

~/.elenchus/
├── sessions/          # Verification sessions
├── baselines/         # Differential analysis baselines
├── cache/             # Response cache
└── safeguards/        # Quality safeguards data

Priority Order:

  1. $ELENCHUS_DATA_DIR - Explicit override

  2. $XDG_DATA_HOME/elenchus - XDG spec

  3. %LOCALAPPDATA%\elenchus - Windows

  4. ~/.elenchus - Default fallback

Custom Storage

# Set custom location
export ELENCHUS_DATA_DIR=/path/to/custom/storage

# Or use XDG spec
export XDG_DATA_HOME=~/.local/share

Session Cleanup

Sessions are preserved as audit records. Manual cleanup:

rm -rf ~/.elenchus/sessions/*
# Or for specific sessions
rm -rf ~/.elenchus/sessions/2026-01-17_*

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                       ELENCHUS MCP SERVER                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌──────────────────────────────────────────────────────────────┐  │
│  │                     MCP PROTOCOL LAYER                        │  │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────────┐ │  │
│  │  │  Tools   │  │Resources │  │ Prompts  │  │ Notifications│ │  │
│  │  │  (36)    │  │  (URI)   │  │   (5)    │  │  (optional)  │ │  │
│  │  └────┬─────┘  └────┬─────┘  └────┬─────┘  └──────────────┘ │  │
│  └───────┼─────────────┼─────────────┼──────────────────────────┘  │
│          │             │             │                              │
│  ┌───────┴─────────────┴─────────────┴──────────────────────────┐  │
│  │                       CORE MODULES                            │  │
│  │  Session Manager │ Context Manager │ Mediator System          │  │
│  │  Role Enforcement │ Issue Lifecycle │ Pipeline (Tiered)       │  │
│  └───────────────────────────────────────────────────────────────┘  │
│                              │                                       │
│                              ▼                                       │
│                    ┌──────────────────┐                             │
│                    │     STORAGE      │                             │
│                    │ ~/.elenchus/     │                             │
│                    └──────────────────┘                             │
└─────────────────────────────────────────────────────────────────────┘

Module Responsibilities

Module

Purpose

Session Manager

Create, persist, and manage verification sessions

Context Manager

Collect and organize target files and dependencies

Mediator System

Multi-language dependency graphs (tree-sitter), issue detection, interventions

Role Enforcement

Ensure Verifier↔Critic alternation, validate compliance

Issue Lifecycle

Track issue states from RAISED to RESOLVED

Pipeline

Tiered verification (screen → focused → exhaustive)


Security

Security Model

Elenchus operates with the following security considerations:

  • No Code Execution: Elenchus does NOT execute the code it verifies. It performs static analysis only.

  • Local Storage: All session data is stored locally in ~/.elenchus/. No data is sent to external servers.

  • Path Validation: All file paths are validated to prevent path traversal attacks.

  • No Secrets in Output: Tool outputs are sanitized to avoid exposing sensitive data.

Permissions

Elenchus requires:

  • Read access to target files for verification

  • Write access to ~/.elenchus/ for session storage

Reporting Security Issues

Please report security vulnerabilities via GitHub Security Advisories.


Troubleshooting

Common Issues

Symptom: Your MCP client doesn't recognize Elenchus commands or tools.

Solutions:

  1. Verify installation in your client's MCP settings

  2. Restart your MCP client after adding the server

  3. Check config syntax (JSON must be valid)

  4. Ensure Node.js ≥18 is installed:

    node --version

Symptom: Error "Session not found: xxx"

Solutions:

  1. List active sessions:

    Read elenchus://sessions/
  2. Sessions may have been cleaned up - start a new session

  3. Verify session ID is correct (check for typos)

Symptom: Cannot read files or write sessions.

Solutions:

  1. Check file permissions on target directory

  2. Verify write access to ~/.elenchus/:

    ls -la ~/.elenchus/
  3. Try custom storage location:

    export ELENCHUS_DATA_DIR=/tmp/elenchus

Symptom: Round rejected due to compliance score.

Solutions:

  1. Check current role requirements:

    elenchus_get_role_prompt({ role: "verifier" })
  2. Lower minimum compliance score:

    elenchus_update_role_config({
      sessionId: "...",
      minComplianceScore: 50,
      strictMode: false
    })
  3. Ensure role alternation (Verifier → Critic → Verifier)

Debugging

Use MCP Inspector for debugging:

npm run inspector
# or
npx @modelcontextprotocol/inspector node dist/index.js

Getting Help


Development

Build Commands

npm run build      # Compile TypeScript to dist/
npm run dev        # Watch mode with auto-rebuild
npm run start      # Run the compiled server
npm run inspector  # Launch MCP Inspector for debugging

Project Structure

elenchus-mcp/
├── src/
│   ├── index.ts           # Entry point, MCP server setup
│   ├── tools/             # Tool definitions and handlers
│   ├── resources/         # Resource definitions
│   ├── prompts/           # Prompt templates
│   ├── types/             # TypeScript interfaces
│   ├── state/             # Session and context management
│   ├── mediator/          # Multi-language dependency analysis (tree-sitter)
│   ├── roles/             # Role enforcement
│   ├── config/            # Configuration constants
│   ├── cache/             # Response caching
│   ├── chunking/          # Code chunking
│   ├── diff/              # Differential analysis
│   ├── pipeline/          # Tiered verification
│   └── safeguards/        # Quality safeguards
├── dist/                  # Compiled output
├── package.json
├── tsconfig.json
└── README.md

Contributing

Contributions welcome! Please:

  1. Fork the repository

  2. Create a feature branch

  3. Submit a pull request


License

MIT

Available Tools

36 tools
elenchus_apply_fixA

Apply a fix for an issue within the current session. Creates checkpoint, updates issue status, refreshes file context, and optionally triggers re-verification. Use this to maintain fix-verify continuity without starting new sessions.

Inputs: sessionId (required), issueId (required), fixDescription (required), filesModified (required), +1 more.

elenchus_check_convergence_allowedB

Check if session convergence is allowed based on quality safeguards.

Inputs: sessionId (required), strictMode.

elenchus_checkpointB

Create a checkpoint for potential rollback.

Inputs: sessionId (required).

elenchus_clear_cacheB

Clear all cached verification results. Requires confirm: true.

Inputs: confirm (required).

elenchus_complete_tierC

Mark the current tier as complete and check for auto-escalation based on issues found.

Inputs: sessionId (required), filesVerified (required), issuesFound (required), criticalIssues (required), +3 more.

elenchus_configure_optimizationC

Configure token optimization settings including compression, context management, and semantic caching.

Inputs: compression, context, semanticCache.

elenchus_end_sessionB

End the verification session with a final verdict.

Inputs: sessionId (required), verdict (required).

elenchus_escalate_tierA

Manually escalate to a higher verification tier (screen → focused → exhaustive).

Inputs: sessionId (required), targetTier (required), reason (required), scope.

elenchus_estimate_savingsC

Estimate potential token savings for a verification session.

Inputs: totalTokens (required), expectedRounds (required), sessionType.

elenchus_evaluate_convergenceC

Get LLM evaluation prompt for convergence quality assessment. Returns a prompt to send to an LLM.

Inputs: sessionId (required).

elenchus_evaluate_edge_casesA

Get LLM evaluation prompt for edge case coverage. Returns a prompt to send to an LLM.

Inputs: sessionId (required).

elenchus_evaluate_severityB

Get LLM evaluation prompt for issue severity assessment. Returns a prompt to send to an LLM.

Inputs: sessionId (required), issueId (required), codeContext.

elenchus_generate_rolesA

Generate customized Verifier/Critic role prompts based on user requirements. This is a 3-step process:

  1. detect_domain - Detects the verification domain from requirements

  2. generate_verifier - Generates Verifier role (needs domain result)

  3. generate_critic - Generates Critic role (needs verifier role)

Each step returns a prompt to send to an LLM. After all 3 steps, call elenchus_set_dynamic_roles with the results.

Inputs: sessionId (required), step (required), previousResult.

elenchus_get_cache_statsB

Get cache statistics including hit rate, total entries, and token savings.

Inputs: workingDir.

elenchus_get_contextB

Get current verification context including files, issues summary, and session state.

Inputs: sessionId (required).

elenchus_get_diff_summaryA

Get differential analysis summary for a project. Shows what has changed since the last verification and estimates token savings.

Inputs: workingDir (required), baseRef.

elenchus_get_issuesB

Get issues from the current session with optional filtering.

Inputs: sessionId (required), status.

elenchus_get_optimization_statsB

Get current token optimization statistics and recommendations.

Inputs: sessionId (required).

elenchus_get_pipeline_statusB

Get current tier pipeline status including completed tiers, escalations, and token usage.

Inputs: sessionId (required).

elenchus_get_project_historyB

Get verification history for a project including past sessions and baselines.

Inputs: workingDir (required).

elenchus_get_role_promptA

Get detailed role prompt and guidelines for Verifier or Critic. Includes mustDo/mustNotDo rules, output templates, and checklists.

Inputs: role (required).

elenchus_get_safeguards_statusB

Get quality safeguards status including periodic verification, confidence, and sampling stats.

Inputs: sessionId (required), projectId (required).

elenchus_mediator_summaryA

Get mediator summary including dependency graph stats, verification coverage, and intervention history.

Inputs: sessionId (required).

elenchus_record_sampling_resultB

Record results from random sampling verification of a skipped file.

Inputs: sessionId (required), filePath (required), issuesFound (required), severities (required).

elenchus_ripple_effectA

Analyze ripple effect of a code change. Shows which files and functions will be affected by modifying a specific file.

Inputs: sessionId (required), changedFile (required), changedFunction.

elenchus_role_summaryB

Get role enforcement summary including compliance history, average scores, violations, and current expected role.

Inputs: sessionId (required).

elenchus_rollbackC

Rollback session to a previous checkpoint.

Inputs: sessionId (required), toRound (required).

elenchus_save_baselineA

Save verification baseline after a successful session. This baseline is used for differential analysis in future verifications to only check changed code.

Inputs: sessionId (required), workingDir (required).

elenchus_set_compression_modeC

Set the response compression mode for token optimization. Use "compact" for moderate savings or "minimal" for aggressive savings.

Inputs: mode (required).

elenchus_set_dynamic_rolesA

Set dynamically generated roles for a session. Call this after completing all 3 steps of elenchus_generate_roles. The roles will be used automatically by getRolePrompt when sessionId is provided.

Inputs: sessionId (required), domainResult (required), verifierRole (required), criticRole (required).

elenchus_start_reverificationA

Start a re-verification session for resolved issues. Links to a previous verification session and focuses on verifying that fixes are correct and complete. Returns focused verification context with target issues.

Inputs: previousSessionId (required), workingDir (required), targetIssueIds, maxRounds.

elenchus_start_sessionB

Start a new Elenchus verification session. Collects initial context, builds dependency graph, and initializes mediator.

Inputs: target (required), requirements (required), workingDir (required), maxRounds, +8 more.

elenchus_submit_llm_evaluationB

Submit LLM evaluation response. Call this after receiving an LLM response to an evaluation prompt.

Inputs: sessionId (required), evaluationType (required), llmResponse (required), targetId.

elenchus_submit_roundA

Submit the output of a verification round. Analyzes for new issues, context expansion, convergence, and mediator interventions.

Inputs: sessionId (required), role (required), output (required), issuesRaised, +1 more.

elenchus_update_confidenceB

Update confidence scores for files based on verification method (cache, chunk, tiered, etc.).

Inputs: sessionId (required), fileConfidences (required).

elenchus_update_role_configC

Update role enforcement configuration. Can enable strict mode, change minimum compliance score, or toggle role alternation requirement.

Inputs: sessionId (required), strictMode, minComplianceScore, requireAlternation.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 36 tools

    Disambiguation4/5

    Most tools have clearly distinct purposes (e.g., start_session vs. start_reverification), but there is some overlap in concept among multiple 'get' tools and evaluation prompts that could cause minor confusion. Overall, descriptions help differentiate them.

    Naming Consistency5/5

    All tools follow a consistent 'elenchus_verb_noun' pattern using snake_case. The naming is predictable and uniform across the entire tool set.

    Tool Count3/5

    36 tools is on the higher side for an MCP server. While the domain (code verification) is complex, this many tools can overwhelm an agent. Some tools might be consolidated, but the scope justifies the count.

    Completeness5/5

    The tool surface covers the full verification lifecycle: session management, context gathering, role generation, evaluation prompts, result submission, rollback, caching, optimization, and history. No obvious gaps for the stated purpose.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      A
      maintenance
      An MCP server that enables dialectical reasoning by forcing separate thesis, antithesis, and synthesis passes over questions, and verifies code implementations through an independent player-coach loop with explicit approval gates. It works in Claude Desktop, Cursor, VS Code, Windsurf, and other MCP-enabled editors without API keys.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables LLMs to perform dialectical reasoning (Thesis → Antithesis → Synthesis) and player-coach verified code synthesis through structured MCP tools. It helps catch blind spots and verify requirements by forcing models to argue with themselves before concluding.
      -