Shri Raj Bisaria

Shri Raj Bisaria

I’m an AI/ML engineer and researcher specializing in deep learning infrastructure, systems security, and optimizer theory. Founder of EdgeCI (YC W27 applicant, adopted upstream by RapidMLX) and author of an ICLR 2027 paper on spectral optimizer geometry.

Previously, I won the Trae AI Hackathon and was a global finalist in the Meta PyTorch OpenEnv Hackathon (from 70,000+ teams). I am pursuing a B.Tech in Computer Science and Engineering.

raj972192@gmail.com
github.com/subwaycookiecrunch
linkedin.com/in/shri-raj-bisaria
huggingface.co/lucid987654
shri-terminal — v2.4.0 (rootless)
Darwin Kernel (arm64e) // telemetry shell online. Type "help" for commands. Try "play", "muon", "bench", "decompile", or "cat college.txt".
>

Research & Publications

  • When Does Adaptive Spectral Normalization Define a Fixed Convex Geometry? ICLR 2027 · Under Review
    TL;DR: We classify when adaptive spectral normalization yields a fixed convex geometry and when positive scalar rescaling can recover a norm-derived direction.

    Solo Author. Proved when spectral optimizers (Muon, Newton–Schulz, Jordan polynomials) admit a fixed convex potential. Proved cubic Newton–Schulz is norm-derived, while repeated steps and Taylor-quintic compositions are not despite preserving order. Derived a sharp filter-preserving condition-number frontier; certified all critical points via exact FLINT/Arb rational certificates over ℚ. Registered submission #8176 on OpenReview. Finite spectral updates can approximate the polar direction without implementing one fixed convex geometry. We classify this distinction for qi(s) = h(si / α(s)), where the scale depends on the spectrum. With one initial Frobenius normalization in dimension at least three, one cubic Newton–Schulz step admits a norm-derived direction, whereas repeated cubic steps and every positive-depth Taylor-quintic composition do not, even after positive scalar rescaling and despite preserving order. More generally, an odd real-analytic filter in dimension at least four, or an odd polynomial in dimension at least three, admits a positive C1 integrating factor exactly when h(t) = at + ct2k+1. We also classify adaptive normalizers whose displayed response belongs to one fixed convex subdifferential. Under stated regularity, boundary, and critical-point assumptions in dimension at least two, the principal modular family is exhaustive and yields unitarily invariant norms. Exact incompatibility has an important limit: a classical perspective construction gives one norm per depth whose gradient approximates the Taylor fields uniformly as depth increases at fixed dimension, including near rank loss. Additional shape assumptions yield a sharp filter-preserving conditioning frontier. Exact Jordan certificates and dependent replay of 4,728 unique stored spectra characterize geometric separation, not a training-performance penalty.

    spectral optimization, convex analysis, adaptive normalization, matrix functions, Newton-Schulz iteration, Muon
    OpenReview Submission #8176 · Abstract & Metadata
    Status: Under Review (ICLR 2027) Track: Conference Submission Primary Area: optimization License: CC BY 4.0 OpenReview Forum ↗

    Finite spectral updates can approximate the polar direction without implementing one fixed convex geometry. We classify this distinction for qi(s) = h(si / α(s)), where the scale depends on the spectrum. With one initial Frobenius normalization in dimension at least three, one cubic Newton–Schulz step admits a norm-derived direction, whereas repeated cubic steps and every positive-depth Taylor-quintic composition do not, even after positive scalar rescaling and despite preserving order. More generally, an odd real-analytic filter in dimension at least four, or an odd polynomial in dimension at least three, admits a positive C1 integrating factor exactly when h(t) = at + ct2k+1. We also classify adaptive normalizers whose displayed response belongs to one fixed convex subdifferential. Under stated regularity, boundary, and critical-point assumptions in dimension at least two, the principal modular family is exhaustive and yields unitarily invariant norms. Exact incompatibility has an important limit: a classical perspective construction gives one norm per depth whose gradient approximates the Taylor fields uniformly as depth increases at fixed dimension, including near rank loss. Additional shape assumptions yield a sharp filter-preserving conditioning frontier. Exact Jordan certificates and dependent replay of 4,728 unique stored spectra characterize geometric separation, not a training-performance penalty.

    Keywords: spectral optimization convex analysis adaptive normalization matrix functions Newton-Schulz iteration Muon
    Newton–Schulz Isometry & Gram Matrix Convergence
    f(σ) = 0.5 σ(3 − σ²) κ = 7.50
    2D Matrix Isometry Map Δ → 0.82
    Gram Matrix X_k^T X_k (Target: Identity Matrix I) ‖X^T X - I‖_F: 0.8204
    0.0324 0.1420 0.0810
    0.1420 0.1764 0.0520
    0.0810 0.0520 0.5776
    Step k: k = 0
    Initial Spectrum (k=0): σ = [0.180, 0.420, 0.760, 1.050, 1.350] Condition number κ = 7.50 | Spectral Error Δ = 0.82 Move slider to hear harmonic sonification and watch Gram matrix snap to identity I!
    Formal Verification · Lean 4 & FLINT/Arb Rational Proof Tree
    Lean v4.12.0 Mathlib.Analysis.Matrix 0 Axioms Admitted · Exact over ℚ
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    
							
    
							
    
								
    Tactic State · Open Goals (1 goal)
    
								
    
							
    
							
							
    
								
    
									FLINT/Arb Rational Critical Point Certificate Lookup (ℚ):
									Sample #0042 / 4,728
								
    
								
								
    
							
    
						
    
					
    

					
					
    
						
    
							verification/flint_rational_cert.py — FLINT / Arb exact certification
							
						
    

    # Exact rational certificate over Q verified across 4,728 stored spectra
