diff --git a/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/VantaQsSkin.kt b/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/VantaQsSkin.kt
new file mode 100644
index 00000000..3f661a0b
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/VantaQsSkin.kt
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2026 Vanta
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.qs.panels.ui.compose
+
+import androidx.compose.runtime.Composable
+
+/**
+ * True when the Vanta Deck skin (glass tiles, light-bar brightness, day header) is drawn.
+ *
+ * AOSP has no QS style picker, so on Vanta the Deck is simply the quick settings: this is the one
+ * switch every Deck hook reads, kept so a future opt-out lands in a single place.
+ */
+@Composable fun rememberVantaQsSkin(): Boolean = true
diff --git a/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/infinitegrid/Tile.kt b/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/infinitegrid/Tile.kt
index 2d6145d1..11df29f0 100644
--- a/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/infinitegrid/Tile.kt
+++ b/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/infinitegrid/Tile.kt
@@ -95,6 +95,7 @@ import com.android.systemui.qs.panels.ui.compose.infinitegrid.CommonTileDefaults
 import com.android.systemui.qs.panels.ui.compose.infinitegrid.CommonTileDefaults.TileHeight
 import com.android.systemui.qs.panels.ui.compose.infinitegrid.CommonTileDefaults.longPressLabelMoreDetails
 import com.android.systemui.qs.panels.ui.compose.infinitegrid.CommonTileDefaults.longPressLabelSettings
+import com.android.systemui.qs.panels.ui.compose.rememberVantaQsSkin
 import com.android.systemui.qs.panels.ui.viewmodel.AccessibilityUiState
 import com.android.systemui.qs.panels.ui.viewmodel.DetailsViewModel
 import com.android.systemui.qs.panels.ui.viewmodel.IconProvider
@@ -169,14 +170,23 @@ fun ContentScope.Tile(
                 tile.state.collect { value = it.toIconProvider() }
             }
 
-        val colors = TileDefaults.getColorForState(uiState, iconOnly)
+        val vantaSkin = rememberVantaQsSkin()
+        val colors =
+            if (vantaSkin) {
+                VantaTileStyle.colors(uiState.visualState, uiState.handlesToggleClick && !iconOnly)
+            } else {
+                TileDefaults.getColorForState(uiState, iconOnly)
+            }
         val hapticsViewModel: TileHapticsViewModel =
             rememberViewModel(traceName = "TileHapticsViewModel") {
                 tileHapticsViewModelFactory.create(tile)
             }
 
         // TODO(b/361789146): Draw the shapes instead of clipping
-        val tileShape by TileDefaults.animateTileShapeAsState(uiState)
+        val stockTileShape by TileDefaults.animateTileShapeAsState(uiState)
+        val tileShape = if (vantaSkin) VantaTileStyle.shape(iconOnly) else stockTileShape
+        val vantaChipModifier = rememberVantaChipModifier(vantaSkin, uiState.visualState, iconOnly)
+        val vantaBodyModifier = rememberVantaBodyModifier(vantaSkin, uiState.visualState)
         val animatedColor by animateColorAsState(colors.background, label = "QSTileBackgroundColor")
         val isDualTarget = uiState.handlesToggleClick
         val interactionSource = remember { MutableInteractionSource() }
