Kushagra Bharti

Student | Software Engineer | ML Enthusiast.

I am a student and software builder who enjoys learning and expanding my skillset.

Primary Sources

[Canonical portfolio homepage](https://www.kushagrabharti.com): Public visual portfolio homepage.
[AI-readable HTML profile](https://www.kushagrabharti.com/ai): Full semantic profile with experience, projects, education, writings, creative work, and crawler notes.
[Plain-text llms.txt](https://www.kushagrabharti.com/llms.txt): This generated Markdown guide for automated readers.

Key facts:

I am a student and software engineer, but I do not fit cleanly into one lane. I move between machine learning, AI agents, full-stack products, research tooling, data systems, computer vision, optimization, trading experiments, and the occasional hardware or film project.
A lot of my work starts with a question I cannot leave alone. Can LLM agents actually plan over a full game? Can pose tracking be cleaned up enough for real lab workflows? Can a product keep artifacts and context instead of turning everything into another chat thread?
I like building the whole loop: the core engine, the UI, the data model, the tests, the telemetry, the failure cases, and the writeup. I do not enjoy stopping at a demo if the interesting part is still hidden.
MonopolyBench is my main AI research bet right now: a deterministic multi-agent environment for studying long-horizon planning, negotiation, deception, and bias through full Monopoly games.
At UT Southwestern, I have been working on computer vision for behavioral neuroscience: DeepLabCut/SuperAnimal pipelines, pose cleanup, behavior scoring, QC outputs, and CSV/XLSX scorecards researchers can actually inspect.
I have worked in real company environments too. At Abilitie, I contributed to an LLM role-play training product with React, TypeScript, provider plumbing, telemetry, prompt work, open-source model fine-tuning, latency improvements, and cost reduction. At Glydr.gg, I have been leading technical and product direction for a customer-facing configuration hub with React/Vite, Fastify, Postgres, Steam auth, admin tooling, and Railway deployment.
I have also built products and systems outside research: Pact, Beyond Chat, NovelBench, PseudoLawyer, Arachne, a personal portfolio/tracker, quant trading tooling, and smaller ML, hardware, and algorithm projects.
I care about legibility. If a model makes a decision, I want traces. If a benchmark gives a score, I want the run artifacts. If a pipeline produces a number, I want to know where it came from and where it can fail.
I care about taste too. The interface matters. The data model matters. The story matters. A thing can pass tests and still feel wrong.
Film is part of the same instinct for me. Framing, pacing, selection, and restraint show up in software more than people admit.
I am looking for work where I can learn quickly, own hard problems, build real systems, and stay honest about what is broken.

Contact and External Profiles

Email: mailto:kbharti.work@gmail.com
LinkedIn: https://www.linkedin.com/in/kushagra-bharti/
GitHub: https://github.com/kushagrabharti
Medium: https://medium.com/@kushagrabharti
X: https://x.com/IamKushagraB
Film Portfolio: https://drive.google.com/file/d/1m3aFLAK4TE29ybbdOzObLS8zrrX3oJwM/view?usp=sharing

Values and Writings and Predictions

01 perpetual learning

Category: value

Summary: Remaining deliberately unfinished before competence becomes a room with no other door.

Perpetual Learning

I distrust the moment when a thing becomes easy.

At first, knowledge is a door. I enter carefully, touching the walls, aware of how much I cannot see. Then familiarity arrives. The room acquires my shape. One day I find myself seated inside it, giving directions, unable to remember when I stopped looking for another door.

That is what frightens me about competence. It can resemble growth long after growth has ended. A practiced answer survives because nobody, least of all me, thinks to question it. Skill hardens into ritual. Success makes the ritual comfortable.

I want reality to keep interrupting me. I want to be corrected while I can still feel the correction, to meet subjects that make my intelligence awkward again. The mind should occasionally have to stand outside in bad weather.

So I keep a small discipline:

* Follow curiosity past usefulness.

* Test what I think I know against what refuses it.

* Begin again before the old self starts calling itself permanent.

Learning is how I remain unfinished on purpose.

02 kinetic agency

Category: belief

Summary: Ruining the perfection of the unattempted by putting work into contact with reality.

Kinetic Agency

There is a peculiar safety in preparing forever. Nothing attempted can fail.

I know this safety well. A plan can become so detailed that it begins impersonating the work. Its edges are clean; reality has not touched it. Meanwhile the unopened door remains perfectly capable of leading anywhere.

Agency begins when I spoil that perfection.

I build, ship, listen, revise. Not because motion is automatically virtuous, but because the world answers only what enters it. An unfinished thing in public teaches me more than a flawless thing held privately in the mind. Reality is an impatient editor. I trust its red ink.

AI makes intelligence abundant. It can cross the blank page, summon a scaffold, explain the unfamiliar, and compress days into minutes. But it cannot supply the final permission to act. Given infinite assistance, a person may still remain seated before the door.

I use it to make hesitation expensive. To shorten the distance between *I wonder* and *I tried*. To become more dangerous to the part of me that prefers potential over proof.

My rule is simple:

Move while uncertainty is still light enough to carry.

03 discernment

Category: thought

Summary: Selection as a creative act: what to keep, automate, complicate, and leave outside.

Discernment

Film taught me that meaning often enters through the side door.

Hold a face for two seconds too long and honesty becomes pleading. Cut early and the scene keeps its dignity. Move the frame a few inches and a harmless object in the background becomes evidence. Sometimes the missing line speaks with greater precision than the actor could.

Kuleshov's lesson stayed with me: nothing means alone. A shot inherits guilt or tenderness from its neighbor. Meaning lives in placement, duration, omission. The invisible decision governs the visible one.

Software, to my surprise, obeyed the same grammar.

Taste there is mistaken for decoration. I think it begins much earlier: in what gets named, what gets repeated, what the machine should anticipate, which mistake the system quietly makes impossible. The best decision may leave no artifact except the absence of irritation.

This matters more now that AI can produce almost anything on request. Generation has become cheap enough to disguise indecision as productivity. A hundred acceptable answers arrive before the question has learned what it wants.

So I return to the cut. **Keep this. Remove that. Let this remain difficult because difficulty belongs here. Make that effortless because it does not.**

Taste is not the abundance of good ideas. It is the nerve to leave most of them outside.

04 predictions

Category: prediction

Summary: Three notes on vanishing interfaces, affordable failure, and freedom in an over-helpful world.

Predictions

The future rarely arrives as an event. It enters as a convenience, then quietly rearranges the room.

The disappearance of the interface

For years we learned the habits of machines: which app to open, which field to complete, where the file had gone. We called this fluency. Mostly, it was obedience with good keyboard shortcuts.

Agents reverse the arrangement. We state an intention; the machinery crosses its own corridors. The app, dashboard, and file do not vanish, but they recede from view. The new interface is the work becoming done.

We will stop visiting software and begin summoning outcomes.

---

The amateur returns

Most ideas die without ever becoming wrong. Their owners lack a laboratory, an expert, a team, enough money, enough time. AI lowers the price of being corrected.

That will produce oceans of mediocrity. Good. Buried inside them will be strange attempts from people who were previously denied the right to attempt anything serious. The laboratory becomes less a place than a temporary condition around a curious person.

Ability spreads when failure becomes affordable.

---

Freedom becomes expensive

When intelligence is everywhere, it will compete for the same scarce territory: human attention. Every surface will offer assistance. Every silence will acquire a suggestion.

Luxury will mean remaining unreachable by systems designed to understand us. The most desirable products and places will not merely serve us. They will grant us intervals in which nothing is requested, measured, optimized, or predicted.

The future will automate nearly everything except the need to escape it.

Experience Links

Software Engineer Intern at Corgi

Date Range: Jul 2026 - Present

Category: Industry

Timeline Tone: active

Summary: Architected and shipped a full-stack commercial insurance brokerage platform, opened a new broker distribution channel that closed $60K in revenue within 10 days, and built supporting automation for broker communications and operations.

Highlights:

Built Corgi's commercial insurance brokerage platform end to end with React, TypeScript, and Django, covering broker onboarding and appointments, quoting, checkout, policy servicing, and commissions in one production workflow.
Owned the architecture across the broker-facing React application, Django APIs, transactional data model, asynchronous workers, service contracts, production infrastructure, and operational rollout, carrying the system from initial design through live broker usage.
Connected the new broker experience to Corgi's existing Startup Line system of record, preserving the established underwriting and quoting engine while giving brokers a purpose-built distribution and servicing layer.
Modeled the broker lifecycle around revisioned applications, quote selection, payment and checkout state, policy issuance and servicing, broker appointments, commission state, and auditable transitions between each stage.
Designed the integration around typed API contracts, idempotent operations, revision-aware state, and Celery reconciliation workers so retries are safe, independently deployed services can recover from partial failures, and policy state does not silently drift between systems.
Separated synchronous broker interactions from asynchronous quoting, document, notification, synchronization, and reconciliation work, keeping the product responsive while long-running insurance operations progress durably in the background.
Expanded Corgi's addressable market through the new broker channel and closed $60K in revenue within the platform's first 10 days in production.
Containerized the Django services and asynchronous workers with Docker and deployed them through Amazon ECR and AWS ECS, using independently scalable web and worker workloads, health-checked rollouts, autoscaling, and blue-green releases to keep quoting and checkout online during deployments.
Ran the production data path on AWS with PostgreSQL/Aurora for transactional state and Redis-backed Celery queues for durable background work, separating latency-sensitive broker requests from document, synchronization, reconciliation, and notification jobs.
Designed deployment and recovery around immutable container images, service health checks, traffic shifting, automatic rollback, queue isolation, and independent web and worker scaling so releases remain routine as broker volume grows.
Built a custom Claude agent runtime that continuously processes broker work across email, Slack, Telegram, and manual entry instead of requiring brokers to move every conversation into a separate AI interface.
Grounded the agent in company-wide knowledge through AWS-hosted vector retrieval and exposed quoting, policy, CRM, appointment, and follow-up operations as MCP tools, allowing it to move from answering questions to completing real workflows.
Designed automatic triggers for inbound and internal activity, memory across deals and conversations, tool-level execution controls, and human approval for external actions so brokers can approve, reject, or revise outbound work before it is sent.
The agent detects unanswered threads and aging opportunities, determines the next action, creates follow-ups, updates operational state, alerts the responsible broker, and queues outbound communication for review before a deal becomes stale.
Launched the agent with 5 brokers across 4 communication channels, saving approximately 25 hours per week, reducing stale conversations by roughly 40%, and protecting an estimated $100K in monthly premium pipeline.
Systems depth: maintains one trustworthy operational state across live insurance workflows, independently deployed services, asynchronous jobs, and agent-initiated actions while preserving human control over consequential external communication.

Tags: Full-Stack Product Engineering, Applied AI, AI Agents, Insurance Technology, React, TypeScript, Django, Python, Distributed Systems, Typed APIs, Idempotency, Celery, Redis, PostgreSQL, Docker, AWS ECS, Amazon ECR, AWS Aurora, Autoscaling, Blue-Green Deployments, Claude, RAG, Vector Search, MCP, Tool Calling, Human-in-the-Loop, Workflow Automation, Django REST Framework, AWS Fargate, AWS CodeDeploy, Aurora PostgreSQL, Event-Driven Architecture, Background Workers, Reconciliation, System of Record Integration, Revisioned State, Omnichannel AI, Email Automation, Slack Integration, Telegram Integration, Broker Operations, Commercial Insurance, AI Product Engineering, Applied-AI, Insurance-Technology, AI-Product-Engineering

Link: https://www.corgi.insure/

Undergraduate Researcher at UT Dallas, CAIR Lab

Date Range: Nov 2025 - Present

Category: Research

Timeline Tone: active

Summary: Built MonopolyBench, a long-horizon multi-agent evaluation environment for frontier LLMs that has captured 8,000+ decisions across 40M+ tokens through deterministic, schema-constrained, and fully replayable economic simulations.

Highlights:

MonopolyBench evaluates whether frontier models can sustain coherent agency across long-running economic interactions rather than solve another isolated prompt. Agents must plan, negotiate, allocate capital, manage risk and liquidity, recover from mistakes, and adapt to strategic opponents inside a persistent environment.
Built an authoritative Python engine as the sole state mutator and exposed every legal decision as a schema-constrained tool. Models can choose among valid actions, but cannot invent moves, rewrite state, or bypass the economic rules of the environment.
Designed a custom multi-agent harness that assembles public state, private memory, conversation history, and legal tools for each decision, validates the returned tool call, performs a corrective retry with concrete errors, and applies a deterministic fallback when a model still fails.
Made communication part of the evaluation surface through public negotiation and private reasoning channels, allowing cooperation, deception, persuasion, risk preference, and strategic consistency to be studied at the decision level.
Created 130 controlled frozen-state scenarios spanning trades, auctions, purchases, building, jail, liquidity pressure, and liquidation, alongside full-game campaigns that test how local competence compounds or collapses over a long horizon.
Generated more than 8,000 agent decisions across 40M+ model tokens, producing high-signal trajectory data for model comparison, behavioral verification, targeted data synthesis, failure analysis, and post-training research.
Recorded every prompt, raw response, tool call, validation error, retry, fallback, state transition, event, snapshot, communication, token count, and cost so a run can be audited as a causal trajectory instead of reduced to a final score.
Built deterministic replay that reconstructs state from the event stream and detects the exact transition where behavior diverges, making model failures distinguishable from harness, rules-engine, and artifact-integrity failures.
Designed controlled cohorts with fixed seeds, deterministic baselines, roster controls, and Latin-square seat rotation so model comparisons separate strategic behavior from turn order and environment variance.
Built batch evaluation and reporting surfaces that aggregate campaigns into model cards, category breakdowns, validity and recovery profiles, token and cost reports, and comparable behavioral slices across models and seeds.
Implemented a FastAPI and WebSocket observation layer with a render-only React interface, keeping the deterministic engine authoritative while researchers inspect games, decisions, messages, and state transitions live.
Tracked provider-reported token usage and generation costs at the decision and campaign levels, linking evaluation quality, behavioral reliability, and inference economics in the same research artifacts.
The active research uses those trajectories to study long-horizon planning, tool-use reliability, negotiation, capital allocation, recovery, and the conditions under which frontier agents fail despite appearing competent on short tasks.

Tags: LLM Evaluation, Multi-Agent Systems, Long-Horizon Agents, Agent Benchmarking, Tool Calling, Schema-Constrained Actions, Deterministic Simulation, Replayable Trajectories, Behavioral Evaluation, Post-Training Data, Failure Analysis, Economic Simulation, Negotiation, Planning, Risk Management, Event Sourcing, Python, FastAPI, WebSockets, React, TypeScript, OpenRouter, JSON Schema, Zod, Model Comparison, Controlled Scenarios, Latin-Square Evaluation, Experiment Telemetry, Cost Accounting, Research Data Generation, Data Synthesis, Agentic AI, Telemetry, Function Calling, Deception, Bias Evaluation, Vite, Pytest, Multi-Agent-LLM-Evaluation, Agent-Benchmarking, Tool-Calling-Agents, Deterministic-Simulation, Long-Horizon-Planning, Schema-Bound Actions, Replayable Artifacts

Link: https://cairatutd.github.io/

Software Engineer Intern at Glydr.gg

Date Range: Jan 2026 - May 2026

Category: Industry

Timeline Tone: past

Summary: Led engineering for Glydr.gg through Consult Your Community, shipping a Railway-deployed configuration platform used by 2,000+ external customers and connecting the public product to distributed Control Panel clients.

Highlights:

Built the customer-facing configuration hub with React, Vite, Fastify, PostgreSQL, and Drizzle, turning controller and game configuration sharing from manual file handoffs into a searchable, versioned product workflow.
Deployed the system as independently operated frontend, API, worker, and database services on Railway, with automated migrations and CI/CD supporting repeatable production releases.
Designed the relational model for users, Steam identities, sessions, games, categories, configurations, immutable versions, imports, handoff tokens, jobs, and audit events.
Engineered cross-client imports through REST APIs, short-lived hashed token handoffs, checksum-addressed payload versions, fetch limits, validation, and deduplication so the Control Panel receives the exact configuration a customer selected.
Made configuration versions immutable and checksum-addressed, allowing imports to resolve an exact payload, suppress duplicates, and remain reproducible as publishers release newer revisions.
Coordinated API and Control Panel state through bounded handoff tokens and background jobs, preserving a clean trust boundary between the public product and independently deployed desktop clients.
Implemented Steam OpenID authentication, HTTP-only session cookies, CSRF protection, administrative publishing controls, rate limits, and private-upload boundaries around the public discovery experience.
Built product and administrative surfaces for discovery, game and category navigation, official publishing, private uploads, version history, import state, and operational auditability.
Shipped the platform to production for more than 2,000 external customers, giving users one-click configuration discovery and import while giving Glydr a controlled publishing, versioning, and distribution surface.

Tags: TypeScript, React, Vite, Fastify, PostgreSQL, Drizzle ORM, Railway, Microservices, REST APIs, Distributed Configuration, Steam OpenID, Authentication, Versioned Data, CI/CD, Product Engineering, Distributed Systems, Platform Engineering, Background Workers, Immutable Versions, Checksum Validation, Token Handoffs, HTTP-Only Cookies, CSRF Protection, Rate Limiting, Admin Tooling, GitHub Actions, Technical Leadership, API Design, Config Versioning, Full-Stack-Development, Distributed-Systems, CSRF

Link: https://glydr.gg/

Machine Learning Engineer Intern at UT Southwestern Medical Center, Tsai Lab

Date Range: Feb 2026 - Jun 2026

Category: Research

Timeline Tone: past

Summary: Built an end-to-end computer vision pipeline for 3-chamber behavioral-neuroscience studies, adapting DeepLabCut/SuperAnimal to lab footage and improving pose-track stability by 56.9%.

Highlights:

Worked with the Tsai Lab on markerless pose estimation for 3-chamber mouse-behavior experiments used to study social interaction and experimental phenotypes.
Hand-annotated domain footage and fine-tuned the DeepLabCut/SuperAnimal model stack around the lab's camera geometry, chamber layout, animal appearance, and occlusion patterns instead of relying on an unchanged general-purpose checkpoint.
Built the complete analysis path from raw videos through pose inference, likelihood-aware filtering, dropped-keypoint interpolation, chamber and cup-contact metrics, behavioral scoring, quality-control reports, and CSV/XLSX exports.
Standardized pose, likelihood, and experiment metadata across video, HDF5, tabular, and researcher-facing formats so each derived score remains traceable to the underlying frames and model confidence.
Improved pose-track stability by 56.9% across benchmark video pairs through model adaptation, confidence filtering, interpolation, and hardened post-processing.
Corrected downstream scoring around discrimination index, ambiguous contact, interpolation boundaries, chamber occupancy, body-length anomalies, and low-confidence summaries so results aligned with the experimental definitions researchers actually use.
Added trial-level quality signals for occlusion, implausible body geometry, low-confidence intervals, and interpolation coverage, enabling researchers to review uncertainty alongside each behavioral result.
Delivered a reproducible researcher-facing workflow that transforms raw pose outputs into uncertainty-aware tracks, interpretable behavioral summaries, and review-ready scorecards.

Tags: Computer Vision, Machine Learning, DeepLabCut, SuperAnimal, Model Fine-Tuning, Domain Adaptation, Markerless Pose Estimation, Behavioral Neuroscience, Video Analysis, OpenCV, Python, pandas, NumPy, Research Software, Behavioral Phenotyping, Pose Tracking, Likelihood Filtering, Keypoint Interpolation, Quality-Control Tooling, HDF5, CSV/XLSX, Scientific Computing, Mouse Behavior Analysis, QC Tooling, Computer-Vision, Machine-Learning, Markerless-Pose-Estimation, DeepLabCut/SuperAnimal, Behavioral-Neuroscience

Link: https://labs.utsouthwestern.edu/tsai-lab

Peer Advisor at UT Dallas

Date Range: Jan 2026 - Jul 2026

Category: Leadership

Timeline Tone: past

Summary: Supported residential operations at UT Dallas through direct resident guidance, incident escalation, community programming, conflict resolution, and coordination with Residential Life.

Highlights:

Served as a first point of contact for academic, personal, housing, and community concerns, connecting residents with the right campus resources when an issue required specialized support.
Handled on-call responsibilities, policy concerns, roommate conflicts, incident reporting, and emergency escalation while maintaining clear communication with professional Residential Life staff.
Built community through resident conversations, meetings, and programs designed to make a large campus feel more navigable and supportive.

Tags: Peer Leadership, Residential Operations, Crisis Response, Conflict Resolution, Community Building, Communication, Resident Support, Community Programming, Emergency Response, Community-Building, Conflict-Resolution, Residential-Operations, Crisis-Response, Peer-Leadership

Link: https://reslife.utdallas.edu/pa/

Undergraduate Research Assistant at UT Dallas

Date Range: Apr 2025 - Nov 2025

Category: Research

Timeline Tone: past

Summary: Built exact optimization solvers and a 67,000-instance programmatic labeling pipeline for research on learning optimal drone coverage plans under distribution shift.

Highlights:

Implemented four paper-faithful greedy and dynamic-programming solvers for one-dimensional drone coverage, including exact plan reconstruction rather than returning only an objective value.
Built the pipeline from generated optimization instances to gold plans, feasibility checks, ML features, JSONL datasets, and quality-control reports so supervised and reinforcement-learning experiments could learn from verified solutions.
Configured a 67,000-instance dataset across training, in-distribution test, shifted, extrapolation, and stress splits to measure whether learned policies generalize beyond the solver's training distribution.
Measured verified labeling throughput at approximately 136 instances per second and benchmarked exact-solver scaling to establish where exact supervision remains computationally practical.
Verified a representative labeling run of 370 solved instances in 2.71 seconds and benchmarked the full dynamic program through 4,096-segment cases, establishing concrete throughput and scaling envelopes for gold-label generation.
Validated every reconstructed plan against feasibility and coverage constraints and cross-checked solver families against shared oracle instances, ensuring generated labels contain executable plans rather than objective values alone.
Exposed gold labelers, legality masks, candidate metadata, and featurization hooks for supervised learning, graph neural network, and reinforcement-learning research.

Tags: Optimization, Dynamic Programming, Exact Algorithms, Programmatic Labeling, Dataset Generation, Distribution Shift, Drone Coverage, Python, NumPy, PyTorch, Reproducible Research, Coverage Planning, Drone Routing, Computational Geometry, Greedy Algorithms, Plan Reconstruction, Featurization, Data Quality, Benchmarking, JSONL, Graph Neural Networks, Reinforcement Learning, Algorithms, Data QC, GNN, Pytest, Exact-Algorithms, Dataset-Generation, Dynamic-Programming, Distribution-Shift-Evaluation

Link: https://personal.utdallas.edu/~daescu/

Software Engineering Intern at Abilitie

Date Range: May 2024 - Aug 2024

Category: Industry

Timeline Tone: past

Summary: Shipped Abilitie AI Cases across 27 enterprise role-play configurations, working from React product flows through structured inference, Llama 3.1 fine-tuning, model observability, and latency and cost optimization.

Highlights:

Built React and TypeScript chat, scenario, streaming, and completion flows for Abilitie AI Cases, converting streamed Azure and AWS model output into validated application state across 27 enterprise role-play configurations.
Owned end-to-end Llama 3.1 fine-tuning on proprietary role-play conversations, scenario data, and structured-output targets to improve domain fidelity and schema-following behavior.
Productionized the fine-tuned model as an available inference path while retaining provider flexibility for the primary customer experience.
Replaced brittle free-form responses with schema-constrained JSON that could be validated, rendered deterministically, and retried only when required.
Built model and provider abstractions across Azure and AWS inference so product flows could route among production models while preserving a shared streaming and structured-output contract.
Reduced LLM cost per conversation by 70% through model migration, prompt compression, structured outputs, and retry reduction rather than treating model price as the only cost lever.
Compressed prompts by approximately 20% and reduced schema-related retries by roughly 8%, improving inference economics while preserving the scenario context required for realistic role-play.
Built DynamoDB telemetry for time to first token, time to last token, throughput, token usage, retries, failures, model and provider metadata, and per-request traces.
Instrumented the complete request path so provider latency, first-token latency, generation duration, token throughput, retry behavior, and application errors could be analyzed separately across models and scenarios.
Used that instrumentation to optimize 3-second idle prefetching and stale-response invalidation, reaching 1.0-second p95 time to first token after the user sends a message.
Tested and hardened the product against prompt injection, malformed output, stale generations, and scenario-breaking responses, balancing model quality with latency, cost, reliability, and role-play realism.

Tags: LLM Product Engineering, Model Fine-Tuning, Llama 3.1, Structured Outputs, React, TypeScript, AWS, Azure, DynamoDB, AI Observability, Latency Optimization, Cost Optimization, Prompt Injection Testing, Streaming UX, JSON Schema, Tool Calling, Prompt Engineering, Model Evaluation, Telemetry, Observability, Material UI, Provider Abstraction, Enterprise AI, Role-Play Simulation, Product Engineering, LLMs, LLM-Product-Engineering, Model-Fine-Tuning, AWS/DynamoDB, Latency-Optimization, AI-Observability

Link: https://www.abilitie.com/case-challenges

Dorm Proctor at St. Stephen's Episcopal School

Date Range: Aug 2021 - May 2022

Category: Leadership

Timeline Tone: past

Summary: Led peer mentorship, residential safety, conflict resolution, and emergency response inside a boarding-school community.

Highlights:

Helped new students adapt to boarding-school routines, expectations, and the social reality of living away from home.
Served as a trusted peer for academic, personal, and social concerns while coordinating with dorm parents, counselors, and administrators when additional support was needed.
Completed safety and emergency-response training and helped maintain a welcoming, accountable, and inclusive residential environment.
Balanced mentorship, residential operations, academic responsibilities, and community expectations in a role built on consistency, discretion, and trust.
Coordinated directly with dorm staff, counselors, and administrators to connect students with the right support while preserving discretion and continuity of care.
Helped sustain daily residential operations through presence, clear communication, conflict mediation, and dependable follow-through across the boarding community.

Tags: Residential Leadership, Student Mentorship, Emergency Response, Conflict Resolution, Community Building, Peer Support, Student Life, Safety Training, Communication, Counseling, Residential-Leadership, Student-Mentorship, Emergency-Response, Conflict-Resolution, Community-Building

Link: https://www.sstx.org/boarding/boarding-student-support

Project Source Links

MonopolyBench

Summary: A long-horizon multi-agent evaluation environment for frontier LLMs, capturing 8,000+ decisions across 40M+ tokens through deterministic economic simulations, schema-constrained tools, and fully replayable agent trajectories.

Highlights:

MonopolyBench tests sustained agency rather than isolated question answering. Four LLM agents repeatedly plan, negotiate, allocate capital, manage liquidity and risk, recover from mistakes, and respond to strategic counterparties inside a persistent economy.
Built the authoritative Python rules engine as the only component allowed to mutate state, then converted every legal decision into a schema-constrained tool so models retain strategic freedom without being able to invent actions or rewrite the environment.
The custom evaluation harness assembles public state, private memory, conversation history, and legal tools for each turn, validates the selected action, attaches concrete errors for one corrective retry, and applies a logged deterministic fallback when necessary.
Implemented complete deterministic game mechanics including seeded dice and cards, the 40-space board, rent schedules, ascending auctions, counter-offer trade threads, mortgages, even-build housing constraints, jail, liquidation, and bankruptcy cascades.
Modeled public negotiation and private reasoning separately, making cooperation, deception, persuasion, risk preference, memory, and strategic consistency observable at the individual-decision level.
Created 130 controlled frozen-state scenarios across trades, auctions, purchases, building, jail, liquidity pressure, and liquidation, complementing full campaigns with targeted tests of specific capabilities and failure modes.
Captured more than 8,000 agent decisions across 40M+ model tokens, creating high-signal evaluation data for frontier-model comparison, behavioral verification, failure analysis, targeted synthesis, and post-training research.
Recorded every prompt, raw response, tool call, validation failure, retry, fallback, communication, event, state snapshot, token count, and cost instead of reducing each run to a win rate or final balance.
Built deterministic event-stream replay that reconstructs the complete trajectory and identifies the exact transition where a run diverges, separating model failures from harness, engine, and artifact-integrity failures.
Designed fixed-seed cohorts, deterministic baselines, controlled rosters, and Latin-square seat rotation so measured differences reflect model behavior rather than turn order or environment variance.
Built batch campaigns that produce leaderboards, per-model research cards, scenario-category breakdowns, validity and recovery profiles, statistical summaries, and complete token and budget reports.
Used provider-reported OpenRouter usage and generation records for decision-level cost accounting, preserving model quality, reliability, latency, and inference economics in the same evaluation corpus.
Exposed live games through FastAPI, WebSockets, and a render-only React spectator interface while keeping the Python engine authoritative over every state transition.
Structured the benchmark as reusable research infrastructure, with full-game campaigns for emergent strategy and frozen-state suites for targeted evaluation and post-training data synthesis.
The resulting research surface supports long-horizon planning, tool-use reliability, negotiation, capital allocation, recovery, and post-training data studies using complete, auditable trajectories rather than opaque aggregate scores.

Tags: LLM Evaluation, Agent Benchmarking, AI Agents, Tool Calling, Long-Horizon Planning, Multi-Agent Systems, Deterministic Simulation, Replayable Artifacts, Negotiation, Deception, Game Theory, Economic Simulation, Event Sourcing, JSON Schema, Schema-Bound Actions, Telemetry, Bias Evaluation, Real Estate Benchmarking, Asset Management, Python, FastAPI, WebSockets, React, TypeScript, Vite, Zustand, OpenRouter, Post-Training Data, Failure Analysis, Controlled Experiments, Pydantic, Pytest, Research Infrastructure, Model Cards, Cost Accounting, Data Synthesis

Link: https://github.com/KushagraBharti/MonopolyBench

Thumbnail: /portfolio/projects/monopoly-llm-benchmark.svg

F1 Reinforcement Learning

Summary: A custom 60 Hz Formula 1 simulator and learning stack where CUDA evolutionary search produced an 89.327-second Monza lap, then behavior cloning and SAC trained a policy that completed the circuit in 78.683 seconds.

Highlights:

Built the racing environment from the ground up rather than wrapping an existing game: a Gymnasium-compatible 5,793-meter Monza circuit, a 60 Hz simulation loop, continuous throttle, brake, and steering control, checkpoint-validated laps, telemetry, deterministic replay, and visual rendering.
Used FastF1 telemetry exclusively to calibrate and refine simulator physics, grounding speed profiles, braking behavior, and track-section dynamics in real F1 data while evolutionary search and the learned policy produced the headline lap times.
Calibrated the physics against clean dry Monza telemetry across multiple seasons and drivers, fitting the simulated speed envelope, braking zones, acceleration profile, section timing, and track geometry to real driving data.
Modeled tire slip and force saturation, longitudinal and lateral weight transfer, an eight-gear torque curve, brake-bias instability, and distinct asphalt, curb, grass, and wall behavior so aggressive control carries realistic tradeoffs.
Implemented oriented vehicle-body collision checks, checkpoint and track-limit validation, surface-specific grip and drag, and simultaneous throttle-brake behavior so learned policies must control the car rather than exploit a point-mass abstraction.
Designed a 35-feature observation space spanning velocity, heading and lateral error, lap progress, seven ray-cast distances, lookahead geometry, curvature, braking gates, target-speed changes, and section-aware state.
Supported discrete, multidiscrete, and continuous action spaces alongside reward shaping, curriculum starts, state libraries, vectorized environments, checkpointing, TensorBoard telemetry, and metadata-aware evaluation for systematic algorithm iteration.
Ran CUDA-accelerated evolutionary search across 300,000 controller candidates, preserving elites and applying mutation and crossover over full-lap fitness to discover an 89.327-second Monza controller.
Implemented the evolutionary campaign as staged populations and generations with fused GPU scoring, elite survival, mutation, crossover, multi-objective progress signals, and full-lap validity gates.
Treated GPU search as a proposal engine rather than ground truth: promising controllers were reranked, replayed, and verified through the CPU simulator before their telemetry could become training data.
Enforced CPU-GPU parity through artifact-level reason codes, lap-validity comparisons, selected telemetry replay, and deterministic reranking, establishing a trusted promotion path from massive parallel search to verified results.
Converted verified controller trajectories into state-action datasets and trained a behavior-cloned PyTorch policy to reproduce the braking, turn-in, throttle, and recovery behavior found by search.
Versioned every exported transition with the physics model, calibration identifier, observation profile, and action schema, creating reproducible training datasets that remain tied to the simulator contract that generated them.
Fine-tuned the cloned policy with a project-native Soft Actor-Critic implementation using twin critics, target networks, replay-buffer preloading, continuous entropy-regularized control, and deterministic lap evaluation.
Trained behavior cloning for 120 epochs on CUDA, then initialized SAC from the learned policy and search-derived replay data so reinforcement learning began from a competitive racing prior rather than random exploration.
Reached a best behavior-cloning validation action error of 3.85e-5, preserving the search controller's continuous steering, throttle, and braking behavior in a compact neural policy.
Exported 50,128 versioned state-action transitions from 16 CPU-replayed source controllers, including eight complete valid laps for training and policy evaluation.
The final behavior-cloning and SAC policy completed Monza in 78.683 seconds, improving by 10.644 seconds over the 89.327-second evolutionary-search controller.
Evaluated the final policy deterministically from a standard start over 4,661 simulation steps, completing the valid lap at 270.8 kph across the line.
Versioned physics, calibration, observation, action, and replay contracts with every artifact so results from different simulator generations cannot be mixed into the same benchmark silently.
Generated exact telemetry replays, rendered lap visualizations, policy comparisons, and large multi-trace racing swarms directly from evaluated artifacts, making controller behavior inspectable beyond a single lap-time number.
Built hardware-aware validation around CUDA availability, NVIDIA Warp interoperability, CPU replay, physics contracts, and deterministic benchmark metadata so large experiments remain reproducible across execution paths.
Maintained PPO, curriculum-learning, and vectorized-environment infrastructure alongside the search, behavior-cloning, and SAC path, enabling controlled comparisons across policy-optimization approaches.
The core systems challenge was building a simulator trustworthy enough to optimize against, scaling search on the GPU without accepting simulation drift, and turning discovered trajectories into a learned policy that remained valid under deterministic replay.

Tags: Reinforcement Learning, GPU Evolutionary Search, Physics Simulation, Behavior Cloning, SAC, PyTorch, CUDA, FastF1, Racing AI, Formula 1, Gymnasium, Stable-Baselines3, PPO, Evolutionary Algorithms, Genetic Algorithms, Controller Search, Policy Optimization, Imitation Learning, Dataset Distillation, Simulation, Physics V2, Vehicle Dynamics, Tire Slip Angle, Tire Force Curve, Weight Transfer, Torque Curve, Brake Bias, Surface Modeling, Curb Physics, Collision Detection, Bicycle Model, Control, Monza, OpenF1, Telemetry, Replay Systems, OpenCV, Python, NumPy, Pygame, Ray-Cast Sensors, Reward Shaping, Reward Function Tuning, Multi-Profile Scoring, Mutation, Crossover, Elite Selection, Survival Floors, Curriculum Learning, State Libraries, Benchmarking, Experiment Tracking, Long-Horizon Control, ML Systems, GPU Computing, Optimization, NVIDIA Warp, Vectorized Environments

Link: https://github.com/KushagraBharti/F1-ReinforcementLearning

Thumbnail: /portfolio/projects/f1-optimization.png

IMC Prosperity 4 Quant Trading Competition

Summary: Finished top 6% worldwide in IMC Prosperity 4 among 18,803 teams, building market-making and statistical-arbitrage strategies with Black-Scholes voucher pricing and hindsight-oracle research.

Highlights:

Finished #1088 overall, placing in the top 6% worldwide among 18,803 teams across five rounds of algorithmic trading, market design, and manual optimization.
Built inventory-aware fair-value market makers with top-of-book imbalance, reservation-price skew, selective liquidity taking, and drift/carry strategies for products whose expected value moved predictably through the round.
Combined stationary fair-value mean reversion with a drift-carry accumulator across the opening products, ending rounds at the position limits when the modeled forward edge justified sustained inventory.
Modeled the competition's market-access auction as an expected-value allocation problem and optimized the manual research, scale, and speed decisions alongside the algorithmic system.
Priced derivative vouchers with Black-Scholes, strike-specific volatility, expiry decay, delta, and an underlying-implied fair, then restricted execution to strikes where the modeled edge survived spread and inventory costs.
Built volatility-smile diagnostics, counterparty-flow features, timed entries and exits, and PnL locks to adapt strategy behavior as products and market regimes changed between rounds.
Scaled the final round to 50 products using synthetic fair values, anchor relationships, category-relative residuals, momentum and reversal signals, rolling z-scores, and position targets constrained by fillability and inventory limits.
Built dynamic-programming hindsight oracles over inventory states to measure the executable opportunity ceiling for each product and distinguish missing alpha from weak execution. Oracle outputs were research labels and diagnostics, never live strategies.
Developed a Python and Rust research stack for historical replay, parallel simulation, strategy comparison, fill-sequence inspection, product and signal PnL attribution, drawdown analysis, and inventory-path review.
Maintained exact official submission artifacts, result scorecards, candidate lineage, and round-scoped strategy packages so every promoted strategy could be traced back to its research assumptions and official outcome.
Diagnosed official-versus-local divergence caused by evaluation-window transfer, within-tick matching assumptions, passive-fill sensitivity, and serialized-state limits, then added forced-cap replay and cross-engine validation before promoting candidates.
Compressed rolling state into delta-encoded integer histories to remain within the competition's 50,000-character persistence limit without discarding the context required by multi-product signals.
Used explicit promotion gates across portal-window replay, full-history replay, parallel Monte Carlo analysis, PnL attribution, drawdown, and transfer-risk review, rejecting strategies that won only on a favorable slice of history.
Won the first manual round and paired manual optimization with the algorithmic stack, treating puzzle structure, capital allocation, and mechanism design as additional quantitative research surfaces.
Recorded 415,950+ in displayed algorithmic PnL across the archived best official round artifacts while maintaining separate attribution for algorithmic strategies and manual optimization.
Preserved official submissions, result JSON, replay logs, strategy lineage, and product-level scorecards as a reproducible research archive spanning all five rounds.
The project became less about maximizing one backtest and more about proving which edge was robust under changing products, noisy fills, incomplete feedback, hard state constraints, and adversarial regime shifts.

Tags: Quantitative Trading, Market Making, Options Pricing, Black-Scholes, Statistical Arbitrage, Backtesting, DP Hindsight Oracle, Market Microstructure, Algorithmic Trading, IMC Prosperity, Top 6% Worldwide, Global Competition, Dynamic Programming, Inventory-Skewed Quoting, Fair Value Modeling, Volatility Smile, Residual Signals, Drift / Carry, PnL Attribution, Drawdown Analysis, Inventory Management, Execution Strategy, Signal Research, State Serialization, Python, Rust, Parallel Monte Carlo, Data Analysis, Research Infrastructure, Replay Fidelity, Cross-Engine Validation, Monte Carlo Simulation, Candidate Lineage, Regime Analysis, Mechanism Design, Strategy Promotion Gates, Manual Optimization, Official Submission Analysis, Reproducible Quant Research

Link: https://github.com/KushagraBharti/IMC-Prosperity-4

Thumbnail: /portfolio/projects/imc-prosperity.png

Beyond Chat

Summary: A project-centered agentic hub where teams run reusable agents against company knowledge and turn their work into durable, reviewable outputs through shared memory, approvals, and automation.

Highlights:

Built Beyond Chat around projects, reusable agents, connected knowledge, and durable outputs instead of disposable conversation threads. Each run resolves the organization, project, agent version, tools, skills, memory, model policy, budget, and approval requirements into a reproducible execution contract.
Designed General, Research, Finance, and organization-defined agents as reusable versioned capabilities, allowing teams to combine a stable agent identity with project-specific knowledge, tools, memory, policy, and automation.
Implemented a FastAPI control plane that creates durable run records before execution and maintains ordered events, worker leases, budgets, checkpoints, cancellation, suspension, recovery, reconciliation, generated files, and human approvals.
Used leases and worker ownership to coordinate execution, checkpoints to preserve progress, reconciliation to recover orphaned runs, and ordered event replay to reconnect streaming clients without losing the causal execution history.
Wrapped the Pi agent runtime behind an application-server protocol and executed production work inside isolated Modal sandboxes, allowing agents to call tools, create files, and run code without sharing a mutable host environment.
Connected agents to organization knowledge, uploaded files, Exa research, Composio applications, MCP servers, reusable skills, and agent- and project-scoped memory, with citations and access filtered through organization policy.
Streamed model output, tool calls, sources, generated files, failures, and execution state over SSE while preserving the same ordered event log for reconnect and replay.
Promoted useful run results into durable documents and structured outputs carrying source-run provenance, generated files, version history, project association, review state, collaboration, and approval status.
Built research, analysis, writing, and operational work products around the same provenance model, allowing completed outputs to become reviewed deliverables, future context, or inputs to repeatable automations.
Used WorkOS AuthKit for organizations, invitations, memberships, and RBAC; Supabase Postgres, Storage, Realtime, and organization-scoped row-level security for persistent data; and signed access paths for private files.
Applied organization policy to model availability, tool and application access, knowledge visibility, execution budgets, and approval requirements, making governance part of the runtime contract rather than a UI-only setting.
Built the product surface in React, TypeScript, Vite, Tailwind, and TipTap across projects, agents, knowledge and applications, automations, memory, work products, and administrative policy.
Integrated OpenRouter for model execution, Exa for source-backed research, Composio and MCP for application actions, Supabase Realtime for organization-scoped updates, and Stripe for product billing infrastructure.
The architecture turns an agent from a one-off chat response into a governed company workflow whose context, permissions, execution, evidence, output, and approval state survive the original session.
Systems depth: durable agent execution stays coherent across asynchronous workers, sandbox boundaries, streaming clients, tool providers, organization authorization, recovery, and human review through explicit runtime contracts.

Tags: TypeScript, React, Python, FastAPI, Supabase Postgres, Supabase Storage, Supabase Realtime, Supabase, PostgreSQL, OpenRouter, AI Agents, Tool Calling, Durable Execution, Durable Outputs, Workflow Orchestration, Agentic AI, Pi Agent Runtime, Modal Sandboxes, MCP, Composio, WorkOS AuthKit, RBAC, Context Engineering, Exa, Stripe, Vite, Tailwind CSS, Vercel, LLMs, RAG, Full-Stack Development, System Design, Product Engineering, Event Streaming, Worker Leases, Checkpoints, Run Recovery, Human Approval, Organization Policy, Row-Level Security, Signed URLs, TipTap, Automation Engine, Agent Memory, Knowledge Retrieval, Artifact Provenance, Artifact Systems, Model Comparison, Data Analysis

Link: https://github.com/KushagraBharti/Beyond-Chat

Thumbnail: /portfolio/projects/beyond-chat.png

Arachne - Go Web Crawler

Summary: A high-concurrency Go web crawler with BFS discovery, a host-partitioned frontier, robots-aware scheduling, PostgreSQL persistence, and a live reading interface; crawled 10,003 public pages in 67.96s (~147.2 pages/sec).

Highlights:

Built a high-throughput crawler in Go around bounded goroutine worker pools, channel-based scheduling, and a host-partitioned breadth-first frontier rather than launching an unbounded goroutine for every discovered URL.
The scheduler maintains per-host FIFO queues and dispatches round-robin across domains, layering global and host-specific concurrency limits so one fast or pathological site cannot monopolize the crawl.
Every dispatch passes through frontier capacity, host-rate, circuit-breaker, global semaphore, host semaphore, and robots.txt gates before entering the fetch pool, centralizing concurrency policy in one auditable scheduler.
Implemented robots.txt-aware scheduling, per-host rate limits, exponential retry backoff, 429 handling, response-size caps, and circuit breakers that isolate repeatedly failing hosts without stopping healthy work.
Cached robots.txt policies, propagated not-before deadlines from rate-limited responses, bounded response bodies, and reset host circuits after cooldown windows to combine crawl throughput with responsible public-web behavior.
Canonicalized and deduplicated URLs before frontier insertion, preserving breadth-first discovery order and preventing fragments, tracking parameters, redirects, and repeated links from inflating the workload.
Persisted frontier state, fetched pages, extracted content, discovery edges, errors, and run metadata in PostgreSQL, while also emitting portable JSON artifacts for replay, debugging, and offline analysis.
Modeled each crawl as a rooted discovery tree, preserving the exact parent edge that introduced every page and making large crawl datasets explainable from the seed outward.
Crawled 10,003 public-web pages in 67.96 seconds, approximately 147.2 pages per second, while preserving host fairness, crawl policy, canonical deduplication, and bounded resource use.
Built a Next.js reading interface that streams newly extracted pages over server-sent events, renders the rooted discovery tree, and lets users inspect page content and crawl diagnostics while the run is still active.
Added keyword-based discovery through search-ranked candidate seeds and speculative prefetch, reducing the time from a broad query to an immediately readable selected crawl.
Containerized the Go crawler, PostgreSQL persistence layer, and Next.js interface with Docker so benchmarks and interactive runs share the same repeatable deployment surface.
Systems depth: host fairness, backpressure, robots resolution, retry timing, circuit state, persistence, and cancellation operate through one coordinated scheduler, preserving throughput and correctness under real public-web behavior.

Tags: Go, Go Concurrency, Goroutines, Channels, Worker Pools, BFS Frontier, Host-Partitioned Scheduling, Frontier Scheduling, Circuit Breakers, robots.txt, URL Canonicalization, Deduplication, PostgreSQL, HTTP, HTML Parsing, Benchmarking, Server-Sent Events, Next.js, React, TypeScript, Systems Engineering, Backend Engineering, Performance Engineering, Large-Scale Web Data, Backpressure, Rate Limiting, Retry Backoff, Discovery Trees, Docker, Public-Web Crawling, Fault Isolation

Link: https://github.com/KushagraBharti/Web-Crawler-Go

Thumbnail: /portfolio/projects/arachne.png

Pact

Summary: A 1st-place HackSMU (Solana Track) mobile accountability platform where users stake money on commitments, submit proof, and resolve outcomes through peer-validator voting and token escrow.

Highlights:

Context: Pact makes accountability financial. Goals become staked commitments inside private circles, peers validate proof, kept commitments return the stake, and broken ones forfeit it. Won 1st place in the HackSMU Solana Track.
Product flow: circle creation with four-character invite codes (up to 24 members), pact creation with a deadline and a 1 to 1,000 DEMO_USDC stake, escrow lock, photo proof upload, validator voting, majority resolution, cancellation, and resolved-state lockout.
Built the Fastify and TypeScript backend as a server-owned lifecycle state machine, using Zod contracts and PostgreSQL constraints to keep creation, staking, proof, voting, resolution, cancellation, and settlement transitions valid.
Mobile: React Native and Expo with Expo Router and NativeWind across nine screens: login, home, create, circle, invite, pact detail, proof submission, voting, and profile.
Resolution engine: majority is floor(n/2)+1, and a pact resolves the moment an outcome is mathematically decided rather than waiting for every ballot. Escrow release or forfeit runs best-effort so settlement can never block the state transition.
Security: every protected route derives identity from the verified Supabase token, never from the client. Lifecycle gates allow proof only while awaiting proof and votes only while awaiting votes, creators structurally cannot be validators on their own pacts, and membership is checked on every read and write.
Defense in depth: unique database indexes enforce one vote per validator, one proof per pact, and one membership per circle, alongside CHECK constraints on status, stake range, and vote decisions.
On-chain architecture: implemented two escrow adapters, including real Solana devnet SPL transfers into a server-controlled vault and a seeding pipeline that mints DEMO_USDC for end-to-end settlement testing.
Migrated the product from standalone commitments to circle-scoped pacts during the hackathon, preserving existing rows through a compatibility migration while expanding the social accountability model.
Engineering scope: coordinated mobile UX, backend lifecycle state, validator logic, proof artifacts, database constraints, and token escrow inside the hackathon window while keeping every consequential transition server-enforced.

Tags: React Native, Expo, TypeScript, Fastify, Supabase, PostgreSQL, Solana, SPL Token, On-Chain Escrow, Hackathon Winner, 1st Place, State Machines, Server-Side Validation, Mobile Development, Full-Stack Mobile, Supabase Auth, Supabase Storage, Expo Router, Web3, FinTech, Consumer Social, Product Engineering, System Design

Link: https://github.com/KushagraBharti/Pact

Thumbnail: /portfolio/projects/pact.png

Personal Site + Tracker

Summary: A personal digital museum for everything I have built, researched, written, and filmed, paired with a private tracker, Google Calendar sync, and a custom OAuth-secured MCP server that runs my entire life.

Highlights:

Product shape: two products in one repo. The public site is a personal museum for everything I have built, researched, written, and filmed; the private tracker syncs Google Calendar and exposes a custom OAuth-secured MCP server that lets agents operate the tasks and calendar workflows I use to run my entire life.
Route model: / serves the public portfolio, /ai the AI-readable profile, /tracker the private app, /oauth/consent the Supabase OAuth consent UI for MCP clients, /api the public APIs, /api/private the tracker APIs, /api/mcp the MCP endpoint, and /.well-known/oauth-protected-resource the OAuth resource metadata.
Content model: backend TypeScript content is the single source of truth for profile copy, about text, education, experience, 20 ordered projects, writings, film, and AI prompts, with shared frontend and backend contracts around one exported snapshot.
Static export: one canonical snapshot emits ten artifacts: a prerendered index.html from the real React homepage shell, ai.html, llms.txt, portfolio.json, version.json, robots.txt, sitemap.xml, and three generated bootstrap modules, so the site humans see and the site agents read can never drift apart.
Performance: the homepage prerenders and then hydrates through Vite; /ai, /tracker, and /oauth/consent load lazily. Fonts are self-hosted with font-display optional, images prefer AVIF and WebP variants with PNG fallback, and the 3D hero plus media-heavy enhancements defer until after first paint with no skeleton placeholders.
Motion system: GSAP with ScrollTrigger drives section choreography, Lenis adds smooth scrolling on fine-pointer motion-safe devices only, and a shared ghost-to-ink scrubbed display type is the typographic signature.
Live widgets: GitHub stats prefer the GraphQL contribution path with caching and fallbacks, and weather uses OpenWeather with backend geo fallback. Both sit behind Express, and the weather widget never triggers a browser location prompt.
Tracker auth boundary: Supabase email and password auth lives in the browser, but tracker data only flows through backend-owned private APIs. The frontend resolves fresh access tokens before private requests and before joining Realtime topics.
Tasks hub: sidebar lists with counts, all-tasks and per-list views, open and completed sections, subtasks, notes, due dates, quick date actions, per-list sort modes with drag reorder, and local hide-completed preferences.
Task model: list links, same-list parent links for subtasks, details, due timestamps with timezones, completion state, sibling sort order, and a recurrence taxonomy of none, daily, weekly, biweekly, and custom with an interval plus a day, week, or month unit and an optional end bound.
Date semantics: date-only tasks normalize to 10 PM in the selected timezone, offsetless datetimes stay local to the task timezone, and absolute ISO datetimes keep their instant. Completing a recurring task mints the next occurrence, and a cron repairs recurring tasks missing their next open copy.
Data model: 14 Supabase tables, ten for the tracker (lists, tasks, sort preferences, sync settings, calendar connections with encrypted token rows split from the public row, jobs, runs, and two event-link tables) and four for MCP (clients, audit logs, rate-limit events, delete confirmations), all under RLS.
Calendar sync engine: a backend-owned job queue with seven job types across four lanes and three run modes; claim, complete, and fail RPCs; dedupe keys and priorities; recovery of jobs stuck running for over ten minutes; and bounded drains sized for serverless execution limits.
Reconciliation: app-side passes scan due tasks in synced lists, Google-side passes read tracker-owned calendar events, rebuild mode clears and reconstructs the dedicated Tracker Tasks calendar, and inbound deltas restore cancelled tracker-owned events instead of importing arbitrary calendar edits as tasks.
Google event model: deterministic event IDs, private extended metadata, timed and all-day events, [Done] titles for completed non-recurring tasks, [Upcoming] projections for recurring ones, and watch renewal with webhook validation.
Realtime refresh: database triggers broadcast small invalidation events on private per-user topics. The client authenticates the topic, debounces the signals, and refetches canonical backend state instead of trusting payloads.
MCP server: a Streamable HTTP endpoint exposing 12 tools across four scopes (read, write, delete, calendar-sync): tracker snapshot, list and task lookup, active and completed listing, create, update, complete, uncomplete, manual calendar sync, and a two-step delete where a prepare call mints a confirmation token bound to the exact task subtree.
MCP auth: Supabase OAuth resource-server validation through JWKS or an HS256 secret, pinned to a single owner user and per-client policy rows, with a timing-safe static bearer as the dev fallback, origin and host allowlists, sliding-window rate limiting through an advisory-lock RPC, and audit logging.
MCP visibility: assistants only see task lists explicitly marked MCP-visible and not archived, client policy can narrow the set further, and writes require an exact list ID or a normalized list name.
Security boundary: public exports never contain tracker data, frontend env carries only anon keys (the admin client actively rejects anything that is not a service-role JWT), production CORS is locked to known aliases, and RLS plus private Realtime topics guard everything private.
Operations: frontend and backend deploy as separate Vercel projects, while four staggered daily jobs handle calendar synchronization, recurring-task repair, Google watch renewal, and MCP rate-limit cleanup within serverless execution bounds.
Systems depth: static public content, server-owned private state, Supabase Auth, RLS, Realtime, Google Calendar side effects, serverless queue processing, and assistant-facing MCP tools remain coherent through backend-owned contracts and canonical-state refresh.

Tags: TypeScript, Express, React, Supabase, MCP, Model Context Protocol, Google Calendar API, Supabase Realtime, Serverless Queues, Static Prerendering, AI-Readable Portfolio, llms.txt, Node.js, Vite, Tailwind CSS, Framer Motion, Three.js, npm, Vitest, Supabase Auth, PostgreSQL, Supabase RLS, Google OAuth, Task Management, Task Recurrence, Calendar Sync, Realtime Systems, Supabase Broadcast, Cron Jobs, Webhooks, Serverless, Vercel, Portfolio JSON, GitHub GraphQL, OpenWeather, REST API, Private APIs, Full-Stack Development, API Integration, Live Widgets, Authentication, Security Hardening, System Design, Testing

Link: https://github.com/KushagraBharti/Personal-Site

Thumbnail: /portfolio/projects/personal-site.png

NovelBench

Summary: A live public research benchmark where 2 to 8 frontier models generate, anonymously critique, revise, and judge creative ideas, producing Glicko-ranked leaderboards with built-in bias audits.

Highlights:

Context: NovelBench tests whether LLMs can generate, critique, revise, and judge creative ideas through a structured multi-stage arena, instead of the usual one-shot screenshot comparisons.
Pipeline: a durable Convex workflow runs generate, anonymous critique, an optional human-critique checkpoint where the run blocks until a human proceeds, revise, vote, and crown. Pause, resume, and cancel are event-driven controls on the same workflow.
Durable orchestration: per-model actions use bounded workpools, exponential retry policy, quorum-based completion, explicit terminal states, and scheduled reconciliation so multi-model evaluations progress reliably across restarts and provider variance.
Anonymity: models appear to each other as letters A through H, idea order is shuffled per judge with a deterministic seeded shuffle, prompts never contain model names, and the presented order is persisted so position bias can be audited afterward.
Scoring: ballots decompose into weighted pairwise comparisons feeding a Glicko rating system, ranked by conservative rating (rating minus twice the deviation). Judge ballots are weighted 0.8 to 1.2 by the judge's own rating, and models under eight pairwise matches stay provisional.
Bias auditing: the leaderboard computes self-preference deltas, same-lab deltas, first-position bias, judge influence concentration, weighted-versus-unweighted rank shifts, and coverage confidence for every ordering.
Data model: about 30 Convex tables: compact run summaries, per-participant stage state, typed append-only event tables for live tokens, tool calls, failures, control events, and reasoning traces, with leaderboard snapshots and daily stats as rebuilt read models rather than per-request scans.
Model execution: OpenRouter streaming with tool-calling turns, structured-output normalization, live token and reasoning-trace events, and policy-gated Exa research during generate and revise with explicit per-stage budgets.
Governance: bring-your-own OpenRouter keys AES-encrypted in a vault table, per-organization policies for allowed models and spend, rate limits of 12 runs per hour and 100 per day, and usage ledgers.
Live scale: 54 benchmark runs, 231 generated ideas, 1,117 critiques written, and 22 tracked frontier models, with the corpus continuing to grow as new public evaluations complete.
Product surface: a Next.js 16 and React 19 site with the live arena, a searchable archive, leaderboard views, and detailed run pages that expose every stage of every run.
Systems depth: coordinates up to eight frontier models through a restart-safe workflow while preserving anonymity, ordered audit trails, normalized structured ballots, live reasoning events, and statistically qualified ratings.

Tags: LLM Evaluation, AI Benchmarking, Multi-Model Evaluation, Glicko Ratings, Convex, Next.js, TypeScript, React, OpenRouter, Workflow Orchestration, Structured Outputs, Anonymous Critique, Model Voting, Bias Auditing, Leaderboard Systems, Creative Evaluation, Evaluation Infrastructure, Realtime Systems, Exa, Prompt Engineering, Product Engineering, Research Infrastructure, Solo Project

Link: https://github.com/KushagraBharti/NovelBench

Thumbnail: /portfolio/projects/novel-bench.png

AutoHDR ML Lens Correction

Summary: A geometry-first neural lens-correction system combining Brown-Conrady calibration with learned residual flow; scored 0.8942 on the normalized leaderboard scale, earned an honorable mention, and led to a follow-up call with the CTO.

Highlights:

Context: built AutoHDR as a competition-grade computer-vision system for automatic lens correction on paired distorted and corrected image data.
Problem: pure image-to-image models learn corrections that look plausible while ignoring camera geometry. AutoHDR pairs an analytic Brown-Conrady distortion model with a learned residual so correction stays a structured geometric transform.
Model: a shared ResNet34 backbone, trained from scratch with a six-channel input that includes coordinate channels, feeding two heads: a parametric head that predicts eight Brown-Conrady coefficients (three radial, two tangential, principal-point offsets, and scale) with tanh-bounded ranges and near-identity initialization, and an FPN-style decoder that produces a bounded two-channel residual flow at one-eighth resolution.
Geometry: the parametric grid and the residual delta fuse additively into a single differentiable grid_sample warp, backward-mapped with border padding, so the whole correction remains one geometric operation end to end.
Loss stack: Charbonnier pixel, SSIM, edge magnitude, line-orientation histogram, and gradient-orientation terms, plus total-variation, magnitude, and curvature regularizers on the flow and a Jacobian foldover penalty that punishes self-crossing warps.
Training: three stages over 23,118 paired images: param-only calibration, hybrid, then fine-tune (8, 8, and 5 epochs, cosine learning rate from 2e-4 down to 8e-5, mixed precision, native-resolution real pairs), each stage warm-started from the previous stage's best checkpoint. The first full campaign ran on a RunPod H100 80GB and the second on an H200.
Safety routing: every output passes checks on out-of-bounds ratio, border validity, Jacobian determinant, and residual magnitude, with deterministic hybrid, parametric, and conservative correction paths plus complete mode telemetry.
Inference: a deterministic full-batch run over 1,000 hidden test images finished with 100% hybrid mode, zero unsafe triggers, and zero fallbacks, with run metadata recording mode counts and artifact lineage.
QA and submission: filename and image-integrity checks, a proxy scorer with hard-fail flags, a validation gate that fails the build past a failure-rate threshold, and QA-gated submission packaging.
Evaluation: scored 0.8942 on the normalized leaderboard scale, equivalent to 89.42 on the displayed scale, earned an honorable mention, and led to a follow-up call with the CTO about hiring the team.
Architecture attribution: the analytic parametric head captures the dominant global correction while the learned residual handles localized departures, preserving geometric interpretability across the full inference path.
Engineering depth: kept the warp differentiable and numerically stable while balancing analytic geometry, learned capacity, staged training, safety routing, quality gates, and deterministic submission packaging.
Validation covered analytic geometry contracts, differentiable warping, loss behavior, training hooks, safety routing, inference artifact integrity, quality-control tooling, and deterministic submission generation.

Tags: Computer Vision, PyTorch, Lens Distortion Correction, Brown-Conrady Model, ResNet34, grid_sample, Residual Flow, ResNet34 CNN, Deep Learning, CNNs, Image Geometry, Optical Flow, Warping, Model Training, Staged Training, Benchmarking, H200, H100, Reproducible Systems, Testing, QA Tooling, Competition Engineering

Link: https://github.com/KushagraBharti/AutoHDR-LensCorrection

Thumbnail: /portfolio/projects/autohdr-ml-lens-correction.png

PseudoLawyer

Summary: An AI contract-negotiation platform: two parties negotiate in a shared realtime chat, an AI mediator joins on request, and the conversation compiles into a generated contract draft.

Highlights:

Built PseudoLawyer into a complete contract-negotiation platform where two parties negotiate in a shared real-time chat, invoke an AI mediator when useful, and compile the resulting agreement into a contract draft; completed the product solo from its original group-project foundation.
Flow: pick a seeded template (freelance services agreement or NDA, both stored as structured JSON), invite a counterparty by email, negotiate in realtime, invoke the mediator when stuck, then finalize into a generated contract and download it.
Stack: Next.js 15 App Router with React 19, Supabase Auth, Postgres, and Realtime, and OpenRouter through the OpenAI SDK to Claude 3.5 Sonnet, with a Tailwind and Framer Motion dark UI.
Data model: six tables (profiles, templates, negotiations, participants, messages, contracts) with a signup trigger that provisions profiles, plus middleware that guards protected routes and round-trips the redirect target through login.
Realtime correctness: re-fetches each Supabase postgres_changes message with its joined sender profile before rendering, preserving participant identity and ordering across concurrent negotiation updates.
Mediator design: Sudo is prompted as a neutral participant in a three-way conversation. State reaches the model as structured JSON, with per-turn sender and role, the latest message, and contract context, rather than a flat transcript, which keeps the mediator aware of who said what.
Trigger mechanics: seven invocation phrases plus an explicit ask button, so the mediator responds when called instead of interrupting every message.
Two tuned AI surfaces: mediation runs at temperature 0.75 with 600 max tokens over the last 20 messages; contract drafting runs at temperature 0.3 with 4,000 max tokens over the last 50 messages plus the template JSON. Same model, deliberately different configurations for conversational versus legal output.
Measured: OpenRouter round-trip latency of p50 897ms and p95 981ms over five instrumented runs, preserved as committed evidence artifacts in the repo.
Agreement compiler: combines the structured template, participant identities, and the latest 50 negotiation messages into a low-temperature drafting pass, preserving the negotiated context in the generated contract artifact.
Systems depth: multi-party realtime state, neutral AI mediation, structured legal drafting, cookie-based SSR authentication, middleware session refresh, and protected redirects operate as one continuous negotiation flow.

Tags: Next.js 15, TypeScript, Supabase, Supabase Realtime, OpenRouter, Claude 3.5 Sonnet, AI Mediator, LLMs, Contract Generation, Legal Tech, PostgreSQL, Supabase Auth, Tailwind CSS, Framer Motion, Full-Stack Development

Link: https://github.com/KushagraBharti/PseudoLawyer

Thumbnail: /portfolio/projects/pseudo-lawyer.png

Kaggle Titanic ML

Summary: An end-to-end supervised machine-learning pipeline spanning data cleaning, exploratory analysis, feature engineering, nine-model comparison, and reproducible prediction export.

Highlights:

Built the complete supervised-learning workflow in Jupyter over the Kaggle Titanic dataset, from raw tabular data through engineered features, comparative modeling, interpretation, and prediction export.
Data work: 891 training and 418 test rows. Age imputed by sex-by-class medians (177 missing), cabin dropped (687 missing), embarked mode-filled, and fares binned into ordinal bands.
Feature engineering: title extraction from names with rare-title consolidation, FamilySize, IsAlone, and an Age-by-Class interaction. FamilySize was analyzed and then dropped once IsAlone captured the same signal more cleanly.
EDA: survival splits studied across class, sex, age, family structure, fare, and title: 74.2% survival for women versus 18.9% for men, 63.0% in first class versus 24.2% in third, 79.4% for Mrs versus 15.7% for Mr.
Models: nine classifiers compared in scikit-learn: logistic regression, SVC, linear SVC, KNN, decision tree, random forest, Gaussian naive Bayes, perceptron, and SGD.
Results: decision tree and random forest both reached 86.76% training accuracy, leading the nine-model comparison on the engineered feature set.
Documentation: a separate written report preserves the complete analytical process, feature decisions, exploratory findings, model comparisons, and interpretation of results.
Established the full supervised-learning workflow used throughout later ML work: cleaning, encoding, exploratory analysis, feature engineering, model comparison, visualization, and reproducible prediction export.

Tags: Machine Learning, scikit-learn, Feature Engineering, EDA, Supervised Learning, Kaggle, Titanic, Jupyter, Python, pandas, Data Cleaning, Model Comparison, Random Forest, Decision Tree, Logistic Regression, SVM, KNN, Naive Bayes, Matplotlib, Seaborn, Technical Documentation

Link: https://github.com/KushagraBharti/Kaggle-Titanic-Solution

Thumbnail: /portfolio/projects/kaggle-titanic-ml.png

Algorithmic Trading Quantitative Test Environment

Summary: A single-strategy quant pipeline connecting Alpaca data, a cost-aware backtest, risk metrics, and a live paper-trading round trip, built to learn the full research-to-execution loop.

Highlights:

Built the quantitative workflow end to end: market-data ingestion, feature computation, signal generation, cost-aware backtesting, risk measurement, trade logging, and live paper execution.
Pipeline: Alpaca historical daily bars flow through feature engineering (returns, moving averages) into a 20/50 moving-average crossover strategy, then a vectorized backtest that charges a flat 10 basis points per position change, then Sharpe ratio, max drawdown, and final return.
Execution: a real Alpaca paper-trading round trip: submit a market buy, poll until filled, submit the sell. Research code wired to a live execution path.
Auditability: CSV trade logs and Matplotlib equity and signal plots for every run make strategy behavior easy to audit.
Benchmark: the evaluation loop measured at roughly 1.54M bars per second on a 199,951-bar seeded synthetic dataset, fast enough that iteration speed is not the bottleneck.
Separated market-data ingestion, feature engineering, signal generation, transaction-cost modeling, portfolio simulation, risk measurement, trade logging, and broker execution into an auditable research-to-execution pipeline.
Used seeded synthetic data alongside Alpaca market data to benchmark the vectorized evaluation engine reproducibly while retaining a live paper-trading path for end-to-end execution validation.

Tags: Python, Alpaca API, Pandas, NumPy, Matplotlib, Algorithmic Trading, Backtesting, Paper Trading, Risk Metrics, Sharpe Ratio, Max Drawdown, Quant Research

Link: https://github.com/KushagraBharti/Quant-Test-Environment

Thumbnail: /portfolio/projects/quant-test-environment.png

Northstar Agentic Financial Memory Platform

Summary: A memory-first AI wealth manager built in four days for a Goldman Sachs-sponsored hackathon, compiling a 44-question intake into durable financial context and streaming every agent action into a visible audit trail.

Highlights:

Built Northstar with a small team in about four days for a Goldman Sachs-sponsored hackathon, centering the product on one visible wealth-management agent that loads durable financial context before responding.
Memory preload: every chat request runs seven parallel database queries (memory documents, context packets, user records, accounts, holdings, tax lots, transactions) and injects the compiled memory file, context packet, and top holdings directly into the system prompt, so personalization is in place before the first token.
Onboarding compiler: a 44-question intake across seven sections (identity, cash flow, assets, goals, risk behavior, taxes, values and approvals) compiles into readable memory markdown, a structured context packet, and a preference graph with eight node types centered on the person.
Agent runtime: three execution modes combine a low-latency OpenRouter streaming path with multi-turn OpenAI Agents SDK runs for fresh research and scenario analysis, plus automatic provider-path recovery.
Tools: six live tools (memory context, portfolio context, Exa web search, market data, financials, filings), with external research hard-capped at three calls per run, plus five deterministic scenario tools and five memory-compiler tools.
Observability: every event dual-writes to JSONL trace files and a database table, with 14 event types (run lifecycle, tool calls, warnings, message deltas) streaming live into the UI trace panel. Scenario runs persist trust receipts with an approval-required status.
Deterministic product data: seeded 13 accounts, 72 transactions, and a $60,687.96 portfolio, plus simulated Plaid ingestion and provider mirrors, creating a complete repeatable financial environment for every workflow.
Plans and approvals: generated plans carry per-step approval state with a dedicated approval endpoint, enforcing a visible human-in-the-loop boundary before consequential financial actions advance.
Frontend: React 19 and Vite with GSAP animation and a hand-written CSS design system: a chat workspace with a live trace panel, a memory-graph dashboard, a scenario canvas, and plans and goals pages.
Architecture: durable memory compilation, parallel context loading, visible tool provenance, deterministic financial fixtures, scenario analysis, trust receipts, and approval gates combine into one explainable agent experience.
Systems depth: preloaded memory, live tool traces, provider recovery, deterministic scenarios, portfolio context, and approval controls remain synchronized across every agent mode.

Tags: Agentic AI, AI Agents, Contextual Memory, Tool Calling, TypeScript, React, Express, OpenRouter, OpenAI Agents SDK, Supabase, PostgreSQL, JSONL Tracing, Observability, Guardrails, FinTech, Scenario Analysis, Portfolio Analytics, Exa, Vite, LLMs, Full-Stack Development, System Design, Hackathon

Link: https://github.com/YuvrajKashyap/northstar

Thumbnail: /portfolio/projects/northstar.png

Age & Gender Recognition

Summary: A real-time OpenCV computer-vision system that detects faces from video and predicts age and gender through Caffe DNN models.

Highlights:

Built a real-time face detection pipeline using OpenCV’s DNN module.
Used pre-trained Caffe models for age and gender prediction, with approximate reported accuracy of 71% for gender and 62% for age in the project context.
Tuned confidence thresholds and padding around detected face regions to improve prediction stability.
Rendered bounding boxes and prediction labels directly on the video stream for immediate visual feedback.

Tags: Python, OpenCV, DNN, Caffe, Face Detection, Real-Time Processing, Computer Vision

Link: https://github.com/KushagraBharti/Gender-Age-Detection

Thumbnail: /portfolio/projects/age-gender-recognition.png

DataDrive: Unified Insights for Data & Fuel Optimization

Summary: A full-stack ML analytics dashboard for exploring Toyota vehicle data, fuel-efficiency predictions, clustering, and interactive visualizations.

Highlights:

Built a Flask + React analytics dashboard over Toyota vehicle data, combining model-backed predictions with interactive exploration.
Implemented regression and K-Means clustering pipelines for fuel-efficiency and vehicle-segmentation analysis.
Built backend API endpoints for prediction, car detail retrieval, and clustering results.
Added data cleaning, feature engineering, and model evaluation workflows to keep the ML layer reproducible.
Built interactive React/D3 visualizations and a 3D car viewer to make the model outputs easier to explore.
Integrated GPT-powered explanation generation and Pinata storage as experimental transparency/auditability features.

Tags: Flask, Python, Machine Learning, Linear Regression, KMeans, React, D3.js, Three.js, Data Analytics, APScheduler, SHAP, OpenAI, Pinata

Link: https://github.com/KushagraBharti/HACKUTD-Data-Drive

Thumbnail: /portfolio/projects/data-drive.png

CircuitSeer (Circuit Solver)

Summary: A computer vision circuit-analysis tool that detects components, traces wiring, and helps solve simple circuit diagrams.

Highlights:

Built CircuitSeer through the AI Mentorship Program at UT Dallas as a team project combining object detection and classical computer vision.
Focused on component recognition using a fine-tuned YOLOv5 model to detect resistors, capacitors, diodes, inductors, and power sources.
Integrated line-detection work using Canny Edge Detection and Hough Transform to help trace wiring between detected components.
Connected the detection outputs to downstream logic for simple series/parallel resistance and capacitance analysis.
Built the project with Python and Flask so users could upload circuit diagrams and receive structured analysis through a web interface.

Tags: Python, YOLOv5, Flask, OpenCV, Computer Vision, Object Detection, Canny Edge Detection, Hough Transform, Circuit Analysis

Link: https://github.com/Hteam121/circuit-seer

Thumbnail: /portfolio/projects/circuit-seer.png

Point Cloud Down Sampler

Summary: A point-cloud processing project comparing a from-scratch voxel downsampler with Open3D’s built-in voxel grid method.

Highlights:

Implemented a custom voxelization algorithm that groups 3D points into discrete grid cells using mathematical flooring.
Reduced dense point clouds while preserving overall shape structure for downstream visualization and analysis.
Compared the custom implementation against Open3D’s high-performance `voxel_down_sample` method.
Built an end-to-end pipeline to load CSV point clouds, convert them into PCD format, downsample them, and export processed outputs for visualization and analysis.
Used the project to understand the tradeoff between writing geometry code from scratch and relying on optimized library primitives.

Tags: Python, Pandas, Open3D, Voxelization, Point Cloud, Downsampling, 3D Data, Geometry

Link: N/A

Thumbnail: /portfolio/projects/point-cloud-down-sampler.png

PCB Design Project

Summary: A hardware project where I designed, ordered, assembled, and tested custom PCBs as part of a senior independent project.

Highlights:

Designed multiple PCBs in EasyEDA, moving from schematic capture to board layout and manufacturing files.
Managed board and component procurement through JLCPCB/LCSC while optimizing for cost, availability, package type, assembly, and manufacturability.
Worked through design challenges involving ATmega328 variants, SMD/THT parts, capacitive-touch buttons, power routing, and component placement.
Assembled and tested the boards after delivery, gaining hands-on soldering, debugging, and hardware bring-up experience.

Tags: PCB Design, Circuit Design, EasyEDA, JLCPCB, LCSC, Electronics, Hardware, Soldering, Embedded Systems

Link: https://drive.google.com/drive/folders/1Zpps2I5CSq7O7xIUTwsn9uJrs2zYMwTK?usp=sharing

Thumbnail: /portfolio/projects/pcb-design-project.png

Self-Driving Car Project

Summary: An Arduino-based RC car rebuild with ultrasonic sensors and a custom obstacle-avoidance control loop.

Highlights:

Repurposed an RC car by rebuilding its internals with an Arduino Uno, motor shield, ultrasonic sensors, and custom wiring.
Wrote C++ control logic to read ultrasonic distance data and perform obstacle detection/avoidance.
Learned the hardware/software debugging loop: wiring, sensor noise, motor control, soldering, and physical-world failure cases.

Tags: Arduino, C++, Self-Driving, Autonomous Vehicle, RC Car, Electronics, Ultrasonic Sensors, Hardware

Link: https://drive.google.com/drive/folders/1Ma02iYvhobL4ckcy6yOPA300WvIpOeDD?usp=sharing

Thumbnail: /portfolio/projects/self-driving-car-project.png

Maze Traversal

Summary: A recursive depth-first-search maze solver in Python that finds and visualizes a complete path through grid-based mazes.

Highlights:

Implemented a recursive depth-first search solver for mazes represented as nested lists.
Marked the solution path with directional arrows to visually trace movement from start to exit.
Added file loading, start-position detection, intermediate maze printing, and execution-time measurement.
Demonstrated recursion, backtracking, grid traversal, path reconstruction, and algorithm visualization in a compact solver.

Tags: Python, Depth-First Search, Recursion, Maze Solving, Backtracking, Algorithms

Link: N/A

Thumbnail: /portfolio/projects/maze-traversal.png

Film and Creative Work

Section Summary: Stories and taste make us human, and I enjoy telling them through the lens.

Filmmaking Profile:

A film I made was screened at AMC Theatres in Times Square!
I love filmmaking, have directed 2 short films, and have contributed to other productions as a videographer and editor.
Film Portfolio: https://drive.google.com/file/d/1m3aFLAK4TE29ybbdOzObLS8zrrX3oJwM/view?usp=sharing

01 St. Stephen's Dining Hall Documentary

Slug: st-stephens-dining-hall-documentary

Title: St. Stephen's Dining Hall Documentary

Short Title: Dining Hall Documentary

Subtitle: 2022

Year: 2022

Genre: Documentary

Duration: 10 min

Summary: A documentary on the dining hall staff and the people behind the daily experience.

Description: A documentary following the St. Stephen's dining hall staff from the start of their day to the end, combining observational footage, intimate interviews, and a close look at the full dining hall experience.

Roles: Director, Cinematographer, Editor

Recognition / Notes:

Nominated for The All-American High School Film Festival 2023.
Screened at AMC Theatres in New York City.

Type: video

Platform: youtube

Watch URL: https://youtu.be/WM6RvRfDCX4

Embed URL: https://www.youtube-nocookie.com/embed/WM6RvRfDCX4

Actions:

Watch: https://youtu.be/WM6RvRfDCX4
Festival Selection: https://www.hsfilmfest.com/2023-official-selections

02 The PB&J Documentary

Slug: the-pbj-documentary

Title: The PB&J Documentary

Short Title: The PB&J Documentary

Subtitle: 2023

Year: 2023

Genre: Documentary

Duration: 19 min

Summary: A comedic documentary about obsession, mentorship, and the perfect PB&J sandwich.

Description: A comedic documentary following Liam and Edison as they chase the perfect PB&J through restaurants, roadside discoveries, and a boutique in San Antonio before the whole mentor-protege dynamic starts to unravel.

Roles: Director, Cinematographer, Editor

Recognition / Notes: N/A

Type: video

Platform: youtube

Watch URL: https://youtu.be/FS8l8G2p7PM

Embed URL: https://www.youtube-nocookie.com/embed/FS8l8G2p7PM

Actions:

Watch: https://youtu.be/FS8l8G2p7PM

03 RTMS Semesterly Recap

Slug: rtms-recap

Title: RTMS Semesterly Recap

Short Title: RTMS Semesterly Recap

Subtitle: 2018

Year: 2018

Genre: Recap

Duration: 3 min

Summary: A semester photo montage focused on rhythm, pacing, and raw editing craft.

Description: A semesterly recap film from Ras Tanura Middle School built as a photo montage. It has no traditional narrative, but it highlights editing instincts, visual sequencing, and the ability to build momentum through rhythm alone.

Roles: Editor, Photographer, Story Builder

Recognition / Notes: N/A

Type: video

Platform: drive

Watch URL: https://drive.google.com/file/d/1az0x6mwBzTXJEPBC7zhBQk9_DGO_8GwN/view?usp=sharing

Embed URL: https://drive.google.com/file/d/1az0x6mwBzTXJEPBC7zhBQk9_DGO_8GwN/preview

Actions:

Watch: https://drive.google.com/file/d/1az0x6mwBzTXJEPBC7zhBQk9_DGO_8GwN/view?usp=sharing

Optional

[Structured portfolio JSON](https://www.kushagrabharti.com/portfolio.json): Static structured portfolio snapshot.
[Live public portfolio API](https://www.kushagrabharti.com/api/portfolio): Backend-owned public portfolio snapshot.
[Live public API llms.txt](https://www.kushagrabharti.com/api/portfolio/llms.txt): Runtime-generated plain-text profile.
[Robots policy](https://www.kushagrabharti.com/robots.txt): Crawler permissions for the public portfolio surface.
[Sitemap](https://www.kushagrabharti.com/sitemap.xml): Indexable public portfolio URLs.
[Build metadata](https://www.kushagrabharti.com/version.json): Static export generation metadata and canonical export URLs.