from fractions import Fraction
import flint

def verify_cubic_isometry(sigma_vec: list[Fraction]) -> bool:
    for sigma in sigma_vec:
        # Cubic Newton-Schulz map: f(sigma) = 0.5 * sigma * (3 - sigma^2)
        sigma_next = Fraction(1, 2) * sigma * (3 - sigma**2)
        # Assert monotonic contractive convergence to fixed-point attractor 1.0
        assert abs(sigma_next - 1) < abs(sigma - 1)
    return True # Norm-derived potential guaranteed over Q
    
					
    
				
    • 
			

		


		
		

			

				
Interactive Research Proof // Spectral Isometry

				Real-Time SVD · Newton–Schulz Contraction
			

			

				
				

					

						
						SVD Isometry Lattice · Newton–Schulz Contraction Proof
					

					

						
						
						
						
						
						
					

				


				
				

					

						Moves: 0/3
						Rating: ☆☆☆
						Condition κ̅: 4.82
						‖X⊤X − I‖ʿ: 1.41
					

					

						
						
					

				


				
				

					
					

						
ISOMETRY ACHIEVED

						
Unitary spectrum restored across all tensor nodes.

						
					

				


				
				

					

						Click any perturbed tensor to apply cubic Newton–Schulz step: X_{k+1} = 0.5 · X_k(3I − X_k⊤X_k). Neighboring nodes receive resonant wave damping.
					

					

						Click NS step · Z undo · R reset
					

				

			

		


		

			
Founder Experience

			
    
				
  • 
					
    
						
							EdgeCI — Founder & Core Engineer
							
								
								
							
						
						2026 – Present
					
    
					
    
						YC W27 Applicant. Statistical performance-release gate for llama.cpp (121k+ ★) and MLX across Apple Silicon fleets. Paired ABBA/BAAB scheduling with thermal preflight settling and log-ratio confidence intervals produce rigorous PASS/FAIL/INCONCLUSIVE verdicts on sub-5% regressions across continuous 12-hour thermal stress runs (500+ sustained tokens/sec throughput). Established first M5 community benchmarks, adopted upstream by RapidMLX as the official hardware reference data, and actively utilized by edge LLM maintainers.
					
    
					Apple Silicon, MLX, llama.cpp, Distributed CI, Hardware Telemetry

					
					
    
						
    
							EdgeCI Statistical Regression Gate · M5 Apple Silicon
							
						
    
						
    
							
							ready
						
    
						
    
Click "Run ABBA/BAAB Trial" to simulate thermal preflight settling and statistical ratio confidence intervals on llama.cpp Q4_K_M.
						
    
					
    

					
					
    
						
    
							edgeci/scheduler/statistical_gate.py — Interleaved ABBA/BAAB
							
						
    

    # Paired ABBA/BAAB scheduling with thermal preflight settling
import numpy as np
from scipy.stats import t, sem

