maav.ai - NeoLab | v0.5

Mobility ideas are easy to imagine: and costly to get wrong. MAAV NeoLab lets AI agents build and break synthetic scenarios, giving humans deterministic evidence before expensive real-world pilots.

Comment

MAAV NeoLab v0.5

Design it. Break it. Make it resilient.

Inspiration

I did not begin by trying to build another mobility dashboard. I began with a frustration from my own mobility research.

Whenever I wanted to investigate a new mobility concept, defining the hypothesis was only the first step. Before I could test it, I often had to write substantial setup code, learn or relearn a specialist platform such as SUMO or MATLAB, translate the idea into that platform's abstractions, and assemble another workflow for visualization and analysis.

These tools are powerful and essential for high-fidelity research. But for early exploration, operating the toolchain can require more effort than conducting the first experiment.

That creates a hidden tax on mobility innovation. A planner, researcher, or R&D team may have an important question about fleet design, autonomous vehicles, urban air mobility, drones, or delivery robotics—yet spend more time constructing experimental machinery than examining the idea itself.

General-purpose AI has made ideation dramatically faster, but a fluent answer is not reproducible evidence. An AI can propose a compelling direction without proving that two alternatives were tested under the same assumptions, constraints, demand, or disruption.

I wanted to reverse that relationship:

Start with the research question, let an AI agent operate the experiment, and make a deterministic evidence system—not the AI—the source of truth.

That idea became MAAV NeoLab.

The Problem

Early mobility ideas move faster than the tools used to evaluate them.

Testing a concept can require simulation-specific programming, duplicated configuration, disconnected dashboards, and manual transfer of results between systems. Every handoff creates an opportunity for assumptions to drift.

Two alternatives may appear comparable even when they were tested with different demand, constraints, operating conditions, or failure scenarios. Results may be visually persuasive but difficult to reproduce. Conclusions can become separated from the exact evidence that produced them.

AI alone does not solve this problem. An assistant can generate recommendations quickly, but it may work from incomplete context, infer unsupported conclusions, or obscure how an answer was produced.

The industry does not need another system that merely produces answers. It needs a faster path from an idea to evidence that can be inspected, reproduced, challenged, and trusted.

What MAAV NeoLab Does

MAAV NeoLab makes mobility experimentation idea-first rather than software-first.

A human describes the objective. A browser agent configures and operates the experiment through WebMCP. A deterministic engine produces the evidence. The final decision remains with the human.

The workflow is intentionally clear:

Describe → Configure → Break → Run → Compare → Review

Version 0.5 proves this model through a deliberately bounded A/B experiment on an authored synthetic Sandton–Rosebank mobility network.

  • Scenario A uses 12 vehicles with 8 seats each.
  • Scenario B uses 10 vehicles with 10 seats each.
  • Both receive the same seed-07 trace of 120 synthetic passenger requests.
  • Both operate across the same 08:30–09:00 simulation horizon.
  • Both receive an equivalent vehicle failure at exactly 08:42.
  • The affected vehicle is selected independently using a fixed deterministic rule.
  • Every completed run produces an immutable event ledger, replay snapshots, metrics, constraint results, provenance, and fingerprints.
  • Compatible run artifacts can be compared and used to stage an evidence-linked finding.
  • The AI agent may stage a finding, but only the visible human interface can Accept or Challenge it.

At the failure tick, the engine selects the active vehicle with the highest onboard occupancy. Ties are resolved through explicit deterministic rules rather than randomness or agent choice. This resolves vehicle A-09 in Scenario A and B-03 in Scenario B.

The experiment produces a genuine trade-off instead of manufacturing a universal winner.

Evidence Scenario A Scenario B
Fleet 12 × 8 seats 10 × 10 seats
Served at horizon 82 81
In service at horizon 29 28
Unserved 9 11
Maximum wait 1,050 seconds 780 seconds
Total energy 37,799 Wh 31,665 Wh
Minimum reserve 7,633 basis points 7,648 basis points
Recovery time 120 seconds 450 seconds
Standing observed 0 0
Maximum-wait constraint FAIL FAIL

Scenario A completes service for more passengers and recovers significantly faster. Scenario B reduces maximum wait and total energy consumption. Both scenarios still violate the hard maximum-wait constraint.

