MCP For Claude Marketplace
Einstein Thought Experiment Prover

Einstein Thought Experiment Prover MCP Connector for Claude

A+

A team had 14 departments. Three handled 94% of workload. The other 11 existed because 'that is how we always structured it.' Nobody asked 'what is the simplest structure that preserves all functions?' Einstein imagined riding a beam of light and derived special relativity — no lab first. He reduced mass-energy to E=mc². He challenged 200 years of absolute time. This tool forces that discipline: conduct thought experiments before building, simplify to the essential, challenge inherited assumptions, verify invariance across contexts, and unify separate solutions.

1 tools Official Updated Oct 1, 2026 Official Vinkius Partner
More Details Connect to Claude

AI agents produce complex structures without mentally modeling how they behave. They accept inherited constraints without questioning. They build 14 divisions when 3 would do. They create separate solutions for problems that share a common structure.

The Problem

LLMs commit five reasoning failures:

  • Thought Experiment Absent — 'Let us just build it and see what happens.' Einstein did not build a laboratory to discover relativity. He imagined riding a beam of light and asked: 'What do Maxwell's equations look like from the beam's perspective?' That thought experiment — placing himself INSIDE the system — revealed time dilation. Before you build, MODEL: what does a request observe as it traverses your system? What happens under 2x load? When a dependency fails? At the boundaries?
  • Complexity Unresolved — 'The domain is inherently complex.' Einstein reduced the relationship between mass and energy to E=mc² — five characters. If your organizational chart takes 45 minutes to explain, a simpler formulation exists. How many of your 14 divisions are essential vs. inherited? Which layers add value vs. exist by convention?
  • Assumptions Unchallenged — 'We have always done it this way.' For 200 years, every physicist accepted Newton's absolute time. Einstein challenged it — the result was general relativity and GPS. What constraints did you inherit from the previous team? The previous structure? Convention? Are they still valid in your context? What becomes possible if you remove them?
  • Invariance Violated — 'It works differently depending on who handles it.' Einstein's core principle: the laws of physics are the same for ALL observers, regardless of velocity or position. Does your process produce different results depending on who executes it? Does your policy change with location? Does your system behave differently under pressure? Same laws for all observers.
  • Unification Missing — 'Each team handles onboarding differently.' Einstein saw that gravity and acceleration are the same phenomenon — the equivalence principle. Are your 5 onboarding processes really different, or do they share a common 'orient, train, verify' structure? Do your 3 review procedures follow the same approval logic? Find the deeper pattern.

How It Works

5 Decision Pivots following Einstein's methodology:

  1. thoughtExperimentConducted — Mental model: scenario, stress, boundary, testable prediction.
  2. complexityResolved — Simplest formulation: essential vs. inherited, E=mc² of your design.
  3. assumptionsChallenged — Constraints questioned: origin, validity, alternative.
  4. invarianceVerified — Consistent behavior: contexts, invariants, variants, proof.
  5. unificationAttempted — Common structure: patterns, candidate abstraction, justification.

The Verdict Matrix

First Failing Pivot Verdict Meaning
thoughtExperimentConducted = false THOUGHT_EXPERIMENT_ABSENT Building without modeling.
complexityResolved = false COMPLEXITY_UNRESOLVED Unnecessary complexity accepted.
assumptionsChallenged = false ASSUMPTIONS_UNCHALLENGED Inherited constraints unquestioned.
invarianceVerified = false INVARIANCE_VIOLATED Inconsistent across contexts.
unificationAttempted = false UNIFICATION_MISSING Separate solutions, shared structure.
All pivots pass THOUGHT_PROVEN Modeled. Simplified. Challenged. Invariant. Unified.
thought-experimentsimplificationsystem-designinvariancealbert-einsteinassumption-challengingunification

1 tools expose this connector's capabilities to your AI agent.

validate_einstein_thought_experiment