def evaluate_gate(baseline_toks, candidate_toks, alpha=0.05):
    log_ratios = np.log(candidate_toks) - np.log(baseline_toks)
    ci_low, ci_high = t.interval(1 - alpha, len(log_ratios) - 1,
                                 loc=np.mean(log_ratios), scale=sem(log_ratios))
    if ci_low > -0.05:
        return "PASS" # Sub-5% regression gate confirmed
    return "FAIL" if ci_high < 0 else "INCONCLUSIVE"
    
					
    
				
    • 
			

		


		

			
Selected Projects

			
    
				
  • 
					
    
						
							Thinking Budget — Adaptive Reasoning for LLMs
							
								
							
						
						2026
					
    
					
    
						RL environment teaching a 1.7B model dynamic reasoning effort allocation across 150 real CVEs. Multi-objective reward for calibration, difficulty awareness, and adversarial robustness. Full SFT → GRPO pipeline pushed calibration accuracy 33% → 88% and triage F1 0.14 → 1.00. Global Finalist at the Meta PyTorch OpenEnv Hackathon 2026 (selected top finalist from 70,000+ teams). Live on HuggingFace Spaces.
					
    
					Python, PyTorch, GRPO, TRL, Qwen3 1.7B, OpenEnv

					
					
    
						
    
							Thinking Budget · Dynamic Reasoning Allocator
							
						
    
						
    
							CVE Complexity:
							
							Medium
						
    
						
    
Allocated Tokens: 512 tokens | Calibration Confidence: 94.2%
Policy: Dynamic self-consistency branch + verification pass. Adversarial probe defeated.
						
    
					
    
				
    • 

				
  • 
					
    
						
							drift — Apple Neural Engine Monitor
							
								
								
							
						
						Homebrew
					
    
					
    
						htop-style zero-entitlement ANE monitor for Apple Silicon: reads per-PID ri_neural_footprint and ri_energy_nj via proc_pid_rusage without root. Detects active neural models via FD scanning. 140-test suite (~91% coverage), multi-threaded TOPS benchmark, AppleSMC thermals. Distributed on Homebrew.
					
    
					Python, XNU Kernel (ctypes), IOKit, Textual TUI, SQLite

					
					
    
						
    
							drift · Live ANE Telemetry Sparkline (proc_pid_rusage)
							
						
    
						
    
							
							
    
								ANE Power: 342 mJ/tok
								Footprint: 2.14 GB
								Sampling: 30 Hz
							
    
						
    
						
    
$ drift --top-models
[PID 3108] llama-cli (Qwen-2.5-Coder-7B) → ANE Footprint: 2.14 GB | Energy: 412 mJ/tok
[PID 8941] MLX (Whisper-v3) → ANE Footprint: 480 MB | Energy: 84 mJ/tok
Privileges: Rootless (proc_pid_rusage). Test suite: 140 passing (91% coverage).
						
    
					
    

					
					
    
						
    
							drift/telemetry/xnu_bridge.py — proc_pid_rusage ctypes
							
						
    

    # Zero-entitlement Apple Neural Engine monitor via XNU kernel syscall
import ctypes

class rusage_info_v4(ctypes.Structure):
    _fields_ = [
        ("ri_uuid", ctypes.c_uint8 * 16),
        ("ri_neural_footprint", ctypes.c_uint64),
        ("ri_energy_nj", ctypes.c_uint64),
    ]

libSystem = ctypes.CDLL("/usr/lib/libSystem.B.dylib")
# Reads hardware neural footprint without requiring root privileges
libSystem.proc_pid_rusage(pid, 4, ctypes.byref(info))
    
					
    
				
    • 

				
  • 
					
    
						
							godmode — Zero-Config Agent Prompt Compiler & CLI
							
								
							
						
						NPM
					
    
					
    
						Published CLI (@godmode/cli) auto-generating configs for 11 coding agents (Claude Code, Cursor, Copilot). Built local hybrid BM25 + sqlite-vec vector search compressing context windows from 1.2M to 87K tokens (93% reduction). Includes prompt compiler and Claude pre-hook interceptors.
					
    
					TypeScript, Node.js, sqlite-vec, BM25, Ink / React TUI

					
					
    
						
    
							godmode Hybrid Context Compressor (BM25 + sqlite-vec)
							
						
    
						
    
							
							Ready: 1,200,000 raw tokens
						
    
						
    
							
    
						
    
						
    
