# Galileo Experimental Prover MCP for AI Agents AI Agent Connect > Galileo Experimental Prover helps your AI client stop blindly trusting documentation and start using actual evidence. Instead of accepting best practices, this Connector forces your agent to design controlled experiments, isolate variables, and predict outcomes before making changes. It turns your AI from a yes-man into a rigorous researcher that demands proof before implementation. ## Overview - **Category:** architecture - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_isqYV5nylEKAxwmBsGWpbc0CJmDH7Xhz0HL04bd3/ai-agent-connect - **Tags:** experimental-method, authority-questioning, variable-control, hypothesis-testing, falsification, galileo, scientific-method ## Description You've seen it happen: you ask your AI for a recommendation, and it gives you an answer because the documentation says so or it's an industry standard. That's authority deference, and in high-stakes engineering, it's a recipe for failure. You need your agent to act like a scientist, not a parrot. The Galileo Experimental Prover changes how your agent handles claims by forcing it to follow a strict experimental framework. When you ask for a technical change, your agent won't just agree with a vendor whitepaper. Instead, it has to question the source, design a repeatable test with specific measurements, and ensure only one variable is changed at a time. It forces the agent to state a prediction before any action is taken, so you can see if the result actually proves the hypothesis or just happened by chance. By using this Connector through the Vinkius catalog, you're giving your AI a logical guardrail that prioritizes evidence over prestige. It stops the let's see what happens approach and replaces it with a structured method for validating every technical decision. You get an agent that actually thinks through the why and how before it touches your production environment. This means instead of jumping into a new database migration because a blog post suggested it, your agent will first demand to know what specific metric it's trying to improve. It will then outline a plan to change only that one factor while keeping everything else the same. You'll get a clear, evidence-based roadmap for every major technical pivot, moving you away from guesswork and toward verifiable success. ## Tools ### validate_galileo_experiment Forces the agent to question authority, design a test, control variables, predict outcomes, and revise beliefs. It turns a vague idea into a rigorous, measurable experiment. ## Prompt Examples **Prompt:** ``` The vendor says this new caching layer handles 50% more traffic. How do we check? ``` **Response:** ``` **Verdict:** AUTHORITY_DEFERRED **Analysis:** * **Authority:** 'The vendor documentation says' is a classic example of authority deference. * **Evidence:** There is no benchmark provided against your specific production load. **Next Steps:** 1. Identify your current maximum volume. 2. Design a load test to see where the current process fails. 3. Test the vendor's claim against your specific data. ``` **Prompt:** ``` We updated the API and the database and it's faster now. How do we know which one did it? ``` **Response:** ``` **Verdict:** VARIABLES_UNCONTROLLED **Analysis:** * **Issue:** You changed three things at once (meetings, tools, and updates). * **Problem:** You cannot know which change caused the improvement. **Correction:** To follow the Galilean method, you must isolate one variable. Try removing only the Monday meetings first and measure the result for two weeks before changing anything else. ``` **Prompt:** ``` Should we switch to the new auth flow? ``` **Response:** ``` **Verdict:** EXPERIMENT_PROVEN **Analysis:** * **Authority Challenged:** You've moved past the vendor's claims. * **Experiment Designed:** 10%/90% split test is a solid method. * **Variables Controlled:** Only routing changes were tested. * **Prediction:** Clear threshold for success. **Conclusion:** The evidence outweighs the authority. You can proceed with the migration. ``` ## Capabilities ### Question source authority Forces the agent to challenge best practices with actual evidence instead of just citing prestige. ### Design repeatable experiments Creates specific tests with clear hypotheses, methods, and measurement protocols. ### Isolate single variables Ensures only one change happens at a time to identify the root cause of performance shifts. ### State outcome predictions Requires the agent to state exactly what should happen before any test is executed. ### Update beliefs based on data Forces the agent to change its position when evidence contradicts its initial stance. ## Use Cases ### Vendor Benchmarking An architect wants to know if a new database actually handles 10k requests. The agent uses validate_galileo_experiment to design a split test. ### Performance Tuning A dev wants to speed up a slow API. The agent uses validate_galileo_experiment to ensure they aren't changing the cache and the code at the same time. ### Process Change A manager wants to know if a new meeting style works. The agent uses validate_galileo_experiment to test one change while keeping the team constant. ### Feature Validation A product owner wants to test a new UI. The agent uses validate_galileo_experiment to predict the success metric before running the test. ## Benefits - Stop authority deference: No more 'the docs say so' excuses. validate_galileo_experiment forces the AI to demand proof. - Eliminate 'magic' fixes: By using validate_galileo_experiment to isolate variables, you'll know exactly which change caused a performance boost. - Reduce production risk: Forcing a prediction before any test ensures your agent doesn't just 'see what happens' with your live data. - Consistent reasoning: Every technical decision follows the same scientific framework, making it easier for human teams to review. - Faster root cause analysis: Instead of guessing, your agent uses validate_galileo_experiment to systematically test one thing at a time. ## How It Works The bottom line is that your AI stops guessing and starts proving every technical claim with a structured experiment. 1. Input a claim or technical hypothesis you want to test. 2. The Connector guides the agent through the five pillars of the Galilean method. 3. You get a structured verdict and a clear path for testing. ## Frequently Asked Questions **What does Galileo Experimental Prover do for my architecture?** It forces your AI to move beyond 'best practices' and actually design controlled experiments. It ensures that every architectural change is backed by evidence, isolated variables, and clear predictions. **How does this help with vendor claims?** It stops your agent from blindly accepting vendor whitepapers. Instead, it forces the AI to demand a specific benchmark and design a test to verify those claims against your actual data. **Can it help me debug performance issues?** Yes, by forcing the agent to isolate a single variable at a time. This prevents you from making multiple changes and guessing which one actually fixed the problem. **Is this for every technical decision?** It is best suited for high-stakes technical decisions like infrastructure migrations, performance tuning, or vendor evaluations where the cost of being wrong is high. **How does it stop my AI from just agreeing with me?** It builds a logical guardrail into your agent's reasoning. It requires the AI to question the source of a claim and provide a repeatable experiment before it can confirm a solution. **What happens if the AI can't find an experiment?** The Connector will flag the reasoning as evidence-deficient. It will tell you that the current logic is based on authority deference and will prompt you to define a measurable test. **How is this different from the Curie Measurement Prover?** Curie forces measurement rigor in existing data. Galileo forces experimental DESIGN — question authority, create a NEW test, predict outcomes, revise beliefs. Curie asks 'did you measure correctly?' Galileo asks 'did you design the right experiment?' **What counts as 'authority deference'?** Accepting a claim because of WHO said it. 'The documentation recommends,' 'the industry standard says,' 'leading companies use' — all authority deference. The source's prestige does not make the claim true. Galileo TESTED Aristotle instead of citing him. **Can I use this for business decisions?** Yes. 'Customers prefer feature X' — design a test, control variables, predict the outcome, measure. The Galilean method applies wherever claims need testing against reality.