Critical Thinking Prover MCP for AI. Force deep reasoning or prove task completion.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

Critical Thinking Prover combines two MCP tools: `validate_critical_thinking` and `validate_task_completion`. Use this to force deep reasoning on complex problems or prove that a task is actually finished.

It stops your AI agent from guessing, assuming everything works, or giving you vague conclusions. You get verifiable rigor for both thought processes and code delivery.

What your AI can do

Validate task completion

Verifies that a task is fully done by requiring explicit proof of requirements met, file changes, and execution logs.

Validate critical thinking

Forces the agent to deeply analyze complex problems by surfacing assumptions, applying multiple frameworks, and bounding confidence.

Surface embedded assumptions

Forces the agent to identify the underlying, unstated beliefs that structure the problem.

Apply competing mental models

Requires analyzing a decision through multiple distinct frameworks (e.g., ethical vs. economic).

Weigh balanced evidence

Ensures the agent presents counterarguments with the same rigor as supporting data.

Map second-order effects

Traces potential ripple effects, identifying who loses or what breaks after a change is implemented.

Bound confidence levels

Determines exactly what evidence would need to exist to change the final conclusion.

Verify task delivery integrity

Confirms that every single requirement has been addressed and provides verifiable execution logs.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

Critical Thinking Prover: 2 Tools

These two tools give you complete control over the quality of AI output, whether that's challenging a flawed idea or proving code actually works.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using Critical Thinking Prover on Vinkius

Validate Task Completion

Verifies that a task is fully done by requiring explicit proof of requirements met, file changes, and execution logs.

Validate Critical Thinking

Forces the agent to deeply analyze complex problems by surfacing assumptions...

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The Critical Thinking Prover integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "critical-thinking-prover": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the Critical Thinking Prover tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"critical-thinking-prover": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with Critical Thinking Prover, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,100+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

Critical Thinking Prover MCP server cover

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Critical Thinking Prover. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 2 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

The hardest part about using AI agents isn't getting an answer; it's trusting it.

Today, you often get a wall of text. The agent summarizes the issue, suggests three solutions, and tells you to 'review these points.' You spend time reading through vague bullet points that read like they came from a textbook—nothing actionable, nothing verifiable.

With this MCP, your AI client stops generating summaries and starts demanding evidence. It forces the conversation into structured checks: What are we assuming? Are there other ways to look at this problem? This isn't just better writing; it's a fundamental shift in accountability.

Using validate_task_completion ensures nothing gets skipped.

Manually tracking agent output means checking markdown summaries, then jumping to the terminal for logs, and finally cross-referencing a separate Jira ticket. It's tedious copy-pasting across multiple tabs just to confirm basic completeness.

This MCP consolidates that entire audit trail into one structured verdict. You don't trust the agent's words; you check the proof it generates—the modified files, the test results, and a clear list of outstanding gaps.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

When you're dealing with high-stakes decisions—be it migrating core infrastructure or designing a new business policy—you can’t rely on an AI agent just saying 'it looks good.' Agents often operate by pattern completion, giving answers that sound confident but are fundamentally flawed. This MCP fixes that. It forces your agent to slow down and perform deep checks before committing a verdict.

You'll use it to surface hidden assumptions you didn't even know existed or to map out every unintended consequence of a new feature. The other side is delivery: if an agent says the code is done, this tool makes them prove it by requiring specific file changes, build logs, and clear documentation of any remaining gaps.

It’s about accountability for both thought and execution. You connect everything through Vinkius to get a single source of truth on complex AI outputs.

Built · Hosted · Managed by Vinkius Critical Thinking Prover - Validate Assumptions & Tasks MCP

Server ID 019e58c7-168d-7196-97b3-62b093e8091a

Vinkius Inspector

Compliance Grade A+

Score 100/100

Report View Report ↗

Here's how it actually works

The bottom line is, the MCP acts as an automated quality gatekeeper, preventing your agent from delivering plausible-sounding garbage or incomplete work.