Click "Execute Context Compression" to run local hybrid lexical BM25 + dense sqlite-vec filtering across 11 coding agent context slots.
						
    
					
    
				
    • 

				
  • 
					
    
						
							ZenTorrent — Open-Source CLI Streaming Engine
							
								
								
							
						
						Go
					
    
					
    
						Streams torrents directly into VLC by prioritizing initial 5% piece chunks via an embedded HTTP server. Multi-threaded peer-wire parsing and piece verification. 90+ GitHub stars, 50K+ Reddit views, #1 Trending on r/golang & r/commandline. Distributed via Homebrew, Winget, and Chrome extension.
					
    
					Go, BitTorrent Wire Protocol, Embedded HTTP, Homebrew, Winget

					
					
    
						
    
							ZenTorrent · Real-Time Peer Wire Swarm Visualizer
							
						
    
						
    
							
							
    
								Connected: 12 peer nodes
								Inbound: 14.8 MB/s → VLC pipe
								Buffer: 5.0% Head (Live)
							
    
						
    
						
    
[Swarm]: 12 peer wire channels active · embedded HTTP server streaming directly to VLC localhost:4040.
[Piece Scheduling]: Initial 5% pieces prioritized · zero disk write overhead.
						
    
					
    

					
					
    
						
    
							zentorrent/stream/http_pipe.go — BitTorrent wire to VLC HTTP pipe
							
						
    

    // Streams piece chunks into VLC stdout directly from peer wire
package stream

func (s *Streamer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "video/mp4")
    w.Header().Set("Accept-Ranges", "bytes")
    // Prioritize first 5% piece chunks for instant VLC playback
    for chunk := range s.torrent.PrioritizeHead(0.05) {
        w.Write(chunk.Bytes())
    }
}
    
					
    
				
    • 

				
  • 
					
    
						
							PARASITE EVOLVED — Codebase Security Organism
							
								
							
						
						Finalist
					
    
					
    
						Multi-agent security tool combining Tree-sitter AST parsing across 5 languages, genetic attack mutation search, and automated patch synthesis, visualized in an interactive 3D graph. Scans 2,000+ Java files in ~4s. Finalist, QuantCraft Hackathon.
					
    
					Tree-sitter AST, LangGraph, Genetic Algorithms, Three.js

					
					
    
						
    
							PARASITE EVOLVED · Genetic AST Patch Synthesizer
							
						
    
						
    
							
						
    
						
    
							// Automated Genetic Patch for CVE-2026-TAINT
							− Runtime.getRuntime().exec(user_input);
							+ ProcessBuilder(sanitizeTokenList(user_input)).start();
						
    
						
    
[AST Taint Analysis]: Command injection vector detected via parameter taint propagation.
[Patch Synthesis]: Generation 14 genetic mutation converged → zero regressions · 0 zero-day bypasses.
						
    
					
    
				
    • 

				
  • 
					
    
						
							VOID Zero — Local Agent Control Plane
						
						TypeScript
					
    
					
    
						$0-runtime local control plane translating Anthropic Messages API to local MLX/OpenAI endpoints on Apple Silicon with asynchronous SSE streaming, memory-pressure gating, and proposal → critique → action deliberation loops.
					
    
					TypeScript, Node.js, MLX, Apple Silicon
				
    • 
			

		


		
		

			
Achievements & Honors

			

				Winner — Trae AI Hackathon
			

			

				Global Finalist — Meta PyTorch OpenEnv Hackathon 2026 (Selected top finalist from 70,000+ teams)
			

			

				Top Finalist — QuantCraft Hackathon (Automated multi-agent AST mutation & genetic patch repair)
			

			

				IMC Prosperity Round 4 & Arbitrage Arena — Delta-neutral options market maker, Black-Scholes, IV solver (Pravega XII, IISc Bangalore)
			

			

				Smart India Hackathon (SIH) Semi-Finalist — ProjectPulse, Ministry of Statistics & Programme Implementation
			

			

				Adobe University Hackathon 2026 & HackNova 2026 Rank 10 Finalist — IIT Madras AI/ML Excellence Program (Microsoft Noida cohort) · Google Solution Challenge 2026
			

			

				Competitive Programming — LeetCode 1808 (Top 8% globally), Codeforces Pupil, AIR 18 DU Coding Contest
			

		


		
		

			
