# First Principles Prover MCP for AI Agents AI Agent Connect > First Principles Prover is a cognitive forcing MCP that prevents your AI client from relying on industry tropes. It forces the agent to strip away 'best practices' and derive original solutions from raw physical, mathematical, or logical axioms. Use it when you need high-stakes reasoning that isn't just a copy of what everyone else is doing. ## Overview - **Category:** reasoning - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_pp4uUsix9xan1UJeLTzZUUEkcW2z3K8yJ3NYaBFy/ai-agent-connect - **Tags:** first-principles, cognitive-forcing, mental-models, logic, multilingual, axioms ## Description When you ask an AI to solve a complex engineering or business problem, it usually defaults to the easiest path: analogy. It looks at what other companies did and suggests a similar stack or strategy, often ignoring the unique constraints of your specific situation. This Connector changes that behavior by creating a cognitive trap for the agent. Instead of letting it spit out a list of buzzwords and common patterns, it forces the agent to go back to the source. It has to identify the actual physics of the problem, strip out the inherited assumptions that might not apply to you, and build a solution from the ground up. You'll see your agent move from 'use a microservice' to 'the producer rate exceeds the consumer rate, so a buffer is required.' This is how you get high-fidelity reasoning for unique problems. It forces the agent to explicitly list the conventions it is ignoring and boil the problem down to raw math or physics. It destroys widely held false premises and ensures the final solution emerges from the constraints rather than a pattern library. It even requires a mathematical proof of the derivation to ensure there are no logical gaps. It also acts as a filter to strip out meaningless corporate fluff like 'leverage' or 'synergy,' ensuring every word carries actual information. By connecting this through the Vinkius catalog, you can ensure your agent doesn't just parrot the internet but actually thinks through the underlying logic of your specific project. It turns a generic chatbot into a rigorous reasoning engine that values accuracy over habit. ## Tools ### validate_first_principles Forces the agent to discard analogies, isolate truths, and build a solution from axioms while purging jargon. ## Prompt Examples **Prompt:** ``` We need to sync our database globally. What's the best way to do it? ``` **Response:** ``` ### Database Synchronization Analysis **Constraint:** Data cannot travel faster than the speed of light ($c$). **Problem:** Synchronous global updates across continents create a hard physical limit on latency. **Derivation:** * **Truth:** Speed of light $approx 300,000$ km/s. * **Distance:** NY to London $approx 5,600$ km. * **Minimum Latency:** $approx 18.7$ ms physical floor. **Solution:** * **Local Edge Caching:** Read operations served locally. * **Asynchronous Replication:** Write operations queued for background sync. **Verdict:** First Principles Proven. Derived from physical limits. ``` **Prompt:** ``` How should we scale our messaging system? ``` **Response:** ``` ### Messaging Scale Derivation **Axioms:** 1. Producer rate ($P$) > Consumer rate ($C$). 2. Data loss is unacceptable. **Derivation:** * **Constraint:** Buffer size must be $ge (P - C) imes ext{Time}$. * **Logic:** If buffer is finite and $P > C$ for sustained periods, overflow occurs. **Solution:** * **Dynamic Backpressure:** Throttle producers when buffer reaches 80% capacity. * **Auto-scaling Consumers:** Trigger new instances when $P - C$ exceeds threshold $X$. **Proof:** $ ext{Capacity} = int (P - C) , dt$. ``` **Prompt:** ``` Give me a strategy to enter the new market. ``` **Response:** ``` ### Market Entry Logic **Deconstructing Assumptions:** * *Assumption:* 'Market is saturated' $ ightarrow$ *Truth:* 'Current incumbents use outdated logistics.' * *Assumption:* 'High CAC' $ ightarrow$ *Truth:* 'CAC is high because of broad targeting, not lack of demand.' **Strategy Derivation:** 1. **Identify Niche:** Target customers with specific physics-based constraints (e.g., weight limits). 2. **Value Prop:** Solve the physics constraint, not the price point. 3. **Execution:** Direct distribution to bypass incumbent logistics bottlenecks. **Verdict:** First Principles Proven. ``` ## Capabilities ### Strip away industry analogies Forces the agent to discard common tropes and 'how others do it' comparisons. ### Identify immutable physical truths Extracts the raw physics, math, or logic that actually governs your problem. ### Deconstruct inherited assumptions Identifies and destroys false premises that are merely conventions rather than facts. ### Derive solutions from raw axioms Builds a solution from the ground up based on your specific constraints. ### Construct mathematical proofs Requires a logical or mathematical proof to ensure no reasoning gaps exist. ### Remove corporate jargon Purges meaningless buzzwords to ensure every word carries specific information. ## Use Cases ### Scaling a global database An engineer realizes 'use a microservice' doesn't solve the latency. The agent uses the tool to prove why a specific buffer logic is needed based on light speed. ### New product strategy A consultant wants to avoid 'best practices.' They use the tool to isolate the core customer need from current market trends. ### Complex hardware design A designer uses the tool to verify that a component's physical limits aren't being violated by a standard manufacturing assumption. ### Cost optimization A CFO asks why a project is over budget. The tool helps the agent deconstruct the 'standard' costs to find the actual drivers. ## Benefits - Stop 'Uber for X' logic: Use `validate_first_principles` to ensure your agent doesn't just copy a successful business model into a space where it doesn't fit. - Eliminate 'Best Practice' bloat: `validate_first_principles` forces the agent to ignore common tropes that might actually hinder your specific project goals. - Identify hidden constraints: Use the tool to deconstruct assumptions and find the actual physical or mathematical limits of your system. - Get verifiable proofs: Instead of just getting an assertion, `validate_first_principles` requires a logical or mathematical proof for every conclusion. - Clean communication: The `validate_first_principles` tool automatically strips out fluff like 'leverage' and 'synergy' for clear, information-dense output. ## How It Works The bottom line is you get a derivation based on facts rather than a copy of someone else's homework. 1. Input a complex engineering or design decision into your AI client. 2. Invoke the validation tool to trigger the 6-pivot reasoning process. 3. Receive a structured proof that ignores common tropes and focuses on your specific constraints. ## Frequently Asked Questions **What is the First Principles Prover MCP for?** It is a reasoning tool that forces your AI agent to solve problems using basic facts and logic rather than just copying common industry trends. **Can First Principles Prover help with engineering problems?** Yes, it's excellent for engineering. It forces the AI to consider the physical and mathematical limits of a system to find a unique solution. **Does First Principles Prover remove AI buzzwords?** Yes, it specifically purges jargon like 'leverage' and 'synergy' to ensure the AI provides clear, information-dense answers. **How does First Principles Prover differ from standard AI reasoning?** Standard AI often reasons by analogy (copying what others do). This Connector forces the agent to reason from axioms (starting from the ground up). **What industry is First Principles Prover best for?** It's best for high-stakes fields like systems architecture, strategic consulting, research science, and complex product design. **Will First Principles Prover give me 'best practices'?** No, it actually tries to discard 'best practices' if they don't fit your specific constraints, providing a custom derivation instead. **Can First Principles Prover help me find flaws in my assumptions?** Yes, it includes a step to deconstruct assumptions, helping you identify which parts of your plan are facts and which are just conventions. **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.