MAAV NeoLab therefore stages:

TRADE_OFF · BALANCED · PENDING HUMAN REVIEW

Passenger conservation remains explicit:

$$N_{\mathrm{requested}} = N_{\mathrm{served}} + N_{\mathrm{in\ service}} + N_{\mathrm{unserved}}$$

For Scenario A:

$$120 = 82 + 29 + 9$$

For Scenario B:

$$120 = 81 + 28 + 11$$

MAAV NeoLab does not replace high-fidelity platforms such as SUMO or MATLAB. It provides a lower-friction assurance layer for exploring a hypothesis, exposing its assumptions, stress-testing alternatives consistently, and deciding whether deeper modeling or a real-world pilot is justified.

MAAV NeoLab v0.5 is a synthetic decision-support workbench—not a live fleet-control system, operational optimizer, or scientifically calibrated transport model.

How AI and WebMCP Are Used

The browser agent is not an embedded chatbot, and it does not operate a separate demonstration environment. It works directly with the application through exactly six static WebMCP tools:

  1. read_lab_state
  2. configure_scenario
  3. inject_disruption
  4. run_scenario
  5. compare_scenarios
  6. stage_finding

Through these tools, the agent can inspect the current laboratory state, configure Scenario A and Scenario B, schedule the equivalent deterministic disruption, run both simulations, compare compatible evidence, and stage a supported finding.

The important architectural decision is that the AI coordinates the experiment but never calculates its trusted evidence.

Passenger movement, assignments, vehicle selection, battery use, energy, failure recovery, metrics, constraints, comparisons, and supported finding claims remain owned by deterministic application and domain logic.

The agent also cannot Accept, Challenge, reset, dispatch, or execute any real-world operation. Final review authority remains intentionally human.

Prompting is the control plane. Deterministic evidence is the truth. Human judgment is the authority.

How I Built It

I built MAAV NeoLab as a strict TypeScript modular monolith using Next.js, React, Zod, Zustand, WebMCP, and Google Maps.

The architecture follows a clear authority chain:

Human UI / WebMCP / Google presentation
                    ↓
             Application service
                    ↓
            Deterministic domain
                    ↓
       Immutable evidence artifacts

The manual interface and browser agent share one repository, one application-service instance, one workspace revision, and one audit trail. An operation completed by the agent becomes visible in the interface without reloading. A manual operation becomes visible to the agent through the same authoritative state.

Every mutation validates the expected workspace revision. Every mutating agent operation carries a source-aware operation ID. Exact retries return the original terminal result, while changed arguments fail closed with an idempotency conflict.

Cancellation propagates through the application boundary and cannot publish a partial artifact or produce a delayed ghost completion. Concurrent operations cannot silently overwrite one another. Scenario revisions invalidate only the affected current evidence while preserving immutable historical artifacts.

The deterministic engine owns:

  • passenger arrivals and lifecycle;
  • assignments and vehicle movement;
  • capacity and no-standing enforcement;
  • battery and energy accounting;
  • deterministic vehicle-failure selection;
  • recovery behavior;
  • immutable ledger events;
  • replay snapshots;
  • metrics and constraints;
  • scenario comparison;
  • supported finding claims.

WebMCP remains a thin adapter. It validates strict input, injects trusted source context, calls the shared application service, and returns bounded structured results. It does not calculate simulation evidence.

Google Maps provides geographic context and replay presentation. It never supplies simulation distance, timing, traffic, dispatch, energy, metrics, comparisons, or conclusions. When Google Maps is unavailable, the authored fallback preserves the complete experiment and produces identical trusted evidence.

I used OpenAI Codex as an architecture, implementation, debugging, testing, and release-verification collaborator. I used Claude during the visual-design iteration. I reviewed the resulting implementation, protected the product's authority boundaries, and remained responsible for the final technical and product decisions.

The WebMCP workflow was exercised through Google Chrome's WebMCP browser-agent surface and ChatGPT's in-app browser assistant.

Challenges I Faced

Making AI Useful Without Making It Authoritative

The agent needed enough capability to execute a meaningful experiment, but it could not be allowed to calculate KPIs, select a convenient failure target, fabricate evidence, approve its own conclusion, or bypass human review.