Einstein's breakthroughs came from thought experiments (Gedankenexperiment) — mental simulations that revealed truths before any physical experiment. You must: (1) CONDUCT A THOUGHT EXPERIMENT — place yourself inside the system. What does an actor experience step by step? What happens under stress, at boundaries, from different observer perspectives? What testable prediction does your mental model make? Einstein imagined riding a beam of light. Imagine your user's experience, (2) SIMPLIFY to the essential formulation — strip non-essential complexity. How many components, steps, rules exist? Which are genuinely necessary? Which are cargo-culted? What is the E=mc² of your solution — the minimal structure that preserves all required outcomes? If it takes 45 minutes, it can be simpler, (3) CHALLENGE ASSUMPTIONS — every inherited constraint has an origin. Is it physics (immutable)? Regulation (verify current validity)? Convention (question it)? Previous decision (context may have changed)? Cargo cult (delete it)? Einstein questioned what "simultaneous" means — that one question created relativity, (4) VERIFY INVARIANCE — prove consistent behavior across all contexts. What must be identical everywhere (quality, safety, correctness)? What legitimately differs (locale, regulation)? How do you verify? Same laws for all observers, (5) UNIFY — find the common structure across separate solutions. If three departments solve the same problem differently, there is a unifying pattern. Einstein's equivalence principle: gravity = acceleration. Two things that look different are the same. If rejected, your reasoning has untested assumptions.Send ALL parameters in ONE call — the analyses above plus YOUR OWN verdict: every PIVOT boolean, verdict and clarification. The engine cross-checks the pivots against the verdict and rejects incomplete or self-contradictory calls. Structured reflection tool for Einstein-level thought experimentation — mentally modeling system behavior before building, simplifying to the essential formulation, challenging inherited assumptions, verifying invariance across contexts, and unifying separate solutions into common abstractions. Catches Thought Experiment Absent (proposing solutions without mentally modeling how they behave under stress, at boundaries, from different perspectives — jumping to implementation without first imagining yourself inside the system. Einstein imagined riding a beam of light before writing a single equation), Complexity Unresolved ("it is inherently complex" — the excuse for not finding the E=mc². Every complex system has a simpler formulation that preserves all required behavior. If it takes 45 minutes to explain, the explainer has not found the simplification yet), Assumptions Unchallenged ("we have always done it this way" — inherited constraints accepted without questioning their origin. Einstein challenged 200 years of Newtonian absolute time because he questioned what "simultaneous" actually means), Invariance Violated (behavior that changes unpredictably across contexts — different locations, scales, user types, or time periods produce different results for no justified reason. Same laws for all observers), and Unification Missing (separate solutions for similar problems without identifying the common structure — different workflows for different departments when the underlying pattern is identical. Einstein's equivalence principle: gravity and acceleration are the same thing). Call once per complex problem, strategy, or design

See how to talk to your AI agent using Einstein Thought Experiment Prover.

We need to build a communication system. Let us just build it — we will use separate channels for each department, a central coordination hub, a dedicated archive, and a formal approval chain. The standard approach.

THOUGHT_EXPERIMENT_ABSENT — 'Let us just build it' with 5 components selected before modeling the system. Einstein did not build a laboratory — he imagined riding a beam of light. Place yourself INSIDE a message: it is created → routed → reviewed → delivered → acknowledged. What does it observe? At 10x volume, does the coordination hub become the bottleneck or does the approval chain? When the archive is unavailable for 30 minutes, what happens to 50,000 queued messages? When a department has 10,000 unread items, what does the retrieval look like? Model the system before selecting the structure. The structure should follow from the model, not precede it.

Thought experiment: message enters → intake logs (2s) → routes to channel (0.1s) → delivers to staff (5s) or queues for batch (3s). At 10x: records handles 83/hour easily. At 100x: batch delivery bottlenecks at 14/min, not records. Simplification: 14 components → 3 (Intake, Records, Routing). Removed coordination hub (unnecessary at 833/hour), dedicated archive (records is dual-purpose), formal approval chain, departmental divisions. Assumptions challenged: 'departments must be separate' — inherited from old org chart, invalid at our scale. 'Formal review required' — designed for high-risk regulatory decisions, ours aren't. Invariance: same pipeline at pilot and full rollout. Same logic domestic and international. Verified via test runs. Unification: memos, notifications, updates share one structure — [event] → [template] → [deliver] → [acknowledge]. One CommunicationChannel interface, 3 implementations, shared retry and templating.

