Akash Gogate

Exploring the space where systems think and biology inspires.

From satellite observation scheduling at Leidos to LLM pipelines for cancer biology.

CS + Biology at UW-Madison | Computing for biology's next frontier.

github.com/AkashGogate ↗

Hi, I'm Akash.

I'm a CS + Biology student at UW-Madison, graduating in May 2028. Right now I'm building LLM agent pipelines for spatial transcriptomics research at the Kendziorski Lab, and my industry experience has been in backend infrastructure and distributed systems at Leidos.

I grew up in Princeton, NJ, where I spent a lot of time on tennis courts (still do). I've coached players and run tournaments. The stringing business came out of that too. That's where I learned that most interesting problems look messier up close than from a distance, and that knowing the fundamentals is what lets you improvise when things go sideways.

I like getting into the technical details when they actually matter, not just to look impressive. Some problems don't have a shortcut. You actually have to understand what's going on to solve them.

The goal is to build things that need both solid engineering and good design to work, not just one or the other. That's where the most interesting problems are, and where I want to spend my career.

3.8 GPA · Dean's List · CS + Biology, UW-Madison · Graduating May 2028 · Open to Summer 2027 internships & co-ops

Where I've worked

Leidos

Software Engineer Intern

May 2025 - Present

Leidos' satellite fleet needed to schedule competing observation requests against a shared set of ground assets, a classic multi-objective optimization problem. I applied dynamic programming and memoization in Python to prototype a scheduling engine, then rewrote the entire engine in Rust once the approach proved out, since the team's production microservice ecosystem demanded stricter reliability and lower latency than a Python service could guarantee at scale.

To keep scheduling decoupled from the rest of the satellite operations stack, I designed an event-driven data pipeline on Kafka with at-least-once delivery semantics, persisting results to MongoDB. That decoupling meant any one service could fail or redeploy without taking down the mission-critical scheduling path around it.

I containerized the team's test suite with Docker and ran it on Kubernetes, wiring the whole thing into GitHub Actions CI/CD. Writing pytest coverage across boundary conditions and deliberate fault injection meant regressions got caught in CI before they ever reached production.

Separately, I built a Claude Code MCP plugin from scratch on top of an institutional knowledge graph mapping the team's ontologies and service dependencies. It now serves roughly 30 engineers across a multi-team defense program, giving them a shared, queryable map of how services relate instead of relying on tribal knowledge.

I also built a solo Android ATAK (tactical mapping) plugin from scratch over four weeks, adding voice-activated situational awareness for field operations. Speech recognition had to run fully offline, on-device, for security, so I integrated a local whisper.cpp model into a command pipeline that classifies spoken reports against two structured formats, a UXO (unexploded ordnance) report and a 9-line MEDEVAC request, then extracts location and threat details from natural speech and plots the result on live tactical maps in about 10 seconds end to end. It hit 100% accuracy on marker-type classification and about 5% average word error rate across both schemas.

I also contributed to the team's distributed media pipeline, a multi-service system spanning MongoDB, S3, a CDN layer, and Kafka for tactical communication media. I owned data ingestion and storage: writing the Kafka consumer that processed incoming topic data, optimizing MongoDB schemas for cleaner data structuring, and building the S3 upload and delete handlers.

Separately, I built a natural-language query tool for aircraft fleet readiness, a React frontend on top of DuckDB for fast analytical SQL and Redis for sub-second caching, so operators could ask plain-English questions about fleet status and get an answer without knowing the underlying schema.

I also extended the team's REST API for querying stored tactical event data, adding five new filter dimensions (unit ID, callsign, event type, time window, and geographic area) while keeping full backward compatibility with the existing endpoints. I documented it in OpenAPI/Swagger and got the new code path to over 90% test coverage.

PythonKafkaKubernetesDockerMongoDBDynamic ProgrammingGitHub ActionsCI/CDRustNeo4jWhisperATAKREST APIDuckDBRedisAWS S3

See more in the Skills section ↗

The Kendziorski Lab, UW-Madison

Student Research Intern

September 2025 - Present

