MarsTrace Early access

Trace your GPU kernel. We bring the GPU.

MarsTrace is kernel tracing as a service. Upload a CUDA kernel and say what you want to see. An agent runs it on an NVIDIA H200, B200 or B300 and returns a timeline of what happened inside, warp by warp.

How it works

From a compiled kernel to a timeline, in one job.

You do not need the GPU, the tracing tools or the time to set either up. A job takes four things from you and gives one file back.

Upload a workspace

The compiled kernel and, if you have them, its source, a launch manifest and input tensors.

Say what to trace

A prompt in plain language: which kernel, which region, and the question you want answered.

Pick the hardware

An H200, a B200 or a B300, and the CUDA toolkit version the job should run with.

Get the trace

One file, marstrace.json. Open it as a timeline in the console, or hand it to your agent as text.

Inside a job

An agent does the tracing. You read the result.

Each job gets its own GPU machine for as long as it runs. An agent instruments the compiled kernel, launches it and records when each part of it ran.

  • A dedicated machine per job. Started for your job, and removed when the job ends.
  • The binary, not a rebuild. The kernel is traced as it was compiled. Source is optional.
  • Run in a sandbox. Your workspace runs isolated, and the result is checked before it reaches you.
  • A quote first. Price a job before you submit it, and cancel one that is running.
A kernel trace open in a browser: rows of thread blocks, coloured by phase, with one region marked for an agent to read
A trace as a timeline: one row per thread block, one colour per phase of the kernel. A region marked here can be handed to an agent as it is.

Three ways in

Use it where you already work.

The command line

The marstrace client prices a job with estimate, sends it with submit and opens the result with show.

Your coding agent

MarsTrace speaks the Model Context Protocol, so an agent can submit a trace, wait for it and read the result on its own.

The console

Jobs, keys and usage sit beside your Token Factory workspace. A job opens on its trace, by thread, warp or block.

Why it can be trusted

A trace of the kernel you ship, not a different one.

MarsTrace is built on Xtrace, the tracer in G-Watch. It adds its probes after compilation, so the compiler never sees them and the kernel stays the one you built.

Existing tracers
Source or IR probes added here
Compiler builds the probes in
Binary a changed kernel
MarsTrace
Source or IR untouched
Compiler optimizes as usual
Binary probes added here

A trace is a measurement. It is useful only if the kernel being measured stays the same. Probes added before compilation change how the compiler schedules the code, and a stage can look slow only because the probe made it slow.

Original instructions still in the traced kernel

Xtrace
94–98%
Existing tracers
8–48%

Time added to the kernel

Xtrace
0.9–2.8%
Existing tracers
3.8–75.6%

Ranges across the kernels tested, on NVIDIA H100 and B300 and AMD MI300X. Source: G-Watch, September 2026.

At a glance

What early access includes.

MarsTrace is open to a first group of teams while we finish it. Tell us about the kernel you want to see inside, and we will set your workspace up.

Status
Early access, on request
Hardware
NVIDIA H200, B200 and B300
You provide
A compiled CUDA kernel and a prompt; optionally source, a launch manifest and tensors
You get
One trace file, marstrace.json, with a timeline and statistics
Interfaces
Command line, coding agents and the console
Billing
Through your MarsCompute workspace. Prices will be published when MarsTrace opens to everyone.

A trace is where an optimization starts.

See how agents turn traces into faster kernels, and the results we have published so far.