# First Principles Prover MCP > First Principles Prover forces your AI agent to build solutions from fundamental truths—pure math, physics, or logic—instead of relying on industry buzzwords or common patterns. It’s a cognitive trap that strips away jargon like 'synergy' and 'leverage.' If you need an architecture solution that can withstand deep academic scrutiny, this engine proves the derivation step-by-step. ## Overview - **Category:** reasoning - **Price:** Free - **Tags:** first-principles, cognitive-forcing, mental-models, logic, multilingual, axioms ## Description Your agent often gives answers that sound convincing but are just echoes of what other companies did last year. It reasons by analogy. Instead, this MCP forces your AI to think from scratch. Before it outputs anything, it runs a strict six-point validation check. This process demands the agent discard all industry conventions and boil the problem down to its raw physics or mathematics. You don't get 'best practices'; you get provable derivations. It breaks the habit of pattern matching by demanding an axiomatic proof for every claim. By connecting this MCP via Vinkius, your AI client gains a deep layer of rigorous testing that prevents vague buzzwords from polluting critical architectural decisions. ## Tools ### validate_first_principles Runs a full validation check that forces the agent to discard analogies, isolate fundamental truths, deconstruct assumptions, derive solutions from axioms, and construct mathematical proof. ## Prompt Examples **Prompt:** ``` Let's leverage industry best practices to build this. ``` **Response:** ``` Verdict: JARGON_DETECTED. You used the corporate buzzword 'leverage'. First principles thinkers speak in plain, fundamental terms. ``` **Prompt:** ``` Analogies: discarding REST APIs. Truths: I think gRPC is better. Assumptions: REST is slow. ``` **Response:** ``` Verdict: ANALOGY_DETECTED. Your 'truths' are just opinions. A fundamental truth must be grounded in physics, math, or raw limits (e.g., bits per second). ``` **Prompt:** ``` Truths: Data cannot travel faster than the speed of light (c). Assumption: We must sync databases globally. Solution: Edge caching locally. Proof: D = V*T. ``` **Response:** ``` Verdict: FIRST_PRINCIPLES_PROVEN. You grounded the problem in physics, broke the assumption, derived the solution, and proved the math without jargon. ``` ## Capabilities ### Discarding Analogies It forces the agent to list and ignore all 'X is like Y' comparisons or pattern-matched solutions. ### Isolating Fundamental Truths The engine requires the problem constraints to be grounded only in physical, mathematical, or logical axioms. ### Deconstructing Assumptions It identifies and challenges inherited assumptions, determining if a constraint is immutable physics, provable math, or merely an outdated convention. ### Deriving Solutions from Axioms The AI must build the final solution purely from these fundamental axioms, making sure it emerges naturally from the constraints. ### Constructing Proofs It generates a formal logical or mathematical proof to validate every conclusion the agent reaches. ## Use Cases ### Designing a Global Data Sync Strategy The team proposed syncing global databases using standard cloud services. Instead of accepting this 'best practice,' the agent ran validate_first_principles, which immediately flagged that the assumption of synchronous global state was impossible due to the physical speed limit of light (c), forcing a shift to local edge caching. ### Developing a Novel Encryption Protocol A junior engineer suggested using an existing, complex protocol. The agent used validate_first_principles and was forced to deconstruct the underlying mathematical axioms, proving that the current setup had inherent vulnerabilities because it relied on a flawed assumption about key distribution. ### Scaling a Real-Time Trading System The initial plan suggested adding more microservices (a pattern). Running validate_first_principles forced the agent to calculate the true throughput limit based on hardware constraints, deriving the solution as a specific buffered queue mechanism instead of a generic service mesh. ## Benefits - Avoids the trap of 'best practices.' Using validate_first_principles ensures that solutions are derived from pure axioms, not copied pattern-matching. This changes your output quality immediately. - Eliminates vague language. The MCP's process forces the agent to purge jargon, ensuring every word carries specific informational content instead of corporate fluff. - Forces rigor in design decisions. By requiring an axiomatic proof, you eliminate architectural suggestions that are just assertions and replace them with verifiable logic. - Deepens validation checks. It doesn't just check for errors; it flags the *type* of error (e.g., Analogy Detected or Assumption Deconstructed), guiding your team to the actual flaw in reasoning. - Clarity on constraints. You learn what is genuinely immutable—physics, math, or hard limits—separating those facts from mere convention. ## How It Works The bottom line is: your AI doesn't guess anymore; it proves. 1. You feed your AI client a problem, asking it to propose an architectural strategy. The agent first runs through the process of discarding all analogies and isolating fundamental truths. 2. The MCP then forces the agent to deconstruct every assumption and derive the proposed solution using only pure axioms, generating a formal proof for its validity. 3. You receive a verdict that verifies if the reasoning is truly axiomatic or if it relied on buzzwords or conventional thinking. ## Frequently Asked Questions **Why does the logic engine scan for buzzwords?** Because words like 'leverage', 'synergy', or 'best practices' are proof of analogical thinking. The semantic trap prevents the AI from faking deep thought. **What qualifies as a fundamental truth?** Physics (like the speed of light or CPU thermal limits), mathematical laws (like Big O complexity), or hard engineering constraints (like network bandwidth limits). Opinions and conventions do not count. **Why must the solution be built from scratch?** To ensure you aren't just importing a library or framework that carries hidden architectural assumptions. Deriving solutions from axioms guarantees a clean, unbloated design optimized for the exact problem. **How do I structure my prompt for validate_first_principles?** You must provide structured inputs covering four key areas: 1) The problem statement, 2) Explicit axioms (the fundamental truths), 3) The assumptions you want to challenge, and 4) The desired output format. Don't just ask a general question; structure your prompt so the agent knows exactly which concepts need validation against physical or mathematical laws. **What does it mean if validate_first_principles returns ANALOGY_DETECTED?** It means your reasoning relied on pattern matching rather than underlying truth. The system found that the solution you proposed was borrowed from a similar-looking problem but wasn't structurally equivalent to the current one. You need to prove causality specific to this context, not just similarity. **Are there usage limitations or rate limits when calling validate_first_principles?** Vinkius manages operational capacity and handles throttling automatically. While we recommend running the tool once per major design decision or analysis phase to ensure quality, you don't need to worry about hitting hard, undocumented limits. **Does using validate_first_principles protect my data privacy?** Yes. Your input context is processed within the secure Vinkius environment and remains confidential. The MCP only uses your inputs to perform logical validation; it doesn't store or transmit sensitive data outside of the established session. **If validate_first_principles fails, does that mean I can't find a solution?** No. It simply means the current reasoning chain has logical gaps or relies on unproven assumptions. The tool doesn't declare failure; it points out exactly where your deduction breaks down, forcing you to re-examine the initial premises.