The lab's spatial transcriptomics work spans single-cell RNA sequencing (scRNA-seq), next-generation sequencing (NGS), and spatial transcriptomics data, each of which suits different model architectures. I built an end-to-end ML pipeline in PyTorch and TensorFlow with an agentic layer that automatically selects and evaluates the right model (scVI, scANVI, scGen, or AmortizedLDA) for a given dataset, with every run tracked in Weights & Biases. Tuning that pipeline for scale cut GPU runtime from 80 minutes down to 27 on identical hardware, a roughly 300% reduction that matters when the lab is iterating across dozens of datasets.

Keeping up with clinical genomics literature was its own bottleneck, so I built TransferAgent to automate NLP-based literature synthesis and cross-paper validity scoring across roughly 500 clinical genomics papers. It cut review time by about 60%, and I worked directly with clinicians in the lab to make sure the synthesis reflected clinical relevance, not just statistical significance.

That pipeline work is now feeding into an ongoing clinical genomics publication targeting a peer-reviewed computational biology journal, where I've been validating model performance and pipeline reproducibility for glioblastoma gene therapy research across a 10-person interdisciplinary lab.

PythonRLLM APIsScanpySeuratCARDscRNA-seqscVIscANVIWeights & BiasesGitHub Actions

See more in the Skills section ↗

Inspirit AI

Machine Learning Research Intern

Sep 2022 - Mar 2023

I built a skin cancer detection pipeline using OpenCV for image preprocessing and scikit-learn (with NumPy/Pandas handling the data wrangling) that reached 95% classification accuracy across roughly 70,000 dermoscopic images. That work became my first published paper, 'Early Skin Cancer Detection Improvement,' through Inspirit AI.

In parallel, I trained and validated a Random Forest classifier on miRNA sequences for cancer cell likelihood prediction, reaching 95% predictive accuracy at p < 0.05, validated with stratified k-fold cross-validation to make sure the result generalized rather than overfitting to one split of the data.

Pythonscikit-learnOpenCVDecision TreeKNNML Research

See more in the Skills section ↗

Princeton Racket Club

Tennis Coach & Tournament Director

May 2024 - Aug 2024

I held a dual role as tournament director and head coach at Princeton Racket Club: directing 8 regional tournaments end to end (380+ match entries, every one starting on time) while also coaching 3 classes of 8-10 athletes spanning ages 8 to 65.

On the coaching side, I built data-driven, skill-adapted regimens for individual athletes rather than running one generic program for everyone. That approach guided 3 junior athletes to over 150 regional ranking points combined and helped 5 adult players climb a full 0.5 NTRP competitive level.

LeadershipCommunicationEvent Management

See more in the Skills section ↗

Tennis Racket Stringing Services

Founder

Jan 2019 - Present

I founded an independent racket stringing business from scratch and scaled it to 45+ regular clients, servicing 12-20 rackets a month across two service tiers: a standard 3-4 day turnaround and a premium 2-day option for players who needed their racket back fast.

Growing the client base meant leaning on grassroots channels rather than paid marketing: word-of-mouth referrals, flyers at local parks, referral discounts through high school tennis teams, and an Instagram page showcasing the stringing craftsmanship itself.

EntrepreneurshipOperationsClient RelationsInventory Management

See more in the Skills section ↗

Recognition & Awards

TEL: Spatial Intelligence Ideathon
2nd Place, 2-Person TeamJul 2026

TEL: Spatial Intelligence Ideathon

UW-Madison

Placed 2nd at a competitive UW-Madison ideathon, pitching a dual-product airport accessibility platform combining ZaiNAr sub-meter indoor positioning with SGA AR spatial computing.

Designed a B2B tool giving airline staff real-time sub-meter wheelchair-passenger tracking between gates, paired with a B2C app letting family track accessible relatives through the terminal.

Want to know more about these? See the Skills section ↗

Things I've built

Lotus Health

Financial risk engine over a 1,080-node ICD-10 comorbidity graph, querying 45 million insurance records to compute 5-year disease cost paths.

Python / SQL / RAG / ICD-10Click to explore ↗GitHub ↗

LLM Agent Pipeline — Spatial Transcriptomics

End-to-end ML pipeline for scRNA-seq, NGS, and spatial transcriptomics. Agentic framework selects and evaluates models across scVI/scANVI/scGen/AmortizedLDA; cut GPU computation 300%.

