Catalog
Projects
Every public repository across both GitHub accounts. Filter by category and status — or start with the six featured case studies.
gada-gpu-analytics
GADA asks a systems question most GPU benchmarks dodge: when does moving an analytical workload to a GPU make the whole application faster, not just the kernel? It implements a database-style scan/filter/reduction query in CUDA C++ on an RTX 5090 and follows the bottleneck through seven implementation stages — warp-shuffle and vectorized kernels, CUB/Thrust references, pinned-memory execution, and chunked multi-stream pipelines. The optimized kernel runs 24.2x faster than a 24-thread AVX2 CPU baseline at 1672 GB/s (93.3% of DRAM bandwidth), yet the complete GPU application stays ~1.4x slower because PCIe transfer dwarfs the kernel. Async streaming overlapped 92.6% of kernel execution with transfers and still improved total runtime only 6%.
contextfidelity
A preregistered replication of the 2026 finding that coding agents get worse at following instructions as a work session gets longer. The setup is deliberately simple: give an agent one repository rule (e.g. every new function must begin with // @tracked), have it do a real multi-function coding task, then score every function in order to test whether compliance decays with session length. The reproduction criterion is fixed before any data are collected, and a null result is a result. If the effect reproduces, the study extends along two axes: whether harder instructions make the decay worse, and whether re-surfacing the rule mid-session reduces it.
cachelens
A profiler for LLM prompt-cache economics: find the bytes that broke your prefix, and what they cost. CacheLens analyzes captured LLM requests turn by turn, pinpoints where a reusable prompt prefix stopped matching — a stray timestamp, a reordered tool schema, a volatile DOM block — estimates the wasted token cost, and recommends what to change. Ordinary hit-rate dashboards only tell you the cache missed; this tells you exactly what broke it, why, and how much that mistake costs. Built for teams running large agentic workloads on cached APIs, where one small prompt bug can silently burn thousands of tokens per request.
kubegpu-lab
A reproducible single-node Kubernetes GPU lab on WSL2 that runs real CUDA/PyTorch computation on a physical NVIDIA GPU, then deliberately breaks the stack to teach GPU workload diagnosis. It validates the full path from the Windows-hosted NVIDIA driver through WSL GPU paravirtualization, the NVIDIA Container Toolkit, k3s/containerd, and the device plugin down to a CUDA PyTorch Job. Then it reproduces five controlled failures — GPU exhaustion, unsatisfiable placement, taint/toleration mismatch, invalid accelerator requests, VRAM exhaustion — each with Kubernetes events, GPU state, and generated evidence. Verified on an RTX 5090; the goal isn't a production fleet, it's making the accelerator execution path real, observable, and diagnosable.
agentlens
A local, developer-controlled reliability and regression layer for Python agent systems. AgentLens records structured traces, attributes token cost, detects structural pathologies, runs deterministic CI gates, and retrieves similar previous failures — designed to complement hosted products like LangSmith, not reproduce them. Change a prompt, model, retriever, or workflow graph, and it compares the candidate against a known-good baseline to catch regressions (wrong tool used, wrong policy retrieved, evidence uncited, limits blown) before the change ships. Version 0.5 adds repeatable GitHub Actions CI for the deterministic core and a real ephemeral PostgreSQL/pgvector integration path.
flex_kv
A lightweight LLM inference memory engine for long-context decoding that treats precision as a runtime property of each KV-cache block rather than a cache-wide dtype choice. Recent and policy-selected blocks stay in BF16/FP16 while older blocks are demoted to FP8 and read directly by the decode kernel — no full-cache materialization back to BF16. It combines paged KV-cache allocation, dynamic block-level precision tiering, fused Triton attention kernels, and prefix-aware block reuse to squeeze more context into limited GPU memory. On an RTX 5090, mixed BF16+FP8 decode throughput at 4K/8K context measured within ~0.2% of the BF16-only paged path.
kernelproof
A correctness-first verifier, profiler, and reward generator for AI-written Triton kernels. KernelProof treats every model-generated accelerator optimization as an untrusted hypothesis: no performance reward until the candidate reproduces a higher-precision reference across deterministic edge cases, emits finite output, and repeats exactly. Passing candidates are measured with CUDA events, scored with a versioned reward contract, and optionally captured with Nsight Systems. It guards against silently fast kernels that mishandle tails, overflow reductions, or assume contiguous storage — the missing layer between 'the model produced a kernel' and 'this change is credible enough to train on or ship'.
gpu-data-pipeline-benchmarks
A reproducible Pandas vs. RAPIDS cuDF case study for a typed ETL workload: predicate filtering, a many-to-one hash join, derived-column arithmetic, grouped aggregation, and sorting. Every run records where the time goes (H2D transfer vs. compute vs. D2H), verifies both engines produce equivalent results, measures GPU energy via NVML, and separates measured facts from cost-analysis assumptions. Measured on an RTX 5090: 5.74x end-to-end speedup over Pandas on 15M rows (0.177s vs 1.018s), with H2D transfer accounting for 0.133s of the 0.177s GPU time — transfer-dominated. Machine-readable JSON plus a generated Markdown result card for every run; no expected speedup target, only committed outputs.
wsl-agent-bridge
Let a Windows-hosted AI coding agent work directly inside WSL — its Linux tools, Conda environments, native filesystem — even when the agent has no documented WSL support. The whole trick is wsl.exe: if the agent can run a shell command on the Windows host, it can already reach WSL, because Windows-to-WSL interop is built in and wsl.exe is just another executable. This repo documents the pattern, a reusable prompt template, a safe capability probe, and the reliability gotchas that actually bite — framed as one-shot SSH with local transport. Agent-agnostic and standard Microsoft-documented interop, not an exploit.
gpu-fit
Which GPU, quantization, and vLLM serving flags to run any LLM — from a first-principles VRAM + bandwidth model. Run 'gpu-fit llama-3.1-8b' and it ranks GPU options by cost per million tokens, tells you whether you need int8/int4, how many cards for tensor-parallel, and hands you a runnable vllm serve command. All offline, from model architecture and GPU specs — no renting machines and OOM-ing first. It answers the four questions every serving decision starts with: will it fit, do I quantize, one GPU or many, and what does it actually cost per million tokens.
robofleet-nexus
A production-style robotics fleet orchestration layer for ROS2, NVIDIA Isaac workflows, telemetry, diagnostics, GPU-aware simulation scheduling, and tamper-evident auditability. It sits above ROS2, Isaac Sim, and robot-control systems as a unified control plane: live WebSocket fleet dashboard, FastAPI control plane, ROS2 telemetry ingestion, GPU inventory with simulation capability profiling, Isaac workload admission control, and Claude-powered root-cause analysis. A heavy Isaac Sim job gets rejected before launch when the local GPU doesn't meet the VRAM threshold. Every event lands in a tamper-evident SHA-256 hash-chain audit trail.
gpu-rdma-roce-lab
A reproducible Linux lab for GPU-aware RDMA/RoCE networking, storage fabric validation, and performance benchmarking. It's a disciplined homelab-style engineering artifact: check system state before benchmarking, validate RDMA/RoCE readiness, run TCP baselines separately, and capture fio storage-path and GPU Direct Storage results in reviewer-safe sanitized form. The discipline is the point — avoid overclaiming, preserve raw evidence locally, sanitize before publishing, and document what was and was not tested. Covers RDMA/RoCE validation, NVMe-oF, NFS/RDMA, and GPU Direct Storage with troubleshooting workflows suitable for public review.
synthetic-devops-gpu
Synthetic DevOps probes for GPU-enabled developer, AI, and infrastructure environments. Traditional synthetic monitoring asks 'can a user complete the workflow' — this asks 'can this machine still execute the accelerated workflow correctly, within expected latency and resource bounds'. The v0.1 probes check NVIDIA driver visibility, CUDA compiler presence, PyTorch CUDA availability, and GPU memory allocation, catching the fragile states where nvidia-smi works but PyTorch can't use CUDA, or driver and toolkit versions disagree. Small active probes you run locally, in CI, during environment setup, or before launching expensive workloads; complements Prometheus/DCGM rather than replacing it.
ampere-llm-perf-lab
An end-to-end LLM inference optimization study on an NVIDIA RTX A1000 laptop GPU (Ampere, SM 8.6, 6 GB). Status is scaffolding only — benchmarks are still coming. The goal is to document what's actually achievable on a constrained 6 GB mobile Ampere card, where memory pressure dominates every serving decision.
roboapi
The unified API layer for robotics: connect any robot, any brand, with one SDK — Stripe, but for robots. Every manufacturer ships a different SDK, protocol, and data format; RoboAPI abstracts them into one clean developer experience — connect to any robot, then use universal move commands and normalized telemetry regardless of hardware. Built on FastAPI with ROS2 Jazzy support, simulated and real-hardware backends, and 14 passing tests. The multi-billion-dollar tax on the robotics industry is every team rewriting the same integration layer from scratch.
kingston-teleport
A reproducible, QPU-budget-capped study of real-time classical feed-forward on IBM's 156-qubit ibm_kingston (Heron R2) processor. The question: can a cloud user teleport an unknown qubit state and apply the Bell-measurement corrections while the destination qubit is still active inside one dynamic circuit? The preregistered hypothesis was not supported — live feed-forward reached 0.6574 mean fidelity against the 2/3 classical threshold, strongly axis-dependent. But the offline-corrected path hit 0.9512, showing the teleportation correlations were present and localizing the interesting behavior to the live-control path. A negative result with honest error bars.
q-tensor
Independent reproduction, correction, benchmarking, and prospective hardware study of GPU-accelerated noisy quantum trajectory simulation with tensor networks, starting from NVIDIA Research's open PTSBE work. Three questions: are the sampling semantics statistically correct (48/48 seeded checks passed after fixing proportional sampling), where does tensor-network batching actually win (CUDA-Q faster at small scale; 6.875x TN speedup on the exact 50-qubit/200-gate workload), and can a frozen calibration-informed model predict real IBM Kingston hardware better than the ideal noiseless model (yes — lower TVD at all four tested depths, preregistered). The central finding is a regime split: tensor networks don't always win, and this repo measures exactly where they do.
proofgate-pq
Evidence-bound post-quantum authorization: freeze intent, independently verify it, execute once, and sign the provenance. ProofGate-PQ separates requesting an action from authorizing its execution — a signed request expresses intent but grants nothing; independent verifiers evaluate the frozen action under a pinned policy with ML-DSA signatures; a protected executor atomically spends the permit against replay, runs the exact approved workload, and signs the provenance record. Fail-closed: only ALLOW authorizes execution. The reference application is quantum computation — changing a circuit, shot count, seed, or backend after authorization invalidates it. MIT-licensed prototype; not production-ready, not FIPS-validated.
muon-tomography-lab
GPU-accelerated experiments in cosmic-ray muon scattering tomography, built around a deceptively hard question: can a detector find high-Z material inside heterogeneous cargo without already knowing where to look? A fast physics/reconstruction spike evolved into a falsification-driven study of Point of Closest Approach tomography — and the most important result is a boundary: the local scattering signal is strong, but blind spatial search with PoCA throws much of it away. At 250,000 accepted tracks, a ground-truth oracle reaches AUC ~0.97 while the best calibrated blind scene-level search reaches only ~0.72. Attractive intermediate results disappeared as the experiment got harder and more realistic; that was useful.
decisiongate
Falsification-first adjudication for LLM-assisted decisions. DecisionGate is a small, inspectable Python engine and CLI that keeps evidence separate from the interpretations built on top of it — multiple LLMs can agree on a convincing conclusion while sharing the same unsupported assumption, and agreement is not independent evidence. Every claim is tagged EXPLICIT, INFERENCE, ASSUMPTION, CONTRADICTED, or UNKNOWN, retaining source, location, and confidence; model output can never create source evidence. The engine finds the predicates a decision needs and asks what evidence would distinguish competing interpretations. The final gate is deterministic: GO, NO_GO, or HUMAN_VERIFY.
incident-triage-agent
A working incident-triage agent that makes the Skills / MCP / RAG / Memory distinction concrete instead of conceptual: every token entering model context is attributed to exactly one mechanism and accounted for. The scenario is an on-call engineer's first ten minutes on a checkout-500 outage — the checklist is a Skill, querying dashboards is MCP, the team wiki is RAG, last outage's lesson is Memory — built as one small agent that uses all four and keeps them strictly separate. Runs offline and deterministically by default: no API key, no model download, no network. If you can't say which mechanism paid for a token, the decomposition is decorative.
qldpc-decoder-bench
Independent replication of MegaQuOp-scale qLDPC decoding throughput (arXiv:2608.25027) on a single RTX 5090, using bivariate bicycle codes and NVIDIA's nv-qldpc-decoder. Measured per-block batch throughput projects to a 408-logical-qubit / 9,792-physical-qubit serial aggregate inside 1 ms and 5 ms syndrome-cycle budgets — the paper's broader scalability observation is corroborated, with syndrome consistency verified (H·c = s over GF(2), 128/128 on every measured code). The key caveat is stated plainly: the paper's 1–5 ms budget comes from trapped-ion cycle times, and the assumption changes the interpretation. Exploratory measurement, not preregistered — decode cost only.
ai-rad
An evidence-driven development assurance framework for AI-assisted software: the code may be vibe-coded, the release is not. AI-RAD starts from the premise that vibe coding isn't the problem — the failure mode is when generation, validation, and release authority collapse into one loop and produce AI slop that looks complete without a durable chain from intent to evidence. The framework restores the chain: intent, rapid prototype, discoveries, requirements, frozen specification, implementation, tests plus evidence, source/environment/evaluator binding, release adjudication. Generation authority and release authority stay separate; nothing ships without adjudication.
ising-bench
Learned-vs-memoryless comparative benchmarking for quantum error structure, built around NVIDIA's open Ising quantum-AI models and an existing measurement archive. Thesis under test: quantum errors are non-Markovian — spatially correlated, environmentally mediated — contradicting the independent/memoryless assumption of standard quantum error correction. The goal is to detect and quantify that correlation in real data and benchmark learned decoders (which can exploit correlation) against memoryless baselines (which cannot). Runs on a modest RTX A1000 6 GB laptop GPU via CUDA-Q — decoder training and real-data analysis, not giant simulated code patches.
tnbench
Provenance-first independent adjudication of quantum/classical benchmark claims. tnbench checks the classical side of public quantum-advantage submissions: it reconstructed the published Sparse Pauli Propagation instance behind a Quantum Advantage Tracker Floquet-Ising benchmark and found the classical comparator (0.183429) was reported at a single truncation setting with no convergence sweep. That doesn't prove the number wrong — it proves the specific test needed to show it's stable hasn't been reported, and the method is visibly settings-sensitive elsewhere in the published data. It also ruled out the cheap shortcut: a 16–20 qubit exact simulation can't substitute for the 51-qubit calculation.
argus
An evidence-backed nginx streaming-path auditor for AI and long-lived HTTP workloads. AI responses stream over seconds or minutes and pass through nginx settings designed for short request-response traffic — buffering can silently batch generated tokens, upstreams can override buffering with X-Accel-Buffering, and proxy_read_timeout measures idle time, not total duration. Argus takes an nginx config plus request identity and answers which server/location block wins, which inherited directives actually apply, and whether the configured idle timeout fits the workload's silence. Local and read-only; every answer preserves its evidence scope rather than claiming a universal production guarantee.
wsl-agent-bridge
Reach WSL (Conda envs, Linux toolchain) from a Windows-hosted AI coding agent via wsl.exe interop: the pattern, a prompt template, and a safe read-only probe. The core trick is one line — wsl.exe shelling into the target distro — and the closest mental model is non-interactive SSH with local transport. This variant leads with a TL;DR and documents the reliability layer for agents that can't be told 'work in WSL' directly. Same standard Microsoft-documented interop as its amitb-gpu twin: agent-agnostic, no exploit, just the details that make it actually work.
roboapi
The unified API layer for robotics: connect any robot, any brand, with one SDK — Stripe, but for robots. Every manufacturer ships a different SDK, protocol, and data format; RoboAPI abstracts them into one clean developer experience — connect to any robot, then use universal move commands and normalized telemetry regardless of hardware. Built on FastAPI with ROS2 Jazzy support, simulated and real-hardware backends, and 14 passing tests. The multi-billion-dollar tax on the robotics industry is every team rewriting the same integration layer from scratch.
helium-vqe-assurance
An open, reproducible reference implementation of a preflight → execute → postflight assurance pipeline for VQE results, demonstrated on the helium atom and targeting IBM Kingston. The contribution is the method, not the physics: a hash-bound, pre-registered invariant contract yielding an auditable ACCEPT / FLAG / ABSTAIN verdict on every VQE run. Helium is the two-electron problem in a finite basis under the Born-Oppenheimer approximation — no three-body problem solved, no quantum-advantage claim. Ships with a noiseless/toy-noise/low-shot demo pipeline plus a device-calibrated Kingston twin built from a real calibration snapshot.
quantum-error-structure-bench
Reproducible benchmarks for structured quantum-error behavior, idle survival, and observable preservation across IBM quantum hardware and simulation. Contains controlled Z-basis idle experiments on IBM Heron-class systems, pairwise mutual-information and permutation-null analysis, and survival and structured Y/Z probe experiments — with raw artifacts, processed results, and figures committed. The interpretation boundaries are explicit: the strongest controlled idle result is narrow (no qubit pair showed residual bit-flip mutual information surviving a 99% family-wise permutation test), and it doesn't establish that hardware errors are universally correlated. An experimental research repo, not a production QEC implementation.
agent-env-ledger
Local environment memory for frontier coding agents. Every serious project lives in its own Conda env, venv, or Docker image — good engineering — but coding agents start each session with amnesia about which env belongs to which repo, which test command is authoritative, which failures already happened, and which files are protected. Agent Env Ledger creates a compact, local, agent-readable ledger per project and environment recording exactly that. It doesn't merge your envs, doesn't send files anywhere, doesn't store secrets, and isn't another agent framework. Just the workspace memory agents need before they act.
quantum-echoes-ibm-torino
Independent verification of Google's Quantum Echoes on IBM Torino — hypothesis strongly supported. The shallow circuit measured 58.3% echo fidelity, a 12x signal over the experiment's own 4.9% random baseline, significant at p < 0.0001, using hardware-aware circuits placed along Torino's native coupling chain to avoid SWAP overhead. The perfect-echo control (forward evolution plus exact inverse) hit 98.6%, confirming high two-qubit gate fidelity on the chosen qubits. Small-scale by design (4 qubits, depth 2–4, 4,096 shots, 2.3 hours): it reproduces the echoes physics on independent hardware, not a formal quantum-advantage claim.
ai-native-systems-design
An AI-native systems design portfolio for two complete GUI-driven platforms: Cyber-Circuit (AI/quantum security operations) and HexaGrid (AI-native infrastructure and energy optimization). The design principle: advanced AI systems are only useful when humans can understand what they're doing, why, and when to intervene. These aren't static mockups — they're working product interfaces built around real operational workflows, focused on making complex systems legible, governable, and auditable. Case studies cover threat-telemetry reasoning, security workflow command layers, and energy-aware scheduling control planes.
entangl
A post-quantum secure communication protocol for AI agents. Every agent-to-agent message is encrypted with ML-KEM-1024 and signed with ML-DSA-87 — NIST-standardized in 2024 as FIPS 203 and FIPS 204 (derived from CRYSTALS-Kyber and CRYSTALS-Dilithium) — because harvest-now-decrypt-later adversaries are already recording traffic that Shor's algorithm will eventually open. The stack layers ML-DSA identity, ML-KEM forward-secret encryption, AES-256-GCM with BLAKE2b-HKDF symmetric crypto, an optional BB84 QKD layer (Cirq), and WebSocket/gRPC transport. Purpose-built for the agentic web: agents buying ads, booking travel, and moving money on behalf of humans, with RSA/ECC-dependent key exchange and signatures replaced by NIST-standardized post-quantum alternatives designed to resist attacks from both classical and known quantum algorithms.
pytran-platform
A hybrid Python–Fortran language for quantum computing and HPC. PyTran unifies Python expressiveness with Fortran-class numerical performance: hybrid kernels written in Python syntax execute Fortran-optimized, with quantum-ready abstractions (circuits, qubits, operators, states), AI-assisted decorators, optional GPU acceleration via CuPy, and a modular transpiler/codegen architecture. Ships as a works-on-first-run bootstrap installer for Debian/Ubuntu/RHEL that creates its own isolated environment — no system Python required. Research-grade, designed for quantum simulation, HPC, and AI-assisted scientific computing.
cyber-circuit-browser
A quantum-enhanced, AI-powered, ML-adaptive browser from Quantum Clarity LLC — first public release v1.0.0. Public details are thin: the repo positions it as an AI-native browsing surface with machine-learning-adaptive behavior, but the README doesn't document architecture or features yet. Treat as early-stage; check the repo's release notes as it develops.