# Archimedes First Principles Prover MCP for AI Agents AI Agent Connect > Archimedes First Principles Prover forces your AI client to stop making lazy assumptions and start thinking from the ground up. It replaces 'industry standard' analogies with rigorous axiom examination, component decomposition, and logical proof derivation. If your agent suggests a move because 'everyone else does it,' this Connector rejects it until the underlying logic is actually proven. ## Overview - **Category:** architecture - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_2aOcxzAi99p47ps29WeUcelnKLtoigQu9RxaugQl/ai-agent-connect - **Tags:** first-principles, axiom-reasoning, decomposition, proof-derivation, boundary-testing, leverage-point, archimedes, method-of-exhaustion ## Description Most AI agents reason by analogy. They see a successful pattern in one industry and try to paste it onto yours without checking if the underlying constraints actually match. They treat complex problems as monoliths and assert conclusions with 'obviously' instead of showing the work. Archimedes First Principles Prover changes this dynamic by turning your AI client into a rigorous logic engine. It forces the agent to state every foundational claim as an axiom, break complex problems down into irreducible components, and build a step-by-step proof for every conclusion. It also requires the agent to find the failure points and the specific leverage points where a small input creates a big result. When you use this through the Vinkius catalog, you aren't just getting a better answer. You're getting an answer that has been stress-tested against the laws of logic. It stops 'obviously' from being a valid argument and forces the agent to show its work, ensuring your strategy isn't built on a house of cards. This tool makes it impossible for your agent to skip the hard thinking required for high-stakes architecture or strategic planning. ## Tools ### validate_archimedes_first_principles Forces your agent to audit its logic by checking axioms, components, proofs, boundaries, and leverage points. It rejects lazy reasoning and ensures every conclusion follows a strict logical chain. ## Prompt Examples **Prompt:** ``` We need to move to a microservices architecture because it's the standard for high-growth tech. ``` **Response:** ``` **AXIOM_UNEXAMINED** — 'Standard' is an analogy. Archimedes derived pi from polygon geometry, not from copying others. At what actual request volume does your current monolith fail? * **Current Constraint:** What is your peak concurrent user count? * **Failure Point:** At what number of requests does the database lock? State the foundational claim: what specific constraint makes your current structure impossible at your current scale? ``` **Prompt:** ``` Our customer churn is high. We should overhaul the entire onboarding experience. ``` **Response:** ``` **PROOF_MISSING** — 'Overhaul everything' is an assertion, not a derivation. We must decompose the onboarding process into irreducible components: 1. **Sign-up Flow** 2. **Tutorial Completion** 3. **First-Value Achievement** 4. **Billing Setup** Which specific step has the highest drop-off? Without decomposition, you optimize the wrong step. Provide the data for each component before suggesting a restructure. ``` **Prompt:** ``` We want to expand into the enterprise market. We should offer a custom dashboard for every client. ``` **Response:** ``` **LEVERAGE_IGNORED** — 'Custom dashboard' might be low-leverage. Archimedes moved ships with levers. The fulcrum placement determines the output. * **Variable A:** Custom UI (High effort, medium value) * **Variable B:** SSO/Security Integration (Medium effort, high value) Which variable produces disproportionate output for an enterprise buyer? Find the lever point. ``` ## Capabilities ### Examine foundational axioms Forces the agent to state and source every underlying assumption instead of relying on analogies. ### Decompose complex problems Breaks down monolithic issues into irreducible components to see how they interact. ### Derive logical proofs Requires a step-by-step logical chain from the starting axioms to the final conclusion. ### Identify failure boundaries Forces the agent to document exactly where a solution stops working or breaks. ### Locate high-leverage variables Identifies the single point where a small input produces a disproportionate output. ## Use Cases ### The 'Industry Leader' Trap An agent suggests a decentralized structure because others use it. The tool rejects it as an analogy and forces a look at your specific team size. ### The Checkout Bottleneck Instead of 'optimizing the flow,' the agent decomposes the funnel into address, shipping, and payment to find the real drop-off point. ### The 'Restructure Everything' Fallacy When a process is slow, the agent is forced to prove that a full restructure is the only solution instead of a simple template change. ### Scaling a New Product The tool forces the agent to find the exact capacity where your current structure fails rather than just saying it 'scales well.' ## Benefits - Stop 'analogy contamination' where your agent copies a competitor's strategy that doesn't fit your specific scale. - Break down monolithic problems into smaller parts using validate_archimedes_first_principles to see how components actually interact. - Eliminate 'obviously' from your reports by forcing the agent to provide a step-by-step logical chain from the ground up. - Find the real failure points of a system by testing boundaries instead of assuming a solution works for every use case. - Identify the single lever that produces disproportionate output so you can stop wasting resources on low-impact tasks. ## How It Works The bottom line is that your agent stops guessing and starts proving. 1. Input a strategic goal or architectural problem to your AI client. 2. Invoke the tool to force the agent to audit its reasoning against first principles. 3. Receive a structured verdict on whether the logic holds or fails. ## Frequently Asked Questions **What is the Archimedes First Principles Prover MCP?** It is a logic audit tool that forces your AI client to stop using lazy analogies and start thinking from first principles. It ensures your agent provides rigorous proofs for every strategic or architectural decision. **How does this help with software architecture?** It forces the agent to break down your system into components and identify the exact failure points. This prevents you from over-engineering a solution that doesn't address the actual bottleneck. **Can I use this for business strategy?** Yes. It is excellent for business strategy because it prevents the agent from just copying a competitor's playbook. It forces the agent to find the unique leverage points in your specific market. **How is this different from a normal AI prompt?** A normal prompt allows the agent to give you the easiest answer it knows. This Connector creates a hard constraint that rejects easy answers unless they are backed by a full logical proof and boundary test. **What happens if my agent gives a lazy answer?** The tool will flag the reasoning as AXIOM_UNEXAMINED or PROOF_MISSING. It will then tell the agent exactly why the logic failed and what specific information it needs to provide to pass the audit. **Does this work for complex engineering problems?** Yes, it is specifically designed for complexity. It forces the agent to decompose problems into smaller, manageable parts so you can solve the root cause rather than just treating the problem as a monolith. **Will this help me find the best way to scale?** It helps by identifying the 'fulcrum.' Instead of suggesting you scale everything, it forces the agent to find the one variable where a small change creates a massive increase in output. **How is this different from the Elon Musk Physics Prover?** Elon Musk Physics Prover forces the 5-Step Starbase Algorithm: question, delete, simplify, accelerate, automate. It is about operational engineering — cutting bloat. Archimedes First Principles Prover forces axiom-based reasoning: state axioms, decompose, prove, test boundaries, find leverage. It is about analytical rigor — proving your logic before building. Musk asks 'should this exist?' Archimedes asks 'is this actually true?' **What counts as a valid axiom?** An axiom is a foundational claim your reasoning depends on, with an explicit source: measurement ('our average processing time is 340 minutes — measured last Tuesday'), physics ('material strength decreases by 15% per 10°C above threshold'), economics ('our acquisition cost exceeds lifetime value at current pricing'), or stated assumption ('we assume retention stays at 14 months'). 'Organization X does Y' is analogy. 'Obviously' is assertion. Neither is an axiom. **Can I use this for business strategy, not just engineering?** Yes. First-principles reasoning applies wherever analogical reasoning misleads. 'We should use freemium because the market leader does' is an analogy. The axiom is: at what conversion rate does freemium generate more lifetime value than paid-only? Decomposition: acquisition, activation, retention, monetization — which component is the actual bottleneck? Proof: if conversion is 3% and free-tier cost is $X/user, then... Boundary: at what scale does free-tier cost exceed premium revenue? Leverage: which single metric, if improved 10%, changes the business?