Python / PyTorch / LLM APIs / ScanpyClick to explore ↗Research project — no public repo

SAT Practice Test Generator

GPT-4o tutor that finds your weak SAT domains and generates exam-matched practice questions on demand.

TypeScript / React.js / Node.js / FastAPIClick to explore ↗GitHub ↗

Computer Vision Hand Tracking System

Real-time hand gesture and joint angle tracking pipeline using OpenCV and MediaPipe. Outputs biomechanical data for clinical motion capture, rehabilitation, and sports performance analysis.

Python / OpenCV / MediaPipe / Computer VisionClick to explore ↗GitHub ↗

Ecological Conservation Game

10,000-agent C++ simulation with spatial hashing and GPU-instanced rendering, sustaining 60+ FPS as bots evolve across generations.

C++ / Raylib / Game AI / Multi-AgentClick to explore ↗GitHub ↗

USTA Tournament Explorer

Android app for discovering USTA tennis tournaments with an interactive map, radius filtering, and NTRP skill-level matching.

Android SDK / Java / GraphQL / MobileClick to explore ↗GitHub ↗

microRNA Cancer Detection (miRcore)

Random forest classifier on microRNA expression profiles to predict cancer biomarkers. 95% accuracy (p < 0.05).

R / Bioconductor / Random Forest / microRNAClick to explore ↗Research project — no public repo

Always learning.

Here's where I am right now. Picked up most of these through working on real projects, and the list keeps growing.

PythonPrimary language across every project. Built LLM pipelines at Kendziorski, event-driven systems at Leidos, ML classifiers at Inspirit AI, and the Lotus Health financial risk engine.
TypeScriptUsed for the SAT Generator frontend and this portfolio site. Prefer TypeScript over plain JavaScript for any project where type safety prevents runtime errors.
RStatistical computing for bioinformatics. Ran microRNA expression analysis for the miRcore cancer detection model and cell-type clustering at Kendziorski.
DockerBuilt and maintained containerized environments at Leidos. Used daily for reproducible builds and test suite management across a Kubernetes cluster.
GitHub ActionsCI/CD automation at Leidos (test suite deployment) and Kendziorski (reproducible pipeline deployment). Manages the full benchmark pipeline for the Self-Improving LLM Agent.
REST APIsDesigned and consumed REST endpoints across multiple projects. Used FastAPI for the SAT Generator backend and HttpURLConnection in the Android app.
Machine LearningCore discipline across Inspirit AI, miRcore, and the Kendziorski pipeline. Ranges from classical classifiers to LLM-driven agentic research systems.
PyTorchDeep learning framework for the scVI/scANVI model work at Kendziorski and the Transformer-based reasoning in the Self-Improving LLM Agent.
LLM APIsGPT-4o for the SAT Generator and OpenAI/Claude/Groq APIs for the LLM agent pipelines at Kendziorski and in Lotus Health.
NumPyArray computing backbone for bioinformatics work at Kendziorski. Used in matrix operations and data transformation pipelines for single-cell data.
PandasData manipulation across the Kendziorski pipeline. Cleans, filters, and reshapes genomics dataframes before analysis.
Scikit-learnBuilt a skin cancer detection classifier at Inspirit AI reaching 95% accuracy using Decision Tree and KNN on dermoscopic image features.
Decision TreesClassical classifier used in the Inspirit AI skin cancer detection pipeline. Implemented with scikit-learn on dermoscopic image features, cross-validated for generalization.
Cross-ValidationApplied stratified k-fold cross-validation at Inspirit AI (95% skin cancer accuracy) and miRcore (95% microRNA accuracy) to validate model generalization.
RAGRetrieval-augmented generation as the retrieval layer in both the Self-Improving LLM Agent (task context retrieval) and Lotus Health (ICD-10 symptom-to-node mapping).
LLM AgentsOrchestrated multi-step agentic systems at Kendziorski (model selection pipeline) and in the Self-Improving Agent (failure-driven self-improvement loop).
ScanpyPython library for single-cell analysis. Handles preprocessing, clustering, and differential expression in the Kendziorski LLM agent pipeline.
SeuratR toolkit for single-cell RNA-seq. Used at Kendziorski for cell clustering, normalization, and expression visualization across spatial transcriptomics data.
GitHubVersion control and code collaboration across every project. Comfortable with branching, pull requests, code review, and CI/CD workflows.
LeadershipDirected 8 regional tennis tournaments and coached 3 athlete classes ages 8-65 as Tournament Director at Princeton Racket Club, holding dual director and head coach responsibilities.
CommunicationPitched a dual-product airport accessibility platform to judges at the TEL Spatial Intelligence Ideathon, placing 2nd, and translated coaching feedback into skill-adapted regimens for athletes ranging from juniors to adults.
EntrepreneurshipFounded and scaled an independent tennis racket stringing business to 45+ clients, building the service tiers and marketing from the ground up.

