diff --git a/docs/concepts/GAMMA_RADIX_METAPROBE.md b/docs/concepts/GAMMA_RADIX_METAPROBE.md
new file mode 100644
index 00000000..357ebc08
--- /dev/null
+++ b/docs/concepts/GAMMA_RADIX_METAPROBE.md
@@ -0,0 +1,218 @@
+# Gamma Radix MetaProbe
+
+Date: 2026-05-19
+Status: BEAUTIFUL_PROVISIONAL
+
+## One-line definition
+
+Gamma Radix MetaProbe is a symbolic, receipt-bearing pulse-tracing architecture that uses gamma-length transmission as a radix metaphor for ultra-fine address/probe space, while keeping the implementation in software-accessible manifolds, WebGPU/PIST surfaces, DSP chunks, and FAMM/NUVMAP witness routing.
+
+This is **not** a claim that ordinary software can dereference literal gamma-wavelength physical memory cells. It is a virtual chart/probe encoding model: gamma-scale coordinates are lawful names, not guaranteed physical addresses.
+
+## Core idea
+
+Instead of treating ray tracing as RGB light transport through fixed geometry, treat tracing as packet propagation through admissible manifolds:
+
+```text
+pulse transport -> attenuation / delay / scatter / residual -> inferred geometry/state
+```
+
+The gamma pulse is the conceptual radix carrier. Each pulse branch is sorted by energy, direction, time, chirality, interaction kernel, spectral mode, density response, and residual scar.
+
+## Packet primitive
+
+The packet aligns with the existing compactified packet primitive:
+
+```text
+Gamma_i = gamma_i ⊗ chi_i ⊗ kappa_i ⊗ tau_i ⊗ U_i Lambda_i a_i ⊗ theta_i ⊗ epsilon_i
+```
+
+Where:
+
+- `gamma_i` = energy-density pulse / symbolic gamma carrier
+- `chi_i` = chirality, braid orientation, or handedness witness
+- `kappa_i` = material / interaction / scattering kernel
+- `tau_i` = delay shell or time-of-flight term
+- `U_i Lambda_i a_i` = spectral/eigen decomposition payload
+- `theta_i` = manifold routing angle / projection coordinate
+- `epsilon_i` = residual scar / admissibility failure witness
+
+## Radix basis
+
+The radix is not base-2 or base-10. It is a multi-axis pulse-state basis:
+
+```text
+R_Gamma = { E, theta, phi, t, chi, kappa, rho, sigma, epsilon }
+```
+
+Interpretation:
+
+| Digit | Meaning |
+|---|---|
+| `E` | energy bin / symbolic frequency band |
+| `theta, phi` | angular route / projection direction |
+| `t` | pulse arrival time / time-of-flight |
+| `chi` | chirality / braid handedness |
+| `kappa` | interaction kernel |
+| `rho` | density-field response |
+| `sigma` | spectral mode / surface state |
+| `epsilon` | residual scar / admissibility failure |
+
+## Relation to existing stack
+
+### NUVMAP
+
+NUVMAP becomes the virtual address projection layer:
+
+```text
+N = (x, y, z, t, E, chi, sigma, rho, epsilon)
+```
+
+This gives the system an ultra-dense symbolic coordinate space without claiming literal physical storage density.
+
+### FAMM
+
+FAMM routes each pulse by field, shear, spectral, and residual state:
+
+```text
+Route_Gamma = FAMM(rho, G, C, epsilon)
+G = A^T A
+C = U Lambda U^T
+```
+
+Each branch is lawful only if its residual remains below the active boundary condition.
+
+### BraidStorm
+
+A single pulse becomes a strand; many pulses become a braidstorm:
+
+```text
+B_Gamma = { Gamma_1, Gamma_2, ..., Gamma_n }
+```
+
+The useful information comes from crossings, timing shear, chirality mismatch, interference, and closure receipts.
+
+### PIST / WebGPU blitter surface
+
+The practical implementation does not require gamma radiation. The gamma pulse can be projected as:
+
+- Fourier packets
+- DSP chunks
+- audio-domain probes
+- hexcode spectral packets
+- WebGPU buffer transitions
+- PIST-like surface dispatches
+
+Each WebGPU dispatch is a bounded surface transition:
+
+```text
+PIST_GPU : Gamma_i -> Gamma_{i+1}
+```
+
+The GPU surface records residual/scar/witness output for each lawful or failed transition.
+
+### MetaProbe / WaveProbe
+
+Gamma Radix MetaProbe fits the pure L3 MetaProbe layer:
+
+- non-settling
+- probe-only
+- low-impact
+- cheap virtual execution
+- exports only when a separate settlement / receipt boundary is invoked
+
+It can be used to sample route quality, detect local manifold stress, or test compression/reconstruction hypotheses without committing every intermediate state.
+
+## Where the savings show up
+
+The savings are **not** from creating literal gamma-scale software memory. They appear by replacing expensive committed computation with cheaper probe computation.
+
+### 1. Settlement avoidance
+
+Most branches never need to become final committed state. MetaProbe can run symbolic probes, discard failed branches, and only export winners.
+
+Savings axis:
+
+```text
+full execution + storage + commit
+    -> probe + witness + selective export
+```
+
+### 2. Sparse residual transmission
+
+Instead of transmitting full state, transmit:
+
+```text
+generator + route witness + residual repair
+```
+
+This is the same savings pattern as GCCL-Rep / nibble-delta witness substrate: sparse manifold telemetry can be much smaller than raw state replay.
+
+### 3. WebGPU/edge/free-tier computation
+
+For browser/WebGPU or free-tier worker contexts, the blitter surface can run bounded, low-duty symbolic probes. The value comes from using available local/edge GPU cycles for spectral transforms instead of renting continuous server compute.
+
+Constraint: this must stay within provider terms and rate limits. The architecture is legitimate only when request caps, duty cycles, and fair-use boundaries are respected.
+
+### 4. Cacheable probe fields
+
+Radix branches that repeat can be memoized as route receipts:
+
+```text
+same packet class + same boundary condition -> reuse prior branch witness
+```
+
+This reduces repeated exploration of the same local manifold basin.
+
+### 5. Compression-native reconstruction
+
+The tracer is useful when output can be reconstructed from a compact law + residual, not when every pixel/sample/state must be explicitly stored.
+
+Savings axis:
+
+```text
+raw samples -> lawful reconstruction core + residual pullback
+```
+
+### 6. Compute triage
+
+The gamma radix is a sorting/routing device. It tells the system where expensive compute is worth spending:
+
+- low residual: accept / cache / compress
+- medium residual: refine locally
+- high residual: route to FAMM scar / reject / quarantine
+- impossible: NaN boundary / no commit
+
+## Boundary condition
+
+This concept is useful only if it remains honest about the physical/software boundary:
+
+- software can name gamma-scale coordinates
+- software cannot dereference them as physical RAM
+- WebGPU can simulate/probe the radix surface
+- FAMM/NUVMAP can route symbolic witnesses
+- exactness must be handled through residual repair and receipts
+
+## Minimal implementation target
+
+A first prototype can be purely software:
+
+1. Define `GammaPacket` with fields for energy bin, direction, time, chirality, spectral mode, and residual.
+2. Implement radix branching over packet fields.
+3. Run branches over a WebGPU or CPU spectral kernel.
+4. Emit route receipts and residual scars.
+5. Compare cost against naive full-state evaluation.
+
+## Claim status
+
+This should remain `BEAUTIFUL_PROVISIONAL` until there are benchmark receipts showing:
+
+- probe cost vs full execution cost
+- residual size vs raw output size
+- cache hit rate for repeated route witnesses
+- WebGPU dispatch cost under real browser limits
+- byte-exact reconstruction where required
+
+## Keeper phrase
+
+Gamma Radix MetaProbe: gamma-length coordinates as virtual probe radix, not physical RAM; savings appear when cheap pulse-branch probes replace committed computation, raw state transfer, and repeated full execution.