@@ -187,7 +197,11 @@ fun ContentScope.Tile(
             val marginBottom =
                 with(LocalDensity.current) { QuickSettingsShade.Dimensions.VerticalPadding.toPx() }
 
-            val animatedCornerRadius by animateDpAsState(TileDefaults.tileRadius(uiState))
+            val animatedCornerRadius by
+                animateDpAsState(
+                    if (vantaSkin) VantaTileStyle.cornerRadius(iconOnly)
+                    else TileDefaults.tileRadius(uiState)
+                )
 
             val inactiveCornerRadius = InactiveIconCornerRadius
             surfaceRevealModifier =
@@ -240,7 +254,8 @@ fun ContentScope.Tile(
                             orientation = Orientation.Horizontal,
                             bounceEnd = currentBounceableInfo.bounceEnd,
                             interactionSource = interactionSource,
-                        ),
+                        )
+                        .then(vantaChipModifier),
             ) { expandable ->
                 // Use main click on long press for small, available dual target tiles.
                 // Open settings otherwise.
@@ -306,7 +321,7 @@ fun ContentScope.Tile(
                     accessibilityUiState = uiState.accessibilityUiState,
                     iconOnly = iconOnly,
                     isDualTarget = isDualTarget,
-                    modifier = contentRevealModifier,
+                    modifier = contentRevealModifier.then(vantaBodyModifier),
                 ) {
                     val iconProvider: Context.() -> Icon = { getTileIcon(icon = icon) }
                     if (iconOnly) {
diff --git a/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/infinitegrid/VantaTileStyle.kt b/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/infinitegrid/VantaTileStyle.kt
new file mode 100644
index 00000000..a97dca8a
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/qs/panels/ui/compose/infinitegrid/VantaTileStyle.kt
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2026 Vanta
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.qs.panels.ui.compose.infinitegrid
+
+import android.graphics.BlurMaskFilter
+import android.graphics.Paint
+import android.service.quicksettings.Tile.STATE_ACTIVE
+import android.service.quicksettings.Tile.STATE_UNAVAILABLE
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.spring
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.draw.drawWithCache
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.compositeOver
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.drawscope.drawIntoCanvas
+import androidx.compose.ui.graphics.lerp
+import androidx.compose.ui.graphics.nativeCanvas
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.res.colorResource
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+/**
+ * Vanta Deck tile skin: every tile is a glass chip.
+ *
+ * Inactive: near-black glass body (#12181D -> #0A0D10, lit from the top) with a dim rim.
+ * Active: the body tinted with the accent at 18%, the rim at full accent and a soft outer glow.
+ * Icon and label are accent when active, #EAF6FA otherwise.
+ *
+ * The body is painted in two layers: [TileColors.background] is the flat mid glass the Expandable
+ * fills with, so the launch/expand animation keeps a solid glass ghost, and
+ * [rememberVantaBodyModifier] lays the lit top-to-bottom gradient over it inside the tile. The rim
+ * and the glow are painted by [rememberVantaChipModifier], which wraps the whole tile: glow behind,
+ * rim over the content.
+ */
+object VantaTileStyle {
+    val GlassTop = Color(0xFF12181D)
+    val GlassBottom = Color(0xFF0A0D10)
+    val GlassMid = Color(0xFF0E1317)
+    val RimDim = Color(0xFF1B6F80)
+    val Text = Color(0xFFEAF6FA)
+    val TextDim = Color(0xFF8A9BA3)
+
+    val SmallCorner = 18.dp
+    val LargeCorner = 24.dp
+    val RimWidth = 1.2.dp
+    val GlowRadius = 18.dp
+
+    const val ActiveTint = 0.18f
+    const val DualTargetTint = 0.24f
+    const val GlowAlpha = 0.55f
+    const val UnavailableAlpha = 0.38f
+
+    /** Vanta motion tokens: springy, not sliding. */
+    const val SpringStiffness = 380f
+    const val SpringDamping = 0.78f
+
+    fun cornerRadius(iconOnly: Boolean): Dp = if (iconOnly) SmallCorner else LargeCorner
+
+    fun shape(iconOnly: Boolean): RoundedCornerShape = RoundedCornerShape(cornerRadius(iconOnly))
+
+    /** The single light source: the Monet accent (Vanta seeds it #35E0FF). */
+    @Composable fun accent(): Color = colorResource(android.R.color.system_accent1_200)
+
+    /** The accent wash over glass for [state]: 18% accent when active, clear otherwise. */
+    @Composable
+    fun tint(state: Int): Color =
+        if (state == STATE_ACTIVE) accent().copy(alpha = ActiveTint) else Color.Transparent
+
+    /**
+     * Tile colours for [state]. [dualTarget] is a large tile whose icon is a separate toggle; its
+     * icon square gets its own accent wash so the two targets stay readable.
+     */
+    @Composable
+    fun colors(state: Int, dualTarget: Boolean): TileColors {
+        val accent = accent()
+        val active = state == STATE_ACTIVE
+        val unavailable = state == STATE_UNAVAILABLE
+        val fg =
+            when {
+                unavailable -> Text.copy(alpha = UnavailableAlpha)
+                active -> accent
+                else -> Text
+            }
+        val fgDim =
+            when {
+                unavailable -> TextDim.copy(alpha = UnavailableAlpha)
+                active -> accent.copy(alpha = 0.72f)
+                else -> TextDim
+            }
+        // Only a dual target large tile draws its icon square; everything else keeps it clear.
+        val iconWash =
+            when {
+                !dualTarget -> Color.Transparent
+                active -> accent.copy(alpha = DualTargetTint)
+                else -> Text.copy(alpha = 0.06f)
+            }
+        return TileColors(
+            background = tint(state).compositeOver(GlassMid),
+            iconBackground = iconWash,
+            label = fg,
+            secondaryLabel = fgDim,
+            icon = fg,
+        )
+    }
+}
+
+/**
+ * The glass body: #12181D at the top falling to #0A0D10, both washed with the accent when active.
+ * Drawn behind the tile's content, over the Expandable's flat [TileColors.background]. Always call
+ * it (it holds animation state); it returns [Modifier] unchanged when [enabled] is false.
+ */
+@Composable
+fun rememberVantaBodyModifier(enabled: Boolean, state: Int): Modifier {
+    val tint = VantaTileStyle.tint(state)
+    val spec =
+        spring<Color>(
+            dampingRatio = VantaTileStyle.SpringDamping,
+            stiffness = VantaTileStyle.SpringStiffness,
+        )
+    val top by
+        animateColorAsState(
+            tint.compositeOver(VantaTileStyle.GlassTop),
+            spec,
+            label = "VantaTileTop",
+        )
+    val bottom by
+        animateColorAsState(
+            tint.compositeOver(VantaTileStyle.GlassBottom),
+            spec,
+            label = "VantaTileBottom",
+        )
+    if (!enabled) return Modifier
+    return Modifier.drawBehind { drawRect(brush = Brush.verticalGradient(listOf(top, bottom))) }
+}
+
+/**
+ * Rim + outer glow for a Vanta glass chip. Always call it (it holds animation state); it returns
+ * [Modifier] unchanged when [enabled] is false. Apply it outermost on the tile so the glow is not
+ * clipped by the tile's own shape clip.
+ */
+@Composable
+fun rememberVantaChipModifier(enabled: Boolean, state: Int, iconOnly: Boolean): Modifier {
+    val accent = VantaTileStyle.accent()
+    val activeTarget = if (state == STATE_ACTIVE) 1f else 0f
+    val lit by
+        animateFloatAsState(
+            targetValue = activeTarget,
+            animationSpec =
+                spring(
+                    dampingRatio = VantaTileStyle.SpringDamping,
+                    stiffness = VantaTileStyle.SpringStiffness,
+                ),
+            label = "VantaTileLit",
+        )
+    if (!enabled) return Modifier
+    val dim = if (state == STATE_UNAVAILABLE) VantaTileStyle.UnavailableAlpha else 1f
+    val corner = VantaTileStyle.cornerRadius(iconOnly)
+    return Modifier.drawWithCache {
+        val radius = corner.toPx()
+        val rim = VantaTileStyle.RimWidth.toPx()
+        val glowPaint =
+            Paint(Paint.ANTI_ALIAS_FLAG).apply {
+                style = Paint.Style.FILL
+                maskFilter =
+                    BlurMaskFilter(VantaTileStyle.GlowRadius.toPx() / 2f, BlurMaskFilter.Blur.OUTER)
+            }
+        val rimInset = Offset(rim / 2f, rim / 2f)
+        val rimSize = Size(size.width - rim, size.height - rim)
+        val rimCorner = CornerRadius((radius - rim / 2f).coerceAtLeast(0f))
+        val rimStroke = Stroke(width = rim)
+        onDrawWithContent {
+            val l = lit.coerceIn(0f, 1f)
+            if (l > 0.01f) {
+                glowPaint.color = accent.copy(alpha = VantaTileStyle.GlowAlpha * l * dim).toArgb()
+                drawIntoCanvas {
+                    it.nativeCanvas.drawRoundRect(
+                        0f,
+                        0f,
+                        size.width,
+                        size.height,
+                        radius,
+                        radius,
+                        glowPaint,
+                    )
+                }
+            }
+            drawContent()
+            // Lit rim: bright at the top edge, fading to the deep teal at the bottom.
+            val rimTop = lerp(VantaTileStyle.RimDim.copy(alpha = 0.7f), accent, l)
+            val rimBottom = lerp(VantaTileStyle.RimDim.copy(alpha = 0.35f), VantaTileStyle.RimDim, l)
+            drawRoundRect(
+                brush = Brush.verticalGradient(listOf(rimTop, rimBottom)),
+                topLeft = rimInset,
+                size = rimSize,
+                cornerRadius = rimCorner,
+                alpha = dim,
+                style = rimStroke,
+            )
+        }
+    }
+}