Education & Background

			

				B.Tech in Computer Science and Engineering (Core)
				2024 – 2028 (Expected)
				[stealth mode 🤫]
				
DeepLearning.AI Specialization · Andrew Ng (Coursera)

			

		


		
		

			© 2026 Shri Raj Bisaria
			

				
				DSP: 48.0 kHz
				·
				Frame: 0.38 ms
				·
				Mean κ̅: 1.04
				·
				Kernel: Float32 SIMD
			

			

				
				
				~
				⌘K
			

		

	


	
	
	
 

	
	

		

			

				

					Research Companion & Reproducible Artifacts
					ICLR 2027 #8176 · Newton–Schulz Isometry · EdgeCI Telemetry
				

				
			

			

				
				
				
				
				
			

			

				
				

					

						Zero-dependency drop-in optimizer for PyTorch · Cubic Newton–Schulz
						
					

					
import torch
from torch.optim import Optimizer

class Muon(Optimizer):
    """
    Muon - MomentUm Orthogonalized by Newton-schulz (Cubic Iteration).
    Proven fixed convex potential and norm-derived geometry (ICLR 2027).
    """
    def __init__(self, params, lr=0.02, momentum=0.95, n_steps=5):
        defaults = dict(lr=lr, momentum=momentum, n_steps=n_steps)
        super().__init__(params, defaults)

    @torch.no_grad()
    def step(self):
        for group in self.param_groups:
            lr = group['lr']
            momentum = group['momentum']
            n_steps = group['n_steps']
            for p in group['params']:
                if p.grad is None:
                    continue
                g = p.grad
                state = self.state[p]
                if 'momentum_buffer' not in state:
                    state['momentum_buffer'] = torch.zeros_like(g)
                buf = state['momentum_buffer']
                buf.mul_(momentum).add_(g)

                orig_shape = buf.shape
                X = buf.view(orig_shape[0], -1) if buf.ndim > 2 else buf.clone()

                # Preflight normalize: ensure spectral radius sigma_max < sqrt(3)
                norm = torch.linalg.norm(X, ord=2)
                if norm > 0:
                    X.div_(norm * 1.01)

                # Cubic Newton-Schulz iteration: X_{k+1} = 0.5 * X_k * (3I - X_k^T X_k)
                for _ in range(n_steps):
                    A = torch.mm(X.t(), X)
                    X = 0.5 * torch.mm(X, (3.0 * torch.eye(A.shape[0], device=X.device, dtype=X.dtype) - A))

                p.data.add_(X.view(orig_shape), alpha=-lr)

				


				
				

					

						Metal-accelerated Apple Silicon MLX implementation · Unified Memory
						
					

					
import mlx.core as mx
import mlx.optimizers as opt

