Technology

Infrastructure that improves itself.

We build AI agents that make the GPU code under every AI model run faster, and that get better at it with every change they keep.

01The bottleneck

AI is only as fast as its GPU kernels.

Kernels are the small programs that do a model's math on the GPU. Every new model and every new GPU needs them tuned again, and today that work is slow, scarce and done by hand.

  1. Tools see only totals.

    Profilers report figures for a whole kernel, not when each warp waited or why, so engineers and their agents guess.

    Our answer: MarsTrace traces every warp

  2. Experts do not scale.

    A few specialists tune one kernel at a time, while new models and GPUs keep arriving.

    Our answer: Agents work in parallel

  3. Lessons get lost.

    What one fix teaches is rarely written down, so the next kernel starts from zero.

    Our answer: A memory every agent reads

02Our answer

Agents that tune kernels, and learn from every change.

We call it recursive self-improvement, one layer down from the model. Instead of a model training a model, agents improve the infrastructure every model runs on, in three loops.

Turn
One kernel, made faster and checked.
Round
A model's slowest kernels, taken by agents in parallel.
Memory
Every kept change, read by the next agent on any model.
Turn · one kernel Round · one model Memory · every kernel Agents trace · fix · verify

Inside one turn

  1. Trace

    MarsTrace records a timeline of every warp in the binary you ship, closed-source libraries such as cuDNN included.

    94–98% of instructions untouched

  2. Optimize

    Agents name what limits the kernel and try the cheapest fix first: tuning, lower precision, fusion, a rewrite, a patch to the binary.

    Seven kinds of change, cheapest first

  3. Verify

    A change stays only if it is faster beyond run-to-run noise and the outputs still match.

    Faster and still correct, or dropped

  4. Remember

    Each kept change is stored with the kernel's hardware footprint. The next agent, on any model, starts from what worked.

    Shared across kernels and models

03The proof

Pika H3 Flex: the same model, made faster.

We ran the loop on Pika's reference-to-video model when we brought it to our GPUs: agents went through its engine kernel by kernel. Same weights, same six denoising steps.

  1. Official build the starting point
  2. +15 kernel optimizations 1.20–1.58× faster generation
  3. +F16 softmax and FP8 attention 1.56–1.83× faster generation

End to end, against Pika's own API

Four 10-second 768p jobs, from submitting to the finished MP4, raced again at ten times speed.

14.2 s video + 2 images 1.70×

MarsCompute53.3 s
Pika's API90.4 s

10.5 s video + 2 images 1.56×

MarsCompute50.0 s
Pika's API78.2 s

14.1 s video + 1 image 1.43×

MarsCompute47.5 s
Pika's API67.8 s

4 images 1.24×

MarsCompute36.0 s
Pika's API44.5 s

Mean of two runs per task, 13–14 November 2026.

The same method for any AI workload, across GPU generations

  • NVIDIA Blackwell

    up to 1.41×

    Found by an agent comparing traces with cuDNN's closed-source kernel, our tile ordering is now in the official FlashAttention, measured by its maintainers on B200, B300 and GB300.

    FlashAttention, November 2026

  • NVIDIA Hopper

    3.9× sooner

    Tuning FlashAttention-3 on an H100, an agent reading our trace reached its target in 14 iterations, against 54 with the best existing tracer.

    MarsRover, September 2026

  • NVIDIA Ampere

    up to 1.51×

    FlashAttention-2's forward pass on an A100, at sequence lengths of 1,024 and up, in an automated run.

    Report, March 2026

Every result, with its conditions

Customer story

Trusted at hyperscale. We built a customized MarsRover for Meta, to help its engineers optimize internal AI workloads.

Read the story