Hi, my name is Avery Clapp

I am a recent gradaute of Johns Hopkins University where I studied Computer Science and Economics. I enjoy grappling with hard topics across a wide range of disciplines, from computer science and software to philosophy, math, and physics. I explore these ideas on my blog.

In my engineering work, I love delving into the fundamentals of how systems work at the lowest level. I am broadly interested in high-performance computing and ML systems as I find the rigor and complexity of these fields to be intellectually rewarding.

Experience

• Research Engineer

  Rabdos AI · June 2026 - Present

  Mapping the frontier of scientific reasoning.

• Research Assisant

  University of Pennsylvania · June 2026 - September 2026

  Neurosymbolic AI & Accelerators.

• ML Research Assistant

  Johns Hopkins University · September 2024 - May 2026

  Developing GPU-accelerated algorithms for large language model training, creating novel CUDA implementations for masked matrix operations that achieve significant performance improvements in computational efficiency and memory optimization for billion-parameter models. While working on this, I was awarded the Pistritto Fellowship, an annual grant given to ambitious student-researchers within the Computer Science department at Johns Hopkins.

• Software Engineer Intern

  Garda Capital Partners · May 2025 - August 2025

  Led full-stack overhaul of firm's core data platform serving all trading desks, while developing cross-team risk analytics solutions including automated VaR calculations, yield analysis tools for investor relations, daily market reports for the repo desk, and modernizing infrastructure through async migrations and CI/CD implementations.

• Software Engineer Intern

  NaviStone Inc · May 2024 - August 2024

  Built client-facing analytics dashboard and optimized middleware architecture, focusing on performance enhancements and scalable data processing to support high-volume user interactions and business intelligence workflows.

• Quantitative Developer

  Institute For Applied Economics · May 2023 - January 2024

  Designed and deployed algorithmic trading platform combining quantitative research with NLP-based sentiment analysis for gold markets, scaling from initial research algorithms to commercial system serving hundreds of subscribers with real-time signal delivery and performance tracking.

Projects

• Separatrix

  C++ & Python

  Structural testing framework for C/C++ codebases that localizes faults by scoring how much small input perturbations make control flow diverge, rather than by counting coverage. An LLVM instrumentation pass compiles targets to a behavioral graph (nodes are functions and basic blocks, edges carry branch conditions and source locations) and injects a runtime that records per-edge traversal counts into bucketed multisets. A chaos engine generates perturbations and a divergence detector diffs each node's outgoing-edge profile against baseline to produce a sensitivity map. The core mechanism is divergence localization: crediting every node whose profile diverges across the full corpus, not just the first bifurcation point, which collapses to near-chance on staged bugs. Validated on Magma fault benchmarks across three targets forming an alignment continuum: lua, where SBFL is inapplicable because debug-subsystem bugs don't surface in observable output, achieves region-level AUC 0.97 vs coverage 0.89 on a bug-blind corpus; sqlite3 shows divergence still beating coverage (0.61 vs 0.47) under weak corpus-fault coupling; md4c is the misaligned pole where input variation concentrates on a bug-irrelevant hot loop, matching SBFL rank at top 2% but not beating it.

  View Project →

• Agentc

  Rust & Python

  JIT optimization runtime that intercepts LLM API calls in multi-step agent pipelines and reduces token spend without touching application code. Ships three components: a profiler that monkey-patches provider clients at import time, capturing every inference call (full prompt/response, token counts, latency, model, cost) into a structured SQLite trace with OTel gen_ai.* semantic conventions and five waste detectors that surface dollar-denominated savings estimates; a semantic memoization layer using exact-hash lookup on the hot path and LSH over 256-dimensional embeddings as a secondary tier for semantically-similar prompts; and a JIT optimizer that applies cost-ranked rewrite rules (ContextCompress, ParallelBranch, ModelDowngrade, StateDrop) only after accumulating enough observations on hot call sites, with shadow-mode sampling at 2% providing ground-truth divergence to enforce per-rule accuracy budgets. Cold calls pass through unchanged; optimization engages only when the empirical cost model has real data to rank proposals. Rust core with PyO3 bindings handles trace ingestion and embedding capture; the profiler's redundant-call detector guides promotion of high-repetition sites into the memoization layer.

  View Project →

• tbjit-alloc

  C++ & Python

  A JIT specializing memory allocator that interposes on malloc/free via LD_PRELOAD and compiles per-call-site allocation routines at runtime. Each call site is identified by a hashed return address; a runtime profiler accumulates per-site histograms of request sizes and object lifetimes into sparse fixed-capacity tables, and once a site crosses a heat threshold the JIT emits a specialized fast path tuned to its observed behavior, picking among strategies like bump allocation and thread-local free lists. Memory is carved from 2 MiB segments backed by transparent hugepages, with a pagemap holding one bit per region to make free-path is_managed checks O(1) instead of a segment scan. A lifetime classifier tags sites Reap/Hold/Unknown to drive segment reclamation and a conditional-hugepage policy, while shadow-mode sampling continuously validates JIT'd paths against the generic allocator and deoptimizes on any divergence. Under realistic LD_PRELOAD deployment the interposition trampoline dominates and per-call latency lands at parity with glibc; the lifetime-aware THP policy cuts allocator RSS by up to 74% (41% end-to-end) on allocation-bound workloads where partially-filled segments would otherwise fault whole hugepages.

  View Project →

• Cache Explorer

  C++

  A full-stack cache profiling tool built on a custom LLVM instrumentation pass. Compiles C, C++, Rust, and Zig with injected memory tracing, runs the trace through a multi-core cache simulator with MESI coherence, TLB simulation, 3C miss classification, and prefetch modeling, and streams results to a Monaco-based web UI in real time. Hardware presets include Apple M-series, Intel Core, AMD Zen, and custom configurable hierarchies. Detects false sharing, supports selective instrumentation for large codebases, and sandboxes untrusted code via Docker.

  View Project →

Open Source ContributionsI'm always looking to work on cool projects so if you have any recommendations or advice, let me know!

• ozy

  A Rust-based CLI tool developed by Aquatic that manages application versions across development teams by centralizing configuration and automatically installing consistent versions of tools like Vault, Nomad, etc. Contributed uninstall functionality, implementing the 'rm' command with symlink removal and optional cache cleanup flag.

  View Project →View PRs →