I enforced this boundary through application architecture and capability design—not merely through prompting.

Achieving Genuine Reproducibility

Determinism required much more than fixing a random seed.

Event ordering, simultaneous arrivals, vehicle and passenger tie-breaks, integer units, routing, rounding, terminal passenger classification, failure timing, canonical serialization, and artifact currentness all had to be explicit.

The same normalized inputs now produce the same ledger, snapshots, metrics, and fingerprints.

Protecting Concurrent and Cancelled Operations

Browser agents retry commands. Users double-click controls. Simulations may be cancelled while computation is running.

Expected-revision checks, source-aware idempotency, generation tokens, abort-signal propagation, and atomic publication prevent duplicate artifacts, stale overwrites, partial commits, and delayed ghost results.

Separating Maps From Evidence

Google Maps makes the experiment easier to understand, but external map geometry could not become simulation authority.

I kept the authored network and deterministic engine authoritative while using Google solely as a presentation layer. Playback, camera movement, scenario selection, layer visibility, and entity inspection never alter application revisions or fingerprints.

Creating One Product for Humans and Agents

The manual interface and browser agent needed to operate the same state.

Agent actions had to become visible in the UI without reloading. Manual actions had to become visible to the agent. Final review controls had to remain exclusively human.

That required one shared runtime rather than two loosely connected demonstrations.

Designing Truthful Failure Behavior

Unsupported WebMCP, unavailable Google Maps, invalid commands, stale revisions, cancellation, and external service failures all needed to degrade safely.

The application therefore preserves the complete manual experiment when optional browser or map capabilities are unavailable, while errors remain bounded and sanitized.

What I Learned

The biggest lesson was that an AI-native application is not simply a traditional application with a chatbot attached.

A useful agent needs bounded capabilities, shared state, visible activity, strict validation, recoverable errors, deterministic behavior, and explicit authority limits.

I also learned that reproducibility is an end-to-end product property. A stable seed is not enough if event ordering, rounding, currentness, terminal-state semantics, or artifact publication remain ambiguous.

Another important lesson was that external presentation must remain separate from internal truth. A map can make evidence easier to understand, but visual plausibility must never replace provenance.

Most importantly, narrowing the first release made the product stronger.

One deeply verified experiment with immutable evidence is more valuable than a broad simulator that only appears intelligent. MAAV NeoLab can pursue an ambitious future precisely because its foundation refuses to confuse AI prose, visual presentation, or external data with proof.

Accomplishments I Am Proud Of

  • Built a complete prompt-to-evidence workflow operated through six WebMCP tools.
  • Created one shared application authority for both humans and browser agents.
  • Implemented deterministic simulation with immutable ledgers, replay snapshots, comparisons, and findings.
  • Produced a genuine trade-off result instead of a hardcoded winner.
  • Preserved human-only final review by excluding Accept, Challenge, and Reset from WebMCP.
  • Built a premium Google Maps replay interface that cannot alter trusted evidence.
  • Implemented revision safety, source-aware idempotency, cancellation, and atomic publication.
  • Preserved historical evidence while invalidating only affected current artifacts.
  • Created accessible manual controls so the experiment remains usable without WebMCP.
  • Built a release candidate supported by 278 automated tests covering determinism, contracts, concurrency, cancellation, security, replay, and UI integration.

What Is Next

The next step is to make MAAV NeoLab extensible without weakening its evidence model.

Future versions could introduce:

  • additional versioned city networks;
  • explicitly modeled disruption types;
  • controlled parameter sweeps;
  • richer experiment templates;
  • domain-specific simulation adapters;
  • deeper research-platform interoperability;
  • additional evidence-backed mobility modes.

Over time, this foundation could support explicitly modeled ground vehicles, urban air mobility, drones, delivery robotics, and other emerging systems.

These are future directions—not capabilities claimed by v0.5. Every new mode would still need transparent assumptions, deterministic execution, bounded agent authority, and verifiable evidence.

MAAV NeoLab turns imagination into an experiment—and an experiment into evidence.

Design it. Break it. Make it resilient.

Built With

Share this project:

Updates

Submission history