First, run validate_critical_thinking to challenge the problem's foundation. You provide the core dilemma, and the MCP forces the agent to expose its assumptions and explore competing theories.

Next, if the issue is code or task completion, run validate_task_completion. The tool demands a formal checklist, exact file changes, and build logs before accepting any 'finished' status.

The final output is a structured verdict. For thinking, you get a confidence level with conditions; for tasks, you get proof of execution integrity.

Who is this actually for?

Solutions Architects who need to justify major technical pivots; Engineering Managers overseeing complex, multi-stage deployments; and Senior Data Scientists building models that rely on imperfect assumptions.

Solutions Architect

Uses validate_critical_thinking when proposing a new system design to ensure all stakeholders' concerns (behavioral, political, technical) are mapped out.

Engineering Manager

Runs validate_task_completion after every major PR cycle to confirm the agent didn't skip mandatory test runs or documentation updates.

Technical Product Lead

Uses validate_critical_thinking when defining product requirements, ensuring that business goals are not based on a single, unexamined assumption.

What Changes When You Connect

Eliminate false confidence. Instead of an agent giving a simple 'it's fine,' validate_critical_thinking demands you state your assumptions and the conditions under which your conclusion holds true.

Catch scope neglect automatically. When designing features, the tool traces second-order effects, showing who loses or what processes are disrupted when your solution goes live.

Guarantee delivery completeness. Running validate_task_completion means you get a full audit trail: every single requirement is mapped to an action, and execution logs prove it worked.

Avoid confirmation bias. The MCP forces the agent to actively search for counterevidence, so you never mistake finding supporting data for doing actual research.

Structure your thinking. Instead of vague advice, validate_critical_thinking forces you to use named mental models, giving you a defensible and structured rationale.

See it in action

01 01

Re-evaluating the monolith migration plan

A team proposes moving from a large codebase to microservices. Instead of accepting the proposal, running validate_critical_thinking forces them to map out hidden assumptions (e.g., 'our staff can operate K8s') and weigh counterevidence against the complexity cost.

02 02

Closing out a major feature release

The agent claims it fixed all bugs in the payment service. Running validate_task_completion forces the agent to provide specific file paths, line ranges modified, and fresh build logs before declaring the task finished.

03 03

Defining a new global policy

A business unit wants to change hiring practices. Using validate_critical_thinking, they are forced to analyze the decision from multiple frameworks (legal, cultural, financial) and map out who loses if the policy fails.

04 04

Debugging an incomplete agent output

The agent provides a summary but skips key steps. Running validate_task_completion immediately flags 'Remaining Gaps' or 'Unverified Changes,' forcing the agent to complete its work before moving on.

The honest tradeoffs

Assuming certainty

Anti-pattern

The agent responds: 'This is definitely the best approach, 100% certain.' This conclusion gives zero useful information and lacks necessary conditions.

The Fix

Use validate_critical_thinking to bound your confidence. You must state, 'I am 65% confident this works, provided X resources are available and Y change does not occur.'

Claiming work is done without proof

Anti-pattern

The agent says: 'Updated the API endpoints successfully.' This statement modifies nothing and provides no verifiable evidence.

The Fix

Use validate_task_completion. It forces you to list the exact files changed, provide compilation logs, and verify every requirement was addressed.

Ignoring context gaps

Anti-pattern

The agent suggests a fix: 'Just add more caching.' This is shallow advice that ignores network latency or database contention.

The Fix

Use validate_critical_thinking to map out second-order effects. Ask: 'Who loses when we cache this? What feedback loops emerge from the new data flow?'

When It Fits, When It Doesn't

You need this MCP if your work involves high risk, complex dependencies, or critical code changes. Use it if you feel like the AI agent is giving you a confident answer without showing its homework. If you just need to summarize existing knowledge or write boilerplate copy, don't use these tools; they're overkill. However, if you are defining policy, designing architecture, or delivering production-ready code, this MCP is essential. Use validate_critical_thinking when the problem itself is ambiguous. Use validate_task_completion exclusively at the end of any development cycle to prove delivery integrity.

