How to Build Autonomous-Vehicle Tests with Decart Oasis 3 Real-Time World Model API

In practice, Decart launched Oasis 3 on 10 June 2026 as an API-first, photorealistic world model for autonomous-vehicle (AV) testing. The service lets developers describe a driving scene in plain text, send throttle-steering actions, and receive video frames in real time. This article walks you through setting up the SDK, designing repeatable test suites, and scaling runs for edge-case coverage.

Why Use a Real-Time World Model for AV Testing?

Traditional simulation platforms rely on pre-baked maps and physics engines. They excel at repeatability but struggle with rare, high-entropy scenarios such as sudden flash floods or unexpected pedestrian behavior. Oasis 3 generates new, photorealistic environments on the fly, which means you can create virtually unlimited variations of a single edge case.

So what does that mean for an AV team in 2026? First, you can cut the cost of collecting real-world miles for rare events. Second, you can run continuous integration (CI) pipelines that automatically spin up a fresh world for each pull request, catching regressions before they hit the road.

Real-world usage reports from early adopters (e.g., a Tier-2 autonomous-shuttle startup) show a 30 % reduction in time-to-detect perception bugs when they added Oasis 3 to their existing simulation stack (source: TechCrunch, 10 June 2026).

Getting Started: Install the Python SDK

Decart publishes the decart-oasis package on PyPI. The latest version (0.0.1) was released on 9 June 2026 and includes a lightweight gRPC client, VP9/JPEG decoding, and a context-manager wrapper.

pip install decart-oasis

After installing, set your API key. Decart reads the DECART_API_KEY environment variable automatically, but you can also pass it directly to the client.

import os
os.environ['DECART_API_KEY'] = 'sk-xxxxxxxxxxxxxxxx'
from decart_oasis import A2VClient

client = A2VClient()  # reads the env var

The SDK uses TLS by default and points to https://oasis-grpc.decart.ai. For local debugging you can override the endpoint and disable TLS.

Creating a Scene with a Text Prompt

Oasis 3 works like a text-to-video model. You start a session, send a prompt, and the model builds a 3-camera world that matches the description.

with A2VClient() as client:
    # Define a rainy downtown intersection in Tokyo
    client.prompt("rainy night at a busy Tokyo intersection, wet asphalt, neon signs, pedestrians with umbrellas")
    streams = client.initialize()
    print(streams)  # ['left_forward', 'front', 'right_forward']

Calling prompt() again resets the world, which is handy for test isolation. The model generates one frame per action chunk (four actions → four frames per stream). Each frame is roughly 8,000 tokens, according to Decart’s CTO in a TechCrunch interview (10 June 2026).

Driving the Vehicle: Sending Actions and Receiving Frames

After the scene is ready, you feed throttle-steering pairs. The SDK expects a list of [throttle, steering] values where throttle is 0-1 and steering is –1 (full left) to 1 (full right).

actions = [
    [0.2, 0.0],  # gentle acceleration, straight
    [0.2, 0.0],
    [0.2, 0.1],  # slight right turn
    [0.2, 0.1]
]
result = client.infer(actions)  # returns 4 frames per stream

# Decode the first front-camera frame (VP9 bytes)
import av
container = av.open(result['front'][0])
for frame in container.decode(video=0):
    frame.to_image().save('frame0.png')
    break

In practice, you would loop infer() inside a simulation step, feeding the latest control output from your perception-planning stack and recording the frames for later analysis.

Designing Repeatable Test Suites

To get CI-grade reliability, wrap the above logic in a test harness that:

• Creates a fresh scene for each test case.
• Runs a deterministic action script (e.g., a lane-change maneuver).
• Collects sensor data (camera frames, depth maps if enabled) and compares against ground-truth expectations.
• Logs latency and token usage for cost estimation.

Here’s a minimal pytest example:

def test_lane_change():
    with A2VClient() as client:
        client.prompt("sunny suburban road, two lanes, clear sky")
        client.initialize()
        # Straight for 2 seconds, then right lane change
        actions = [[0.3, 0.0]] * 8 + [[0.3, 0.5]] * 4
        frames = client.infer(actions)
        # Simple check: front camera should show lane markings shift right
        assert detect_lane_shift(frames['front'])

Because the world is generated on demand, you can add random variations (e.g., fog density) by appending modifiers to the prompt. This gives you a combinatorial explosion of test cases without manual map authoring.

Scaling Up: Parallel Sessions and Cost Management

Decart charges $0.02 per second of generated video. A typical 10-second lane-change test costs $0.20. If you run 1,000 parallel sessions for a full-scale regression suite, the hourly bill tops out at $720. Enterprise contracts can lower the per-second rate to $0.015, according to Decart’s pricing page (June 2026).

To keep costs in check, monitor token usage via the x-session-token-count metadata header returned on each infer() call. You can also set a max-duration per session and abort early if a failure is detected.

Comparison Table: Oasis 3 vs Google Genie 3 vs World Labs Marble

Original Analysis: When Does Oasis 3 Beat Traditional Simulators?

Traditional simulators (e.g., CARLA, NVIDIA DRIVE Sim) excel at physics accuracy but require pre-built maps. Oasis 3 shines when you need high-entropy visual variation quickly. If you run a test suite that needs 10,000 unique weather-intersection combos, building that many CARLA maps would take weeks and cost thousands of compute hours. Oasis 3 can generate the same number of combos in a few hours of API time, at a predictable $200-$300 budget.

However, for low-level control validation—such as verifying tire-force models—Oasis 3’s physics is still a limitation. The best practice in 2026 is a hybrid pipeline: run high-level perception and planning tests in Oasis 3, then validate critical control loops in a physics-rich simulator.

Practical Takeaway: Who Should Use This?

• ✅ AV startups that need rapid visual edge-case generation without hiring a map-building team.
• ✅ Tier-1 OEM testing groups looking to augment existing simulation pipelines with photorealistic diversity.
• ✅ Robotics researchers who want a quick driving-scene sandbox for reinforcement-learning experiments.
• ❌ Safety-critical control teams that require millimeter-accurate physics; they should still rely on dedicated physics simulators.

Step-by-Step Checklist

1️⃣ Sign up for a Decart API key (https://decart.ai)
2️⃣ Install the Python SDK: pip install decart-oasis
3️⃣ Write a prompt that describes the target scenario
4️⃣ Initialize the session and retrieve camera streams
5️⃣ Loop: send throttle-steering actions → receive frames
6️⃣ Store frames and metadata for offline analysis
7️⃣ Integrate the harness into CI (e.g., GitHub Actions)
8️⃣ Monitor token usage and adjust budget alerts
9️⃣ Scale with parallel sessions for large regression suites
🔟 Review physics limits and fallback to a high-fidelity simulator when needed

Conclusion

Decart Oasis 3 API gives AV developers a fast, cost-predictable way to generate endless photorealistic driving worlds. By following the steps above, you can build repeatable test suites, catch perception bugs early, and keep your simulation budget under control. Use Oasis 3 for visual edge-case coverage, and pair it with a physics-rich simulator for low-level control validation. The result is a more robust autonomous-driving stack ready for the roads of 2026 and beyond.