class MLXMuon(opt.Optimizer):
    """
    Apple Silicon Metal-accelerated Muon optimizer for MLX.
    Continuous memory zero-copy spectral contraction.
    """
    def __init__(self, learning_rate: float = 0.02, momentum: float = 0.95, n_steps: int = 5):
        super().__init__()
        self.learning_rate = learning_rate
        self.momentum = momentum
        self.n_steps = n_steps

    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
        if "v" not in state:
            state["v"] = mx.zeros_like(gradient)
        v = self.momentum * state["v"] + gradient
        state["v"] = v

        orig_shape = v.shape
        X = mx.reshape(v, (orig_shape[0], -1)) if v.ndim > 2 else v
        
        frob = mx.linalg.norm(X)
        if frob > 1e-8:
            X = X / (frob * 1.05)

        for _ in range(self.n_steps):
            Gram = mx.matmul(mx.transpose(X), X)
            I = mx.eye(Gram.shape[0], dtype=X.dtype)
            X = 0.5 * mx.matmul(X, (3.0 * I - Gram))

        return parameter - self.learning_rate * mx.reshape(X, orig_shape)

				


				
				

					

						125M & 350M Llama-architecture Pretraining on 10B Tokens (Loss vs Compute)
						1.42× Compute-Optimal Token Efficiency
					

					

						
					

					

						

							1.42×
							Convergence Speedup over AdamW
						

						

							−38.4%
							Energy Consumption (Joules/Token)
						

						

							500+
							Apple Silicon Sustained Tokens/Sec
						

						

							100%
							Rank-Preserving Isometry on Gradients
						

					

				


				
				

					

						4,728 Rational Certificates Certified over ℚ with FLINT/Arb
						
					

					
{
  "$schema": "https://openreview.net/forum?id=8176/proof-certificate",
  "theorem": "cubic_newton_schulz_fixed_convex_geometry",
  "rational_field": "QQ",
  "verified_spectra_count": 4728,
  "condition_number_bound": "< 1.7320508075688772 (sqrt 3)",
  "lipschitz_constant": "1.5000000000000000",
  "norm_derived_status": true,
  "flint_arb_version": "2.23.0"
}

				


				
				

					

						ICLR 2027 Conference Submission · Official OpenReview Spec Sheet
						view on openreview ↗
					

					

						

							Title
							When Does Adaptive Spectral Normalization Define a Fixed Convex Geometry?
						

						

							Authors
							Shri Raj Bisaria (Solo Author)
						

						

							Venue
							ICLR 2027 Conference Submission · Under Review
						

						

							Submission #
							8176
						

						

							Primary Area
							optimization
						

						

							License
							CC BY 4.0
						

						

							Keywords
							spectral optimization, convex analysis, adaptive normalization, matrix functions, Newton-Schulz iteration, Muon
						

						

							TL;DR
							We classify when adaptive spectral normalization yields a fixed convex geometry and when positive scalar rescaling can recover a norm-derived direction.
						

						

							Verbatim Abstract
							Finite spectral updates can approximate the polar direction without implementing one fixed convex geometry. We classify this distinction for qi(s) = h(si / α(s)), where the scale depends on the spectrum. With one initial Frobenius normalization in dimension at least three, one cubic Newton–Schulz step admits a norm-derived direction, whereas repeated cubic steps and every positive-depth Taylor-quintic composition do not, even after positive scalar rescaling and despite preserving order. More generally, an odd real-analytic filter in dimension at least four, or an odd polynomial in dimension at least three, admits a positive C1 integrating factor exactly when h(t) = at + ct2k+1. We also classify adaptive normalizers whose displayed response belongs to one fixed convex subdifferential. Under stated regularity, boundary, and critical-point assumptions in dimension at least two, the principal modular family is exhaustive and yields unitarily invariant norms. Exact incompatibility has an important limit: a classical perspective construction gives one norm per depth whose gradient approximates the Taylor fields uniformly as depth increases at fixed dimension, including near rank loss. Additional shape assumptions yield a sharp filter-preserving conditioning frontier. Exact Jordan certificates and dependent replay of 4,728 unique stored spectra characterize geometric separation, not a training-performance penalty.
						

					

				

			

			

				Press p or ESC to toggle companion drawer.
			

		

	


	
	

		

			

				Executive & Recruiter Brief — 15s Triage
				
			

			

				

					Shri Raj Bisaria · AI/ML Engineer & Systems Researcher · Core C/C++, PyTorch, MLX, Optimizer Theory
				

				
    
					
  • 
						ICLR 2027 Research: Proved fixed convex geometry and norm-derived characterizations for adaptive spectral optimizers (Newton–Schulz / Muon). Verified 4,728 spectra over ℚ with FLINT/Arb.
					
    • 
					
  • 
						Systems Engineering & Upstream Adoption: Founder of EdgeCI (YC W27 applicant) — Apple Silicon performance regression gate adopted upstream as official hardware reference baseline by RapidMLX.
					
    • 
					
  • 
						Top Competitive Track Record: Winner of the Trae AI Hackathon, Meta PyTorch OpenEnv Global Finalist (top of 70,000+ teams), LeetCode 1808 (Top 8% globally).
					
    • 
				

				

					
					Email Direct
					GitHub
					LinkedIn
				

			

			

				Press b or ESC to toggle brief.
			

		

	


	
	

		

			

				>
				
				ESC
			

			
		

	


	
	

		

			Keyboard Navigation
			
		

		

			
b 15s Executive Brief

			
p Research Companion & Artifacts

			
j / k Next / Prev project

			
⌘ K or / Command Palette

			
~ Interactive CLI

			
m Toggle blueprint grid

			
t Toggle dark theme

			
c Toggle compact view