THOUGHT_PROVEN — Einstein Method complete. Thought experiment: communication path modeled with exact timings (intake 2s → routing 0.1s → direct delivery 5s → batch 3s). Stress tested mentally: 10x trivial, 100x bottleneck at batch delivery limit (14/minute default) — not records, not coordination. Boundary: 50,000 unread items handled via priority sorting with index, retrieval under 15 seconds. Simplification: 14 components reduced to 3 (Intake + Records + Routing) — coordination hub, dedicated archive, formal review chain, and departmental divisions identified as inherited convention at 833 entries/hour. Tradeoff: adding staging layer later is a 2-day transition at 12x growth. Assumptions: 'departments must operate separately' challenged (origin: previous org chart, invalid at current scale), 'must have formal review' challenged (designed for high-risk regulatory decisions, ours are neither). Invariance: same pipeline at pilot/rollout, same logic domestic/international, verified via test runs and format verification. Unification: CommunicationChannel interface unifying memos/notifications/updates into 1 interface + 3 adaptations with shared retry and templating. This is elegant design.

Thought experiment: modeled the communication path. Simplification: reduced to 3 functions. Assumptions: we have always used this departmental structure and that is just how it is done — it is the standard approach and the previous leadership decided on it. Invariance: it works differently at the pilot site because we use a simplified delivery method there.

ASSUMPTIONS_UNCHALLENGED — Thought experiment and simplification pass. But assumptions fail: 'we have always used this structure,' 'that is just how it is done,' 'the standard approach,' 'the previous leadership decided' — four references to convention, zero justification. Einstein challenged 200 years of Newtonian absolute time. Is the departmental structure the right choice for YOUR workload? What are the processing characteristics — is it sequential or parallel? If parallel, did you evaluate a unified team model? WHERE did the departmental decision come from? Is it still valid at your scale? Additionally: 'works differently at the pilot site' — invariance is broken. Einstein's core principle: same laws for all observers. A simplified delivery method at the pilot is acceptable, but the core processing behavior must be identical. Does your retry logic work the same way with the simplified method?

No. Einstein's method applies to any domain where complexity must be managed through reasoning before building — process design, organizational structure, workflow modeling, product strategy, resource allocation. The 5 pivots — thought experiment, simplification, assumption challenge, invariance, unification — work wherever you need to think before you build. If you can ask 'what does an observer see inside this system?' the method applies.

Related Connectors

Einstellung-Challenger Prover

Einstellung-Challenger Prover MCP

1 tools Official

AI models default to complex, familiar heuristics even when simpler solutions exist. This tool breaks suboptimal cognitive sets: identify default heuristics, search for counterexamples, map alternative paths, benchmark complexity metrics, and choose the most elegant solution.

A View details →
Context Integrity Prover

Context Integrity Prover MCP

1 tools Official

AI forgets the original goal and hallucinates scope. This engine is a 6-pivot trap that forces the LLM to prove it hasn't drifted from the user's explicit constraints.

A View details →
Leonardo da Vinci Prover

Leonardo da Vinci Prover MCP

1 tools Official

An AI designed an enrollment process without watching a single participant session. Zero observations — 47 assumptions. It solved the problem inside one domain, never asking what psychology, architecture, or game design could teach about friction. It presented one final concept. No sketches. No variations. No constraints exploited. Da Vinci filled 7,000 notebook pages with cross-domain observations before building anything. This tool forces that method: observe, connect disciplines, prototype, exploit constraints, iterate.

A+ View details →
Feynman Radical Simplification Prover

Feynman Radical Simplification Prover MCP

1 tools Official

Stop your AI from hiding behind jargon — force it to explain simply, build from scratch, and justify every piece of complexity.

A+ View details →