Questions you might have

Does Critical Thinking Prover generate answers to complex problems? +

No. Critical Thinking Prover performs zero content generation. It forces the AI agent to structure its own reasoning into verifiable fields — assumptions, frameworks, evidence, consequences, confidence bounds — then validates that the reasoning is logically consistent. The agent does all the thinking. The tool catches blind spots.

How is this different from Sequential Thinking? +

Sequential Thinking structures thoughts in a linear chain — step 1, step 2, step 3. It's domain-agnostic and doesn't validate reasoning quality. Critical Thinking Prover is orthogonal: it doesn't sequence thoughts, it validates that the reasoning addresses five specific cognitive failure modes — assumption blindness, mono-perspective, confirmation bias, scope neglect, and false precision. You can use both together: Sequential Thinking to decompose the problem, Critical Thinking Prover to validate the conclusion.

What types of problems does this apply to? +

Any complex problem where the answer is not obvious and the reasoning matters more than the conclusion. Technical architecture decisions, business strategy, policy design, ethical dilemmas, resource allocation, organizational restructuring, risk assessment, investment analysis, product prioritization. If the problem has competing frameworks, hidden trade-offs, and uncertain outcomes — this tool forces the agent to reason through them instead of pattern-matching to a confident-sounding answer.

Can the agent still reach a 'wrong' conclusion after passing validation? +

Yes — and that's by design. Critical Thinking Prover validates reasoning PROCESS, not reasoning OUTCOMES. A conclusion can be well-reasoned and still turn out wrong — that's the nature of complex problems. What the tool guarantees is that the reasoning considered assumptions, multiple perspectives, counterevidence, consequences, and uncertainty bounds. A well-structured wrong answer is infinitely more useful than a confidently stated right one — because you can see WHERE the reasoning might break.

If `validate_critical_thinking` rejects my output, what does that mean for my project? +

Rejection means your reasoning has a structural blind spot. The MCP forces you to address specific flaws—like hidden assumptions or insufficient counterevidence—before moving forward. You must correct the underlying logic first.

How do I integrate the Critical Thinking Prover MCP into my existing AI workflow? +

You connect your preferred AI client through Vinkius. This single connection gives you access to all available tools, letting you apply deep reasoning without modifying your current development environment.

When should I use `validate_task_completion` in my agent pipeline? +

Use this tool immediately after the agent completes any task or delivers code. It forces proof by requiring specific details, like file paths and compilation logs, rather than just a 'done' statement.

What kind of data does `validate_critical_thinking` require to be useful? +

It needs complex decision inputs—not simple facts. The prompt must contain enough detail to warrant weighing multiple opposing viewpoints and mapping second-order consequences.

View all recipes →

MCP Servers for Reliable A/B Test Analysis

A/B test results interrogated for hidden assumptions, statistical validity verified before shipping , stop making product decisions on p-values alone

Critical Thinking Prover Data Analysis Prover

Stress-Test Hot Takes Before Publishing via MCP

Hidden assumptions exposed, counterarguments steelmanned, source bias detected , publish contrarian takes that survive intellectual combat

Critical Thinking Prover Journalistic Reasoning Prover

View all recipes

Connect to your AI in seconds.

Validate task completion

Validate critical thinking

Critical Thinking Prover: 2 Tools

Make your AI actually useful.

Validate Task Completion

Validate Critical Thinking

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

The hardest part about using AI agents isn't getting an answer; it's trusting it.

Using validate_task_completion ensures nothing gets skipped.

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Re-evaluating the monolith migration plan

Closing out a major feature release

Defining a new global policy

Debugging an incomplete agent output

The honest tradeoffs

Assuming certainty

Claiming work is done without proof

Ignoring context gaps

When It Fits, When It Doesn't

Questions you might have

Powerful workflows you can unlock today

MCP Servers for Reliable A/B Test Analysis

Stress-Test Hot Takes Before Publishing via MCP