University of Wisconsin–Madison

B.S. Computer Science & Biology · August 2024 — May 2028

Computer Science Capstone

Senior course surveying industry frameworks across game design, computer vision, machine learning, and web development. Included panels with working engineers, university professors, and college students.

Android Application Development

Built native Android apps covering UI design patterns, activity lifecycle, data persistence, and REST API integration with real-world services.

Virtual Reality

Explored VR development fundamentals including 3D scene construction, spatial interaction design, and headset SDK integration for immersive experiences.

Game Development

Designed and shipped interactive games covering game loops, physics systems, entity management, collision detection, and AI agent behavior.

Web Development

Full-stack fundamentals: HTML, CSS, JavaScript, and introductory frameworks for building interactive, data-driven web applications.

Big Data Systems

Deploying distributed systems to store and analyze large datasets. Covers unstructured and structured storage, streaming data pipelines, and training ML models, primarily in Python.

Bioinformatics

Sequence alignment, RNA-seq analysis, genomics pipelines, and biological databases.

Computational Biology

Mathematical modeling of biological systems, network analysis, and data-driven approaches to biology.

Genetics

Heredity, gene expression, mutation, and population genetics.

Cell Biology

Cellular structure, organelle function, signaling pathways, and the cell cycle.

Statistics for the Life Sciences

Probability, hypothesis testing, regression, and sampling distributions, with the underlying mathematics taught alongside biological applications.

Data Structures

Core structures: linked lists, trees, graphs, hash maps, heaps, and their algorithmic complexity.

Advanced Algorithms

Algorithm design and complexity analysis: dynamic programming, greedy methods, divide-and-conquer, graph traversal, and NP-hardness.

Deep Learning

Neural network architectures, backpropagation, CNNs, RNNs, Transformers, and training at scale with PyTorch.

Machine Learning

Supervised and unsupervised learning, model evaluation, neural networks, and ensemble methods.

Artificial Intelligence

Search, constraint satisfaction, Bayesian reasoning, and foundations of intelligent agent design.

Linear Algebra

Vectors, matrices, transformations, eigensystems, and their applications to data analysis.

Machine Organization and Programming

How processors execute instructions: memory hierarchy, caching, pipelining, assembly, and system-level memory management.

Intro to Computer Engineering

Digital logic, circuits, memory systems, and the hardware-software boundary underlying modern computing.

Operating Systems

Processes, threads, memory management, file systems, and concurrency primitives.

Database Management Systems

Relational model, SQL, indexing, transaction handling, and an introduction to NoSQL systems.

Cryptography

Symmetric and asymmetric encryption, hash functions, digital signatures, and protocol security proofs.

Differential Equations

Ordinary differential equations, modeling dynamic systems, and numerical solution methods.

Discrete Mathematics

Logic, proof techniques, combinatorics, graph theory, and set theory.

Programming I

Java fundamentals: control flow, methods, arrays, objects, and the basics of object-oriented design.

Programming II

Object-oriented design in Java: inheritance, polymorphism, interfaces, recursion, and unit testing.

Programming III

Advanced data structures and algorithm analysis in Java: trees, graphs, hash tables, and software design at scale.

Get in touch

Open to Summer 2027 internships and co-ops in software engineering, AI/ML, data science, biotech, and computational biology research. Available May 15 – Sep 1. Email is the best way to reach me.

Akash Gogate — 2026Built with Next.js · Tailwind CSS