# Critical Thinking Prover MCP for AI Agents AI Agent Connect > Critical Thinking Prover MCP forces your AI agent to stop guessing and start reasoning. It breaks the habit of hallucinated confidence by requiring the agent to map out hidden assumptions, weigh counter-evidence, and trace second-order consequences before it gives you an answer. It is for high-stakes decisions where 'it should work' isn't good enough. ## Overview - **Category:** productivity - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_HnRM4jwjWWzTcwIx1fdDtyj5utGoROvccTsTLtXH/ai-agent-connect - **Tags:** critical-thinking, reasoning-validation, structured-reasoning, decision-pivots, cognitive-debiasing, complex-problems, meta-cognition, agentic-pipeline ## Description Critical Thinking Prover forces your AI agent to stop guessing and start reasoning. You know the feeling of asking an AI for a strategy and getting a generic, confident list of bullet points that don't actually address your specific constraints. It's not just a lack of knowledge; it's a lack of rigor. This Connector changes that by turning your AI agent into a rigorous analyst. It forces the agent to stop at the "obvious" answer and dig into the messy stuff: what are we assuming to be true? What does the competition think? Who gets hurt if we do this? By making these steps mandatory, the agent can't just complete the pattern. It has to build a defensible case. When you use this through the Vinkius catalog, you're giving your AI agent a set of guardrails that demand high-quality reasoning for every complex prompt you send. It turns a hallucinated guess into a structured, multi-perspective analysis that you can actually trust in a boardroom or a technical review. Instead of accepting the first thing the model spits out, you get a breakdown of hidden assumptions, competing frameworks, and second-order consequences. This means your agent won't just tell you that a migration is a good idea; it will tell you who loses when it succeeds, what the training costs are, and what specific conditions would make the plan fail. It moves the needle from simple pattern completion to actual, defensible logic. ## Tools ### validate_critical_thinking The agent is forced to surface assumptions, weigh evidence for and against, and bound its confidence. This provides a defensible case for complex decisions. ### validate_task_completion The agent maps every prompt requirement to a specific file change or action with proof. This ensures you never receive a done message without a verifiable checklist. ## Prompt Examples **Prompt:** ``` Should we move our customer data to a new provider? What are the risks? ``` **Response:** ``` ### Decision Analysis: Data Migration **Verdict: REASONING_PROVEN** **Hidden Assumptions:** * Assumes the new provider's API is compatible with current schemas. * Assumes the data team has the bandwidth for a 3-month migration. **Competing Frameworks:** * *Economic:* High upfront cost vs long-term savings. * *Risk:* Potential for downtime during cutover. **Evidence For:** * Lower monthly OpEx by 15%. * Better compliance features. **Evidence Against:** * Proprietary lock-in risks. * Potential for data loss during transit. **Second-Order Effects:** * Increased training time for the support team. * Potential friction in the developer onboarding flow. **Confidence:** 70%. Would reverse if the migration cost exceeds $50k or if downtime exceeds 4 hours. ``` **Prompt:** ``` I want to automate our onboarding. What are the hidden assumptions here? ``` **Response:** ``` ### Assumption Audit: Onboarding Automation **Verdict: ASSUMPTION_BLIND** Your current plan has several unexamined premises: 1. **Assumption:** Users want a faster flow. *Counter:* Users might prefer a slower, more guided flow to ensure they don't miss setup steps. 2. **Assumption:** The current bottleneck is manual entry. *Counter:* The bottleneck might be the lack of clear documentation. 3. **Assumption:** The engineering team can build this in one sprint. *Counter:* Integration with legacy CRM systems often takes longer than expected. **Next Steps:** Define the specific bottleneck before building the automation. ``` **Prompt:** ``` Check my code migration. Did I actually do everything the user asked for? ``` **Response:** ``` ### Task Completion Audit **Verdict: UNVERIFIED_CHANGES** I have reviewed the changes against your requirements: | Requirement | Status | Evidence | | :--- | :--- | :--- | | Update user schema | ✅ Done | `models/user.py` lines 45-60 | | Add auth middleware | ✅ Done | `middleware/auth.py` added | | Update docs | ❌ Missing | No changes found in `/docs` | | Run migrations | ❌ Missing | No build logs provided | **Remaining Gaps:** * Documentation update required. * Need to provide execution logs for the migration script to confirm success. ``` ## Capabilities ### Expose hidden assumptions The agent identifies the underlying beliefs about causality and scope that are often taken for granted. ### Apply competing frameworks The agent analyzes the problem through multiple named mental models like economic, behavioral, or first-principles lenses. ### Weigh counter-evidence The agent is forced to actively seek and evaluate the strongest arguments against its own proposed conclusion. ### Map second-order consequences The agent traces ripple effects such as unintended incentives, resource consumption, and feedback loops. ### Bound confidence levels The agent provides specific conditions that would reverse its conclusion instead of claiming 100% certainty. ### Audit task completion The agent proves it finished every requirement by mapping them to specific file changes and execution logs. ## Use Cases ### Cloud Migration Strategy Deciding on a cloud migration where the agent must weigh cost-of-delay against team expertise and operational complexity. ### Product Launch Analysis Analyzing a new feature where the agent must identify hidden assumptions about user behavior and potential friction. ### Policy Design Review Evaluating a company policy where the agent must trace ripple effects on different departments and unintended incentives. ### Code Refactor Audit Verifying a complex refactor where the agent must prove every requirement was met with actual execution logs. ## Benefits - Stop confirmation bias by forcing the agent to find evidence against its own plan using validate_critical_thinking. - Eliminate it should work excuses by requiring actual execution logs and file paths with validate_task_completion. - Avoid scope neglect by mapping second-order effects like training costs or team velocity drops. - Get honest risk assessments by forcing the agent to state what conditions would reverse its conclusion. - Move past platitudes like it depends by demanding a committed position based on named mental models. ## How It Works The bottom line is that your agent stops giving you easy answers and starts giving you defensible ones. 1. Send a complex prompt or decision request to your agent. 2. The agent triggers the pivots to evaluate its own logic before finishing. 3. You receive a verified verdict with explicit evidence and risk bounds. ## Frequently Asked Questions **How does Critical Thinking Prover stop AI hallucinations?** It forces the agent to identify its own assumptions and provide evidence for and against a conclusion. By making it find the 'why' and the 'what if it fails', the agent is less likely to just guess a confident but incorrect answer. **Can I use Critical Thinking Prover for business strategy?** Yes. It is specifically designed to help with high-level planning by mapping out second-order consequences and applying different mental models like economic or behavioral frameworks. **How does Critical Thinking Prover handle complex technical decisions?** It breaks down technical choices into defensible cases. It forces the agent to look at things like team velocity, training costs, and long-term architectural debt instead of just giving you a quick fix. **Does Critical Thinking Prover help with risk management?** Absolutely. It requires the agent to bound its confidence and state exactly what conditions would cause its conclusion to be wrong, which is a core part of professional risk assessment. **What makes Critical Thinking Prover different from a standard system prompt?** Standard prompts are suggestions the AI can ignore. This Connector creates mandatory checkpoints and schema requirements that the agent must satisfy to provide a final answer. **Can I use Critical Thinking Prover to audit my agent's work?** Yes, the task completion tool is perfect for this. It forces the agent to provide a checklist mapping every single requirement to a specific change or log. **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.