Mei: Epistemic Verification Engine

Inspiration

In robotics, vehicles, and physical systems, the most dangerous failures don’t come from bad execution, they come from making a decision without knowing whether it’s physically valid.

We noticed that modern video models are usually treated as media generators. We asked a different question: What if video could be used to test physical hypotheses before action is taken?

Instead of generating content, we use video as a simulated execution of a physical goal. The output isn’t a clip, it’s a verified state transition: can this action succeed, fail, or is there not enough evidence to decide?

What it does

Mei is an epistemic verification engine that determines whether a physical scenario is possible, impossible, or uncertain before action is taken. Users describe a physics-focused goal (for example, “a robotic arm stacks three boxes without tipping” or “a vehicle takes a turn with lateral slip”).

Mei: Plans execution beats representing physical steps. Simulates execution using video generation as a stand-in for real-world action. Runs a vision observer to extract physical evidence from the execution. Validates each state transition against physics constraints and available evidence. Returns a structured result: outcome (goal_achieved, goal_impossible, epistemically_incomplete), confidence, constraints_discovered, and a WorldStateGraph of verified transitions.

Video is not the product - it is the execution medium. The product is epistemic validity: whether the scenario can be trusted to work and under what constraints. In exploratory mode, when evidence is insufficient, Mei retries with different viewpoints (e.g., side or overhead) and returns actionable next steps instead of a dead end.

How we built it

Pipeline: Simulation Goal → Plan Beats → GPU Render → Observer → Epistemic Evaluator → World State Graph

System: A FastAPI service receives goals, plans execution beats, and queues GPU jobs via Redis. A serverless GPU bridge (RunPod) renders executions and stores artifacts in Cloudflare R2. A ResultConsumer evaluates outputs using vision models and updates a persistent WorldStateGraph. An epistemic layer determines whether observer evidence is required or optional based on intent (closed-form physics vs perceptual dynamics).

Exploratory mode: When uncertainty persists (risk_profile=high), the system automatically explores alternate viewpoints and records what evidence was attempted and what remains missing.

The UI presents decision outcome, confidence, and constraints , not videos so users can act without interpretation.

Challenges we ran into

Observer reliability: Vision models can miss critical physical cues. We mitigated this using physics-specific prompts, structured questions, and observability augmentation across retries.

Distributed execution: Coordinating local APIs, Redis queues, and serverless GPUs required strict job semantics and fault-tolerant result handling.

Epistemic boundaries: Determining when a solver alone is sufficient (e.g., fully specified stacking) versus when observation is mandatory (e.g., vehicle dynamics) required explicit intent classification and domain rules.

Accomplishments that we're proud of

Epistemic architecture: We explicitly separate “impossible” from “uncertain”. The system applies domain-specific constraints (statics vs. vehicle dynamics) and supports a solver-only path for closed-form physics when visual evidence is unnecessary.

Exploratory mode: On uncertain verdicts, Mei does not blindly retry. It augments observability with different framings, records what evidence was attempted, and surfaces concrete suggestions when uncertainty persists.

Video as a state transition function: Each render corresponds to a transition in a directed acyclic graph of world states. Failure and uncertainty are first-class outcomes — the system never retries until success at any cost.

Production-style pipeline: A distributed system with a main API, Redis queue, serverless GPU workers, and artifact storage, including graceful fallbacks when compute or credits are exhausted.

State-first API: Consumers receive outcomes, confidence, and constraints without needing to watch video. Video exists only as a debug artifact, not the primary output.

What we learned

Video as a state transition Each render represents a transition from one world state to another. An observer validates whether that transition is physically consistent, producing a graph of verified states rather than a linear video timeline.

Distinguishing failure from uncertainty We learned to separate “this cannot work” from “we cannot conclude.” When evidence is missing or ambiguous, the system enters an epistemic state instead of hallucinating a verdict.

Exploration beats repetition Retrying the same prompt on uncertainty doesn’t help. We introduced exploratory retries , different viewpoints and camera hints so each attempt gathers new evidence instead of repeating failure.

What's next for Mei: Epistemic Verification Engine

Multi-observer consensus Aggregate verdicts from multiple observers to improve robustness and calibrated confidence.

Stronger evidence extraction: Structured prompts and tooling to extract concrete physics signals such as acceleration, center of mass movement, slip angle, and stability margins.

Richer exploratory suggestions: Automatically propose parameter changes or alternative goals when uncertainty persists, instead of generic hints.

Batch simulation API: Submit multiple goals at once and compare outcomes across variations.

Per-episode result isolation: Dedicated result queues to prevent cross-contamination when running many simulations in parallel.