Canonical AI-readable portfolio page.
Kushagra Bharti
Student | Software Engineer | ML Enthusiast
I am a student and software builder who enjoys learning and expanding my skillset.
Canonical site: https://www.kushagrabharti.com
AI page: https://www.kushagrabharti.com/ai
Plain text: https://www.kushagrabharti.com/llms.txt
Structured JSON: https://www.kushagrabharti.com/portfolio.json
Public API snapshot: https://www.kushagrabharti.com/api/portfolio
Robots: https://www.kushagrabharti.com/robots.txt
Sitemap: https://www.kushagrabharti.com/sitemap.xml
Snapshot source: generated static export
Snapshot generated: generated at build time
Intro
builder. researcher. filmmaker. tinkerer.
I enjoy building software at the intersection of AI, data, and real-world impact.
Latest update: Currently applying for Summer 2026 internships
Fun fact: A film I made was screened at AMC Theatres in Times Square!
Featured read: The Trillion Dollar AI Software Development Stack
Travel plans: Visiting Home for summer break!
Socials and Links
Primary socials from the public homepage
- Email: kbharti.work@gmail.com
- LinkedIn: /in/kushagra-bharti
- GitHub: /kushagrabharti
- X: /IamKushagraB
- Medium: /@kushagrabharti
Other public links
About Me
I build systems that make complex behavior easier to see, test, and improve.
Curious by nature. Driven by impact. Always learning.
Hey there! I'm Kushagra Bharti
Hey, I'm Kushagra, and I study computer science and spend the rest of my time building: AI agents, RL environments, trading algorithms, short films, and much more. Ultimately, I am obsessed with learning, and love challenging myself.
Values
- curiosity
- craft
- impact
- integrity
Current projects
- Monopoly Bench - A platform where various LLMs can play Monopoly against each other; I plan to publish a paper connected to this work.
- A light-weight web crawler in Go - A project I am using to learn Go, concurrency, networking performance, and resource management.
- An open-source T3.chat app - A project I am using to sharpen my web development skills, try creative chat UX ideas, and eventually integrate my web crawler as a tool.
Current learning
- Go, especially concurrency.
- WebSockets and real-time applications.
- Machine learning fundamentals.
- LLMs, including tool-calling and context management.
- Networking performance.
- Resource management.
- Data management.
Interests outside technology
- I love cooking and have been cooking since I was five years old.
- I love filmmaking, have directed 2 short films, and have contributed to other productions as a videographer and editor.
- I love sports, especially soccer, volleyball, tennis, and table tennis, and I also follow soccer, Formula 1, and the UFC.
- I am interested in psychology, reading, and the arts.
Values, Beliefs, Writings, Thoughts, and Predictions
learning
Category: value
Why I look for something harder once a thing gets easy.
# 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.
agency
Category: belief
Why I ship unfinished work and let reality correct it.
# 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.
taste
Category: thought
What editing films taught me about taste in software.
# Taste
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.
predictions
Category: prediction
Agents replacing apps, cheap failure, and being left alone as a luxury.
# 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.
Experiences
Places, teams, and problems that shaped how I build.
Software Engineer at Corgi
Date range: Jul 2026 - Aug 2026
Category: Industry
Status: past
Architected and launched Corgi's first commercial insurance broker platform, unifying onboarding, underwriting, payments, servicing, and commissions to open a new revenue channel. Built a production AI agent combining company knowledge, persistent memory, and custom tools for broker and sales automation.
- Architected and shipped the commercial insurance broker platform across React, TypeScript, and Django, bringing broker onboarding, appointments, applications, quoting, checkout, policy servicing, and commissions into one production product.
- Owned the broker product's frontend architecture, Django APIs, transactional data model, asynchronous workers, integration contracts, production runtime configuration, and operational rollout, carrying the system from initial design through release, direct broker onboarding, and live usage.
- Opened Corgi's first broker distribution channel, enabling brokers to sell its commercial insurance through the platform. The channel generated $60K in revenue within its first 10 days in production and subsequently exceeded $110K.
- Designed the integration with Startup Line, Corgi's existing underwriting and quoting system of record, giving brokers a dedicated distribution and servicing layer while maintaining explicit ownership of application, pricing, payment, and policy state across independently deployed services.
- Modeled the insurance lifecycle as cross-service state machines spanning revisioned applications, quote selection, checkout, policy issuance, servicing, broker appointments, and commissions, with auditable transitions and explicit rules for which operations could proceed in each state.
- Established OpenAPI contracts, immutable application snapshots, authoritative pricing revisions, and durable idempotency records with request-hash validation, preserving the relationship between submitted application data, payable quotes, and retried provider operations.
- Designed recovery for ambiguous transaction outcomes using persisted operation intent, stable provider retry keys, and explicit failure classification, distinguishing a safe retry from a request that might already have produced an external effect.
- Built atomic broker ownership claims and recoverable cross-service transfers using canonical insured identifiers, row locks, persistent transfer state, and payment fencing, preserving transaction authority and commission attribution during concurrent claims and reassignment.
- Integrated provider settlement data with broker commission accounting, using historical owner/rate snapshots, deterministic settlement-event identities, and locked target reconciliation to apply accruals and reversals without duplicating earnings during repeated synchronization.
- Separated synchronous broker requests from asynchronous quoting, document generation, notifications, synchronization, and reconciliation, keeping customer interactions responsive while longer-running insurance operations progressed through background workers.
- Implemented HMAC-signed underwriting and payment events, durable delivery records, retry backoff, dead-letter handling, and Celery reconciliation. Workers refreshed authoritative provider state to reconcile delayed, duplicated, or reordered events into the broker workflow.
- Containerized Django services and asynchronous workers with Docker and shipped broker integrations through Amazon ECR and Terraform-managed AWS ECS, using independently scalable web and worker workloads, autoscaling, health-checked rollouts, and blue-green release infrastructure to keep quoting and checkout available during deployments.
- Configured integration runtimes and rollout gates around immutable container images, service health checks, traffic shifting, automatic rollback, and queue isolation, supporting production releases and recovery across broker APIs and independently scaled background workers as usage grew.
- Ran transactional workflows on PostgreSQL/Aurora and background processing through Redis-backed Celery queues, separating latency-sensitive broker traffic from document, notification, synchronization, and reconciliation workloads.
- Built a custom Claude agent runtime that continuously processes broker activity across email, Slack, Telegram, and manual entry, allowing automation to operate within the communication channels brokers and internal sales teams already use.
- Grounded the agent in company-wide knowledge through RAG and AWS-hosted vector retrieval, exposing quoting, policy, CRM, appointment, and follow-up operations through custom MCP tools so it could retrieve context and execute broker workflows.
- Designed automatic triggers for inbound and internal activity, persistent memory across deals and conversations, tool-level execution controls, and human approval for external actions, allowing brokers to approve, reject, or revise outbound communication before execution.
- Automated the follow-up lifecycle: detected unanswered threads and aging opportunities, selected the next action, drafted follow-ups, updated operational state, alerted the responsible broker, and queued outbound communication for review before a deal became stale.
- Launched the agent with five brokers across four communication channels, saving approximately 25 hours per week across brokers and internal sales staff, reducing stalled conversations by roughly 40%, and helping protect an estimated $100K in monthly premium pipeline through timely follow-up.
- Coordinated live insurance workflows, independently deployed services, asynchronous jobs, and agent-initiated actions around consistent operational state, 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
Undergraduate Researcher at UT Dallas, CAIR Lab
Date range: Nov 2025 - Present
Category: Research
Status: active
Built MonopolyBench to investigate economic capability and alignment in interacting LLM agents, including capital allocation, negotiation, risk management, deception, and collusion. Developed economic environments, agent harnesses, and trajectory-generation infrastructure for evaluation and RL/post-training research.
- Created MonopolyBench at UT Dallas's Comets in AI Research lab to investigate how LLM agents act in a persistent economy. The research combines economic decision-making and multi-agent alignment with the infrastructure needed to generate long-horizon agent trajectories.
- Led development of the economic simulation, agent harnesses, evaluation infrastructure, and research artifact pipeline. Agents plan, bid, negotiate, allocate capital, manage risk and liquidity, recover from mistakes, and adapt to strategic opponents across complete games.
- Analyzed how bargaining, asset consolidation, development, rent generation, and liquidity decisions compound into advantage or insolvency. Linked economic outcomes to the interactions that produced them rather than reducing capability to a final win label.
- Studied cooperation, deception, persuasion, collusion, bias, risk preference, and strategic consistency through public negotiation, model-authored private analysis, and observed actions. Kept economic performance and trustworthy behavior as separate research dimensions.
- Built economic environments and agent rollout pipelines for RL/post-training research, generating multi-step tool-use trajectories that connect observations and interaction history to selected actions, state transitions, and economic outcomes.
- Extracted reusable decision tasks from recorded trajectories, preserving the original prompts, tool schemas, action history, and reconstructed state. This supports failure-focused evaluation, targeted data synthesis, and post-training dataset construction.
- Designed 130 frozen-state scenarios spanning trades, auctions, purchases, building, jail, liquidity pressure, and liquidation. Paired these controlled probes with full-game campaigns to study how local decisions develop into long-horizon strategy.
- Captured 10,685 agent decisions across 28 complete games (112 full-game trajectories), about 60M model tokens and 77,000 replayable events, producing a corpus for model comparison, behavioral verification, failure analysis, targeted data synthesis, and post-training research.
- Engineered the authoritative Python rules engine as the sole state mutator and exposed legal decisions through schema-constrained tools. Models retain strategic freedom while ownership, cash, development, and solvency constraints remain enforced by the environment.
- Built the multi-agent harness to assemble public state, private memory, conversation history, and legal tools, validate the selected action, supply concrete errors for a corrective retry, and record a deterministic fallback if recovery fails.
- Recorded every prompt, raw response, tool call, validation error, retry, fallback, event, state snapshot, communication, token count, and cost. These records let researchers distinguish strategic errors from tool-use failures, provider problems, and harness interventions.
- Implemented deterministic state reconstruction and artifact replay checks to verify benchmark operation and diagnose divergence. Preserved the distinction between reproducing recorded environment transitions and regenerating stochastic model behavior.
- Designed fixed-seed cohorts, deterministic baselines, roster controls, and Latin-square seat rotation for controlled comparisons. Built model cards, scenario breakdowns, validity and recovery profiles, statistical summaries, and cost reports from campaign artifacts.
- Implemented FastAPI and WebSocket observation with a render-only React interface so researchers can inspect games, decisions, messages, and transitions live while the Python engine retains authority over the simulation.
- Tracked provider-reported OpenRouter usage and generation costs per decision and campaign, connecting behavioral reliability and experimental coverage with inference economics.
- Developed the work around two complementary contributions: an economic capability and alignment research benchmark, and reusable environment and trajectory infrastructure for agent evaluation and post-training research.
Tags: Multi-Agent Systems, Economic Capability, AI Alignment, RL & Post-Training, Agent Trajectories, Agent Harnesses, Capital Allocation, Collusion, Auctions, Scenario Extraction, LLM Evaluation, 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
Software Engineer Intern at Glydr.gg
Date range: Jan 2026 - May 2026
Category: Industry
Status: past
Built and launched Glydr's community marketplace for gaming and productivity keybind profiles. Engineered the full stack, immutable versioning, and secure desktop imports to connect profile discovery and publishing with the company's foot controllers. This was done through Consult your Community.
- Led engineering and product direction for Glydr.gg through Consult Your Community, taking a customer-facing configuration hub from design to production for more than 2,000 active users of the company's gaming and productivity foot controllers.
- Built the marketplace with TypeScript, React, Vite, Fastify, PostgreSQL, and Drizzle, replacing manual controller and game configuration handoffs with searchable discovery, publishing, and versioned keybind-profile workflows.
- Deployed independently operated frontend, API, worker, and database services on Railway, with automated migrations and CI/CD supporting repeatable production releases across the application.
- Designed the relational model for users, Steam identities, sessions, games, categories, configurations, immutable versions, imports, handoff tokens, jobs, and audit events, connecting customer actions to the exact configuration and delivery state behind them.
- Engineered cross-client imports through REST APIs, short-lived hashed token handoffs, checksum-addressed payload versions, fetch limits, validation, and deduplication so desktop Control Panel clients receive the exact profile a customer selected.
- Made configuration versions immutable and checksum-addressed, allowing imports to resolve a reproducible payload and suppress duplicates even as publishers release newer revisions.
- Coordinated API and Control Panel state through bounded handoff tokens and background jobs, maintaining an explicit trust boundary between public marketplace requests 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 and import experience.
- Built customer and administrative surfaces for game and category navigation, official publishing, private uploads, version history, import state, and auditability, giving Glydr operational control over profile distribution.
- Delivered one-click configuration discovery and desktop imports to more than 2,000 external users, turning community profile sharing into a production publishing, versioning, and distribution platform for the hardware ecosystem.
Tags: Product Engineering, API Design, TypeScript, React, PostgreSQL, Vite, Fastify, Drizzle ORM, Railway, Microservices, REST APIs, Distributed Configuration, Steam OpenID, Authentication, Versioned Data, CI/CD, 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, 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
Status: past
Built a computer vision pipeline for behavioral neuroscience, from model fine-tuning to validated behavior scoring. Turned noisy lab footage into stable pose tracks, interpretable measurements, and reproducible research outputs with explicit quality controls.
- Engineered markerless pose-estimation and behavioral-analysis workflows for the Tsai Lab's three-chamber mouse experiments, supporting research into social interaction and experimental phenotypes.
- Hand-annotated domain footage and fine-tuned the DeepLabCut/SuperAnimal model stack for the lab's camera geometry, chamber layout, animal appearance, and occlusion patterns, adapting the model to the conditions of the actual experiments.
- Built the complete analysis pipeline from raw video 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 data, and researcher-facing outputs, keeping derived scores traceable to source 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 for discrimination index, ambiguous contact, interpolation boundaries, chamber occupancy, body-length anomalies, and low-confidence summaries, aligning computed measurements with the lab's experimental definitions.
- Added trial-level quality signals for occlusion, implausible body geometry, low-confidence intervals, and interpolation coverage so researchers could assess uncertainty alongside each behavioral result.
- Delivered a reproducible research workflow that converts raw pose outputs into uncertainty-aware tracks, interpretable behavioral summaries, and review-ready scorecards, connecting model performance to measurements the lab could inspect and use.
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
Peer Advisor at UT Dallas
Date range: Jan 2026 - Jul 2026
Category: Leadership
Status: past
Supported UT Dallas residential life through student guidance, crisis response, conflict resolution, and community programming.
- Advised residents on academic, personal, housing, and community concerns, connecting them with specialized campus resources and coordinating support with Residential Life.
- Handled on-call duties, policy concerns, roommate conflicts, incident reporting, and emergency escalation in coordination with professional staff.
- Built a supportive residential community through individual conversations, resident meetings, and programs that helped students navigate campus life.
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
Undergraduate Research Assistant at UT Dallas
Date range: Apr 2025 - Nov 2025
Category: Research
Status: past
Built exact optimization solvers and a research data pipeline for learning drone coverage plans, producing verified training targets and controlled tests of generalization.
- Implemented four paper-faithful greedy and dynamic-programming solvers for one-dimensional drone coverage, reconstructing exact executable plans alongside objective values.
- Built a pipeline from generated optimization instances to gold plans, feasibility checks, ML features, JSONL datasets, and quality-control reports for supervised and reinforcement-learning experiments.
- Configured 67,000 instances across training, in-distribution test, shifted, extrapolation, and stress splits to study generalization beyond the training distribution.
- Verified labeling throughput of approximately 136 instances/second: a representative run solved 370 instances in 2.71 seconds. Benchmarked the full dynamic program through 4,096-segment cases to establish practical scaling limits for exact supervision.
- Validated reconstructed plans against feasibility and coverage constraints and cross-checked solver families on shared oracle instances, ensuring labels contained executable solutions.
- Exposed gold labelers, legality masks, candidate metadata, and featurization hooks for supervised learning, graph neural networks, 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
Software Engineering Intern at Abilitie
Date range: May 2024 - Aug 2024
Category: Industry
Status: past
Delivered full-stack systems for Abilitie AI Cases, bringing enterprise role-play training from model responses into an interactive product. Led open-source model fine-tuning and engineered the inference, observability, and response-generation systems behind its quality, speed, and cost improvements.
- Delivered full-stack systems for Abilitie AI Cases within a product engineering team, spanning React/TypeScript chat, scenario, streaming, and completion flows alongside backend model orchestration across 27 enterprise role-play configurations.
- Converted streamed Azure and AWS model output into validated application state through JSON Schema-driven UI, connecting conversational responses to deterministic product behavior across configurations with different models, system prompts, and scenario prompts.
- Owned the end-to-end Llama 3.1 LoRA fine-tuning pipeline on AWS SageMaker: acquired, cleaned, filtered, and formatted proprietary role-play conversations, scenario data, and structured-output targets, then trained and benchmarked models for domain fidelity and schema-following behavior.
- Developed an evaluation rubric with the product team covering speed, reliability, and conversational quality, using it to assess fine-tuned models and the role-play experience.
- Productionized the fine-tuned model as an available inference path while retaining provider flexibility for the primary customer experience. Evaluated fine-tuning and self-hosting options as part of the product's model strategy.
- Built model and provider abstractions across Azure and AWS, allowing product flows to route among production models while preserving a shared streaming and structured-output contract.
- Replaced brittle free-form responses with schema-constrained JSON that could be validated, rendered deterministically, and retried only when required, making model output usable by the application's UI and state transitions.
- Reduced LLM cost per conversation by 70% through model migration, prompt compression, structured outputs, and retry reduction, optimizing the complete conversation workload across multiple cost drivers.
- Compressed prompts by approximately 20% and reduced schema-related retries by roughly 8%, improving inference economics while retaining 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/provider metadata, and per-request traces.
- Instrumented the complete request path to distinguish provider latency, first-token latency, generation duration, token throughput, retry behavior, and application errors across models and scenarios.
- Implemented speculative response generation during three-second typing pauses, prefetching model output before send and invalidating stale responses when the user continued typing. Used telemetry to tune this path, reaching approximately 0.5-second p95 time to first token after send.
- Tested and hardened the product against prompt injection, malformed output, stale generations, and scenario-breaking responses, evaluating role-play realism alongside latency, cost, reliability, and model quality.
Tags: LLM Product Engineering, Model Fine-Tuning, AWS SageMaker, 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, Llama 3.1, LoRA
Dorm Proctor at St. Stephen's Episcopal School
Date range: Aug 2021 - May 2022
Category: Leadership
Status: past
Supported a boarding-school community through peer mentorship, residential leadership, conflict resolution, and emergency preparedness.
- Helped new students adapt to boarding-school routines, expectations, and life away from home; served as a trusted peer for academic, personal, and social concerns.
- Coordinated with dorm parents, staff, counselors, and administrators to connect students with support while preserving discretion and continuity of care.
- Completed safety and emergency-response training and supported an inclusive, welcoming, and accountable residential environment through clear communication, conflict mediation, and dependable follow-through.
- Balanced mentorship, daily residential operations, academic responsibilities, and community expectations through consistent presence and trusted peer leadership.
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
Projects
Software (and some hardware) I have designed, built, and shipped.
MonopolyBench
A multi-agent economic benchmark for testing how LLMs allocate capital, negotiate, manage risk, and behave under competitive incentives. Pairs long-horizon agent environments with trajectory generation and reusable decision tasks for RL and post-training research.
- Created MonopolyBench to study economic capability and alignment in a persistent multi-agent economy. Four frontier LLM agents make interdependent decisions about capital allocation, bidding, negotiation, property development, liquidity, and survival while adapting to strategic counterparties.
- Examined how local decisions accumulate into sustained advantage or insolvency. Full-game analysis follows asset acquisition, portfolio consolidation, recurring rent, cash reserves, leverage through mortgages, and recovery under liquidity pressure across long horizons.
- Traced bargaining mechanisms that terminal win rates conceal: fragmented ownership becoming developed rent-generating portfolios, exchanges of strategically valuable properties for liquidity, scarce housing constraining development, and creditor transfers compounding advantage after bankruptcy.
- Studied economic performance and trustworthy behavior as separate dimensions. Public negotiation and model-authored private analysis support investigation of cooperation, persuasion, deception, collusion, bias, commitments, and consistency between stated plans and subsequent actions.
- Connected negotiation activity to realized outcomes rather than treating more messages or more trades as stronger agency. Examined when proposals produce useful exchanges, when capital is tied up without productive development, and how risk-taking changes solvency as opponents' portfolios evolve.
- Built economic simulation and agent rollout infrastructure for generating long-horizon trajectories relevant to RL and post-training research. Each episode connects the information available to an agent, its tool choices, the actions actually applied, and their subsequent economic consequences.
- Converted recorded interactions into reusable decision tasks with original prompts, ordered tool schemas, interaction history, selected actions, and reconstructed state. These tasks support targeted evaluation, failure-focused data synthesis, and post-training dataset construction.
- Designed 130 controlled frozen-state scenarios covering trades, auctions, purchases, building, jail, liquidity pressure, and liquidation. Combined these local decision probes with full-game campaigns to investigate how individual capabilities transfer into sustained economic behavior.
- Captured 10,685 agent decisions across 28 complete games (112 full-game trajectories), about 60M model tokens and 77,000 replayable events, building a corpus for behavioral verification, model comparison, failure analysis, targeted data synthesis, and post-training research.
- Structured the environment, rollout collection, scenario extraction, and outcome analysis as reusable research infrastructure. Full episodes preserve long-term consequences; extracted decision tasks isolate moments where planning, negotiation, tool use, or recovery succeeds or breaks down.
- Implemented the economic mechanisms behind the benchmark: a 40-space board, seeded dice and cards, rent schedules, ascending auctions, counter-offer trade threads, mortgages, even-build housing constraints, jail, liquidation, and bankruptcy cascades.
- Architected the Python rules engine as the sole authority over state and legal actions. Schema-constrained tools let agents choose economic strategies while the engine enforces budget, ownership, trading, development, and solvency rules.
- Built the agent harness around public state, private memory, conversation history, and the legal tools available at each decision. It validates returned tool calls, provides concrete errors for a corrective retry, and records a deterministic fallback when recovery fails.
- Separated an agent's strategic choice from execution reliability. Validation, retries, and fallbacks remain explicit so researchers can distinguish an economically weak policy from a tool-format failure, provider error, or harness intervention.
- Preserved prompts, raw responses, tool calls, validation failures, retries, fallbacks, communications, events, state snapshots, token counts, and costs. The trajectory pipeline links these records into the execution history behind each measured outcome.
- Implemented deterministic reconstruction of recorded game transitions and separate state and artifact replay checks. This validates the environment and identifies rules-engine defects, missing evidence, and provenance differences without assuming stochastic model outputs can be regenerated identically.
- Designed fixed-seed cohorts, deterministic baseline policies, controlled model rosters, and Latin-square seat rotation for comparative campaigns. These controls support analysis of model behavior, turn-order effects, and environment variance.
- Built batch reporting for leaderboard views, model research cards, scenario-category breakdowns, validity and recovery profiles, statistical summaries, and token and budget reports. Historical unbalanced games are used for mechanism studies rather than universal model rankings.
- Used provider-reported OpenRouter usage and generation records for decision-level cost accounting, connecting behavioral quality, reliability, latency, and inference economics to the same evaluation corpus.
- Exposed games, decisions, and conversations through FastAPI, WebSockets, and a render-only React spectator interface. Researchers can inspect a live run without moving simulation authority out of the Python engine.
- Developed complementary research directions around the benchmark as a reusable evaluation instrument and the economic capability and alignment behavior it reveals. The environment and trajectory work also provide a foundation for future RL and post-training experiments.
Tags: Multi-Agent Economics, AI Alignment, RL & Post-Training, Agent Harnesses, Agent Trajectories, Capital Allocation, Collusion, Risk Management, Auctions, Scenario Extraction, Outcome-Linked Datasets, LLM Evaluation, Multi-Agent Systems, Long-Horizon Planning, Agent Benchmarking, AI Agents, Tool Calling, 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
F1 Reinforcement Learning
A telemetry-calibrated Formula 1 physics simulator and GPU-accelerated learning system. Combines evolutionary controller search, behavior cloning, and reinforcement learning to develop racing policies, with CPU-verified trajectories and deterministic replay connecting simulation, training, and evaluation.
- Engineered a Formula 1 physics simulator from scratch around 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 for physics calibration and refinement, grounding speed profiles, braking behavior, and track-section dynamics in real driving data. Evolutionary search and the learned policy independently produced the reported lap times.
- Calibrated the simulated speed envelope, braking zones, acceleration profile, section timing, and track geometry against clean dry Monza telemetry across multiple seasons and drivers.
- 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 collisions, checkpoint and track-limit validation, surface-specific grip and drag, and simultaneous throttle-brake behavior to constrain policy optimization with vehicle geometry and driving rules.
- 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.
- Scaled CUDA-accelerated evolutionary search to 300,000 controller candidates, using elite preservation, mutation, crossover, and full-lap fitness to discover controllers that complete valid Monza laps.
- 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.
- Established a CPU verification gate for GPU search: promising controllers were reranked, replayed, and validated in the CPU simulator before their telemetry entered training datasets.
- Checked CPU-GPU parity using artifact-level reason codes, lap-validity comparisons, selected telemetry replay, and deterministic reranking, making validation an explicit requirement for promoting parallel-search results.
- Converted verified controller trajectories into state-action datasets and trained a behavior-cloned PyTorch policy to learn the braking, turn-in, throttle, and recovery behavior discovered by search.
- Bound every exported transition to its physics model, calibration identifier, observation profile, and action schema, preserving the simulator contract behind each training example.
- 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 to begin reinforcement learning with a competitive racing prior.
- 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 promoted learned policy completed a CPU-verified simulated Monza lap in 77.683 seconds, under the 79.327-second FastF1 reference from 2024 Italian Grand Prix qualifying.
- 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 throughout the artifact pipeline to prevent silent comparisons across incompatible simulator generations.
- Generated exact telemetry replays, rendered lap visualizations, policy comparisons, and large multi-trace racing swarms from evaluated artifacts, exposing controller behavior throughout the lap.
- 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.
- Connected calibrated vehicle dynamics, GPU search, CPU validation, trajectory distillation, and neural policy optimization through explicit artifact contracts, making each stage inspectable and its results reproducible.
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
IMC Prosperity 4 Quant Trading Competition
Placed top 6% worldwide among 18,803 teams in IMC Prosperity 4. Built market-making, options-pricing, and statistical-arbitrage strategies alongside a Rust/Python research system for fast backtesting, execution analysis, and validation across changing market regimes.
- Placed #1088 overall, in the top 6% worldwide among 18,803 teams across five rounds of algorithmic trading, market design, and manual optimization, competing as a two-person team with shared strategy and research work.
- Engineered inventory-aware fair-value market makers with top-of-book imbalance, reservation-price skew, selective liquidity taking, and drift/carry strategies for products with predictable expected-value movement 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.
- Implemented dynamic-programming hindsight oracles over inventory states to estimate each product's executable opportunity ceiling and diagnose whether performance was limited by signal quality or execution. Kept oracle outputs confined to research labels and diagnostics.
- Built a Python and Rust research system for historical replay, parallel simulation, strategy comparison, fill-sequence inspection, product and signal PnL attribution, drawdown analysis, and inventory-path review, using the Rust backtester to accelerate strategy iteration.
- Preserved exact official submission artifacts, result scorecards, candidate lineage, and round-scoped strategy packages, linking each promoted strategy to its research assumptions and official outcome.
- Diagnosed local-versus-official performance divergence from evaluation-window transfer, within-tick matching assumptions, passive-fill sensitivity, and serialized-state limits; added forced-cap replay and cross-engine validation to candidate promotion.
- 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.
- Required candidate strategies to pass portal-window replay, full-history replay, parallel Monte Carlo analysis, PnL attribution, drawdown, and transfer-risk review, rejecting gains that depended on favorable historical slices.
- Won the first manual round, combining puzzle analysis, capital allocation, and mechanism design with the algorithmic trading research.
- 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.
- Evaluated strategy robustness across changing products, noisy fills, incomplete feedback, hard state constraints, and adversarial regime shifts, connecting signal research to the conditions under which orders could actually execute.
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
Recursive Capital (2nd Place, AWS Agentic AI Hackathon)
Recursive multi-agent swarms that assemble autonomous quant teams to research markets, construct portfolios, and carry strategies through evaluation to Alpaca paper execution. Combines collaborative agent workspaces, adversarial review, continuous monitoring, and AWS-hosted orchestration.
- Won 2nd place at the Austin Agentic AI Hackathon with Recursive Capital, an AI-native investment platform built by a four-person team in the financial portfolio management track.
- Built recursive multi-agent orchestration that assembles a working investment team around a fund mandate. Agents divide market research, challenge investment theses, construct portfolios, evaluate strategies, and coordinate paper execution through a persistent collaborative workspace.
- Made the team structure dynamic: an orchestrator can create research specialists, strategy developers, adversarial reviewers, blind backtesters, executors, moderators, and further orchestrators as the work requires. Agents delegate to descendants, exchange evidence, and supervise the resulting research tree.
- Coordinated autonomous research-to-execution across dated evidence, investment memos, portfolio weights, independent challenges, walk-forward backtesting, final review, order planning, and broker reconciliation. Research becomes an executable strategy through an explicit workflow.
- Integrated financial statements, ratios, earnings, insider activity, ownership, filings, prices, screening, and news through Dexter's native finance tools. Added SEC evidence, Exa web research, X posts, FRED macroeconomic series, and bounded Apify web-data collection.
- Added sentiment analysis through Jev on OpenRouter, retaining source excerpts, URLs, publication metadata, class probabilities, and confidence. Connected those outputs to the same research process as financial fundamentals and macroeconomic evidence.
- Translated a client's goals into a fund mandate covering capital, horizon, risk tolerance, approved assets, position and sector limits, cash reserves, drawdown constraints, rebalance cadence, and execution permissions.
- Integrated strategy synthesis and portfolio construction around immutable target allocations, rationale, evidence, and change triggers. Strategy revisions receive new identities so a backtest or review remains attached to the exact investment decision it evaluated.
- Integrated the team's walk-forward backtesting engine with a blind evaluator that receives frozen numerical strategy inputs and dates. The backend computes performance and pass/fail results; the evaluator does not inherit the strategy author's research or live web access.
- Bound final adversarial review and execution checks to the current strategy, evaluation, and policy. The platform can send a strategy back for revision, surface a failed test, or proceed under the fund's configured trading authorization.
- Connected the workflow to Alpaca's live paper-trading API for account state, market information, order submission, and fill reconciliation. End-to-end hosted testing reached a confirmed broker fill, with paper execution kept distinct from historical simulation and real-money trading.
- Implemented stable client order IDs, persisted intent, request-hash checks, a shared broker lock, and read-only reconciliation of uncertain submissions. Retries inspect the original order rather than submitting a second trade with a new identity.
- Integrated a watchdog and moderator workflow that monitors positions, order activity, strategy evidence, and unresolved broker outcomes. Deterministic checks and an emergency stop enforce execution constraints alongside a model-based second opinion.
- Added a historical execution mode using the same walk-forward accounting and fill logic. A persisted replay clock, cash balance, holdings, fills, and equity ledger support fractional positions, slippage, volume limits, and next-session execution without sending historical orders to Alpaca.
- Gave agents persistent conversations and a fund research workspace for shared memos, data, strategy documents, and results. File access, tool permissions, and delegation boundaries let specialists collaborate while preserving the context and evidence behind their work.
- Built a live React/TypeScript canvas for inspecting the investment team: agent trees, parent-child links, conversations, progress, tool activity, files, model choices, branch controls, and shared canvas positions.
- Added collaborative access with authenticated accounts, fund memberships, invitations, and live updates. Different users can follow the same research tree, inspect its evidence, and see changes to agents and shared files.
- Engineered persistent swarm supervision around background delegation, bounded conversation and tool-result reads, progress reporting, cancellation, and waits that release worker capacity. Nested delegation can continue without a parent monopolizing the compute slot its children need.
- Added an opt-in hourly scheduler that resumes the same fund orchestrator with saved context, skips overlapping work, and respects pause, archive, and stop controls. Later research and execution cycles remain subject to the fund's current mandate and backend checks.
- Deployed React, FastAPI, and Bun workers running the Dexter agent loop in one Docker container on AWS EC2 behind CloudFront HTTPS. Used ECR images, encrypted EBS, Secrets Manager, IAM instance roles, and Systems Manager for hosting and operations.
- Ran main-agent inference and blind evaluation through Amazon Bedrock. Integrated Bedrock Guardrails for memo screening and fund-specific AgentCore Memory for watchdog feedback, with CloudWatch and EventBridge supporting monitoring and audit infrastructure.
- Worked with teammates across the core product, backtesting and analytics, synthesis and order planning, and watchdog infrastructure. The shared system connects recursive agent collaboration to a demonstrated research, evaluation, and paper-execution workflow.
Tags: Multi-Agent Systems, Quantitative Research, Agentic Trading, Recursive Agent Swarms, Autonomous Agents, Portfolio Construction, Strategy Development, Walk-Forward Backtesting, Agent Orchestration, Adversarial Review, Risk Management, Alpaca, Paper Trading, Agent Monitoring, Shared Agent Workspaces, Persistent Agent State, Research Infrastructure, Market Data, Sentiment Analysis, Financial Datasets, SEC Filings, FRED, Exa, Apify, Tool Calling, Amazon Bedrock, AgentCore Memory, Bedrock Guardrails, AWS EC2, CloudFront, Docker, Amazon ECR, IAM, Secrets Manager, CloudWatch, EventBridge, Python, FastAPI, TypeScript, React, Bun, Dexter, Idempotency, Order Reconciliation
Multiplayer
A social network for AI agents. People connect their ChatGPT Dots, Grok Bot, Codex, Claude Code, OpenClaw, Hermes and Muse agents, and those agents message each other and their friends' agents over MCP and REST while every person stays in their own native chat.
- Built Multiplayer, a service that lets a person's AI agents talk to each other and to their friends' agents. Each person connects one agent per platform (ChatGPT Dots, Grok Bot, Codex, Claude Code, OpenClaw and Hermes) alongside an existing Meta Muse integration, and native chat stays the human interface.
- Gave every agent the same 24 tools through the official MCP TypeScript SDK over Streamable HTTP and through REST, with WorkOS AuthKit for Google sign-in and WorkOS Connect for MCP OAuth with PKCE, dynamic client registration and resource audience validation.
- Measured delivery in production: across 15 smoke runs, a message reached the agent waiting for it in a median of 308 ms. Waits subscribe to Supabase Realtime before reading, so an update committed in between is never missed.
- Bound each validated OAuth client to exactly one agent slot per owner. A new client can bind only while the owner's one-hour pairing window is open, so a valid token from another of the owner's clients cannot claim an unpaired agent.
- Limited discovery to an explicit friendship graph: an agent can reach its owner's other agents and the enabled agents of direct friends. A send takes a shared lock on each cross-owner friendship and rechecks permission, so removing a friend either blocks the send or waits until the message is stored.
- Kept the server to coordination only. It runs no models of its own, every conversation holds exactly two agents with a hard 200-message budget, and the website transcript is read-only.
- Designed per-agent inboxes with cursors, exact acknowledgments and leased claims of up to 20 messages. Workers preserve native handoffs before acknowledging, and an acknowledgment can never clear newer arrivals or another agent's inbox.
- Implemented ChatGPT Dots event subscriptions for agent.message.created as Standard Webhooks, with signed callback challenges, public-address checks pinned through TLS, per-subscription ordering and bounded exponential retries.
- Added a durable dispatcher: pg_cron checks inside Postgres every 30 seconds and calls the app only when work is due or for a five-minute heartbeat. One pass runs at a time under a lease, and a job that runs out of time before its callback is sent keeps its attempt.
- Wrote native bridges for Grok Bot routines, the Codex App Server, a Claude Code channel, OpenClaw hooks and Hermes webhooks. They block while idle, so no agent is polled or woken on a timer.
- Stored everything in Supabase Postgres with row-level security on every table, parameterized SQL and transactional writes. Checksummed migrations run under a transaction lock after a successful production build on Vercel.
- Stress-tested against real PostgreSQL: 150 rounds of ten concurrent operations without deadlocks or duplicate receivers, plus registration races and concurrent recovery dispatchers. One real-database test reproduced a concurrent-start deadlock (40P01), fixed by taking agent locks in sorted order.
- Passed a live acceptance test in production: a real Muse on its native OAuth connection coordinated a group plan with three simulated participants, took a late-arrival update, revised its proposal after feedback and reached a confirmed agreement with no approval clicks after setup.
- Designed the landing page as a meadow where each platform's character can be dragged around, picked and heard, with a reply arriving from the agent it is talking to.
Tags: Multi-Agent Systems, Agent Networks, Agent Interoperability, MCP, OAuth, PKCE, Dynamic Client Registration, Webhooks, Standard Webhooks, Event Delivery, Durable Dispatch, Concurrency, Social Coordination, PostgreSQL, Row-Level Security, pg_cron, Supabase, WorkOS, Drizzle, Next.js, React, TypeScript, Python, Vercel, Docker, Vitest, Playwright, ChatGPT, Codex, Claude Code, Grok
Go Web Crawler
A high-throughput Go crawler combining breadth-first discovery with fair host scheduling, bounded concurrency, and fault isolation. Sustained roughly 147 pages per second on the public web while streaming extracted content and discovery paths into a live reading interface.
- Architected a Go crawler around bounded goroutine worker pools, channel-based scheduling, and a host-partitioned breadth-first frontier, separating URL discovery from resource-controlled fetch execution.
- Designed a scheduler with per-host FIFO queues and round-robin dispatch across domains, combining global and host-specific concurrency limits to prevent individual sites from monopolizing the crawl.
- Centralized dispatch policy through frontier-capacity, host-rate, circuit-breaker, global semaphore, host semaphore, and robots.txt gates before a request enters the fetch pool.
- 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, coordinating throughput with public-web crawl constraints.
- 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, with portable JSON artifacts for replay, debugging, and offline analysis.
- Represented each crawl as a rooted discovery tree with the exact parent edge that introduced every page, preserving provenance from the seed through the fetched dataset.
- 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 discovery tree, and exposes page content and crawl diagnostics during active runs.
- 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.
- Coordinated host fairness, backpressure, robots resolution, retry timing, circuit state, persistence, and cancellation in one scheduler, maintaining bounded execution as public-web hosts slow down, rate-limit, or fail.
Tags: Go, Concurrent Systems, BFS Frontier, Go Concurrency, Goroutines, Channels, Worker Pools, 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
AutoHDR ML Lens Correction
A neural lens-correction system that combines analytic camera geometry with learned residual flow. Engineered differentiable warping, staged GPU training, and geometric safety checks to preserve image structure, earning an honorable mention in the AutoHDR competition.
- Built a competition-grade lens-correction system from paired distorted and corrected images, combining analytic camera calibration with learned geometric refinement.
- Paired a Brown-Conrady distortion model with learned residual flow, constraining correction to an interpretable geometric transform while allowing localized departures from the analytic camera model.
- Designed a shared ResNet34 backbone trained from scratch on six-channel input including coordinate channels. Its parametric head predicts eight Brown-Conrady coefficients: three radial, two tangential, principal-point offsets, and scale, with tanh-bounded ranges and near-identity initialization. An FPN-style decoder predicts bounded two-channel residual flow at one-eighth resolution.
- Fused the parametric grid and residual delta into one differentiable grid_sample warp with backward mapping and border padding, retaining a single geometric correction throughout the inference path.
- Combined Charbonnier pixel, SSIM, edge-magnitude, line-orientation-histogram, and gradient-orientation losses with total-variation, magnitude, and curvature regularization. Penalized self-crossing warps through a Jacobian foldover term.
- Trained over 23,118 paired images in three stages: parametric calibration, hybrid learning, and fine-tuning for 8, 8, and 5 epochs. Used cosine learning rates from 2e-4 to 8e-5, mixed precision, native-resolution real pairs, and each previous stage's best checkpoint. Ran the first full campaign on a RunPod H100 80GB and the second on an H200.
- Validated output geometry through out-of-bounds ratio, border validity, Jacobian determinant, and residual-magnitude checks, routing deterministically among hybrid, parametric, and conservative corrections with complete mode telemetry.
- Completed deterministic full-batch inference on 1,000 hidden test images with 100% hybrid mode, zero unsafe triggers, and zero fallbacks; preserved mode counts and artifact lineage in run metadata.
- Built filename and image-integrity checks, a proxy scorer with hard-fail flags, a failure-rate build gate, and QA-gated submission packaging.
- Scored 0.8942 on the normalized leaderboard scale, equivalent to 89.42 on the displayed scale, earned an honorable mention, and received a follow-up call with the CTO about hiring the team.
- Assigned dominant global correction to the analytic parametric head and localized departures to the learned residual, preserving geometric interpretability across inference.
- Integrated analytic geometry, learned capacity, staged training, safety routing, and quality gates while keeping the warp differentiable, numerically stable, and reproducible through submission packaging.
- Validated geometry contracts, differentiable warping, loss behavior, training hooks, safety routing, inference artifact integrity, quality-control tools, and deterministic submission generation.
Tags: Computer Vision, PyTorch, Image Geometry, Deep Learning, Lens Distortion Correction, Brown-Conrady Model, ResNet34, grid_sample, Residual Flow, ResNet34 CNN, CNNs, Optical Flow, Warping, Model Training, Staged Training, Benchmarking, H200, H100, Reproducible Systems, Testing, QA Tooling, Competition Engineering
Link: https://github.com/KushagraBharti/AutoHDR-LensCorrection
Pact
Won 1st place in HackSMU's Solana Track with a mobile platform that turns commitments into financial stakes. Engineered peer validation, server-enforced lifecycle transitions, and token escrow to connect proof, majority voting, and settlement.
- Built a mobile accountability platform where goals become staked commitments inside private circles, peers validate proof, and outcomes determine whether stakes return or are forfeited. Won 1st place in the HackSMU Solana Track.
- Delivered the complete commitment lifecycle: circles with four-character invite codes and up to 24 members, pacts with deadlines and 1 to 1,000 DEMO_USDC stakes, escrow locking, photo proof, 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.
- Built nine mobile screens with React Native, Expo, Expo Router, and NativeWind: login, home, create, circle, invite, pact detail, proof submission, voting, and profile.
- Implemented majority resolution at floor(n/2)+1 votes, resolving a pact as soon as the result becomes mathematically decided. Kept best-effort escrow release or forfeiture separate from the state transition so settlement failures could not block resolution.
- Derived identity on every protected route from a verified Supabase token. Enforced membership on every read and write, restricted proof and voting to their valid lifecycle stages, and structurally excluded creators from validating their own pacts.
- Enforced one vote per validator, one proof per pact, and one membership per circle through unique database indexes, alongside CHECK constraints for status, stake range, and vote decisions.
- 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.
- Integrated mobile UX, backend lifecycle state, validator logic, proof artifacts, database constraints, and token escrow within the hackathon window, enforcing consequential transitions on the server.
Tags: Full-Stack Mobile, Solana, State Machines, React Native, Expo, TypeScript, Fastify, Supabase, PostgreSQL, SPL Token, On-Chain Escrow, Hackathon Winner, 1st Place, Server-Side Validation, Mobile Development, Supabase Auth, Supabase Storage, Expo Router, Web3, FinTech, Consumer Social, Product Engineering, System Design
Beyond Chat
A shared workspace for agents that research, execute, and deliver work using company knowledge. Combines durable orchestration, isolated code execution, persistent memory, and human approvals so teams can recover runs, review outputs, and automate repeatable workflows.
- Architected a project-centered agent workspace around reusable agents, connected company knowledge, and durable work products. 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 versioned capabilities, combining stable agent identities with project-specific knowledge, tools, memory, policy, and automation.
- Engineered a FastAPI control plane that persists run records before execution and manages ordered events, worker leases, budgets, checkpoints, cancellation, suspension, recovery, reconciliation, generated files, and human approvals.
- Coordinated execution through worker ownership and leases, preserved progress in checkpoints, reconciled orphaned runs, and replayed ordered events when streaming clients reconnected.
- Integrated the Pi agent runtime behind an application-server protocol and ran production work inside isolated Modal sandboxes, supporting tool calls, file creation, and code execution without a shared 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.
- Turned run results into durable documents and structured outputs with source-run provenance, generated files, version history, project association, review state, collaboration, and approval status.
- Applied the same provenance model to research, analysis, writing, and operational work, allowing 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.
- Enforced organization policy on model availability, tool and application access, knowledge visibility, execution budgets, and approval requirements as part of runtime execution.
- 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.
- Preserved context, permissions, execution evidence, outputs, and approval state beyond the originating session, making agent work reusable and reviewable across a company workflow.
- Coordinated asynchronous workers, sandbox boundaries, streaming clients, tool providers, organization authorization, recovery, and human review through explicit runtime contracts for durable agent execution.
Tags: AI Agents, Durable Execution, Workflow Orchestration, TypeScript, React, Python, FastAPI, Supabase Postgres, Supabase Storage, Supabase Realtime, Supabase, PostgreSQL, OpenRouter, Tool Calling, Durable Outputs, 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
Personal Site + Tracker
A digital museum of my engineering, research, writing, and film, paired with a private system for running my daily work. Combines calendar synchronization, durable task workflows, and an OAuth-secured MCP server that lets AI assistants act within explicit permissions.
- Built a public digital museum and a private productivity system in one repository: a portfolio for engineering, research, writing, and film, alongside a tracker with Google Calendar synchronization and an OAuth-secured MCP server for agent-operated task and calendar workflows.
- Separated the public portfolio and AI profile (/ and /ai), private tracker (/tracker), MCP OAuth consent (/oauth/consent), public and private APIs (/api and /api/private), Streamable HTTP MCP endpoint (/api/mcp), and OAuth resource metadata (/.well-known/oauth-protected-resource).
- Established backend TypeScript content as the source of truth for profile copy, about text, education, experience, 20 ordered projects, writings, film, and AI prompts, exposing a canonical snapshot through shared frontend and backend contracts.
- Generated ten artifacts from one snapshot: index.html prerendered from the real React homepage shell, ai.html, llms.txt, portfolio.json, version.json, robots.txt, sitemap.xml, and three bootstrap modules, keeping human-facing pages and agent-readable exports synchronized.
- Prerendered and hydrated the homepage through Vite, lazy-loaded /ai, /tracker, and /oauth/consent, self-hosted fonts with font-display optional, and preferred AVIF/WebP images with PNG fallback. Deferred the 3D hero and media-heavy enhancements until after first paint without skeleton placeholders.
- Designed section choreography with GSAP and ScrollTrigger, Lenis smooth scrolling restricted to fine-pointer motion-safe devices, and a shared ghost-to-ink scrubbed display type.
- Kept Supabase email/password authentication in the browser and private tracker data behind backend-owned APIs, resolving fresh access tokens before private requests and Realtime subscriptions.
- Built a tasks hub with counted sidebar lists, all-task and per-list views, open/completed sections, subtasks, notes, due dates, quick date actions, per-list sorting with drag reorder, and local hide-completed preferences.
- Modeled tasks with list links, same-list parent links, details, timezone-aware due timestamps, completion state, sibling order, and none/daily/weekly/biweekly/custom recurrence. Custom rules support an interval, day/week/month unit, and optional end bound.
- Defined explicit date semantics: date-only tasks normalize to 10 PM in the selected timezone, offsetless datetimes remain local to that timezone, and absolute ISO datetimes retain their instant. Completion creates the next recurring occurrence, with cron repair for missing open copies.
- Structured 14 Supabase tables under RLS: ten for tracker lists, tasks, sort preferences, sync settings, calendar connections with encrypted tokens separated from public rows, jobs, runs, and two event-link tables; four for MCP clients, audit logs, rate-limit events, and delete confirmations.
- Engineered a backend calendar job queue with seven job types, four lanes, three run modes, claim/complete/fail RPCs, dedupe keys, priorities, recovery of jobs running beyond ten minutes, and bounded drains for serverless execution.
- Implemented app-side reconciliation of due tasks in synced lists, Google-side reconciliation of tracker-owned events, and a rebuild mode for the dedicated Tracker Tasks calendar. Inbound deltas restore cancelled tracker-owned events without importing arbitrary calendar edits as tasks.
- Used deterministic Google event IDs, private extended metadata, timed/all-day events, [Done] titles for completed non-recurring tasks, [Upcoming] projections for recurring tasks, and validated webhooks with watch renewal.
- Broadcast small database invalidation events over private per-user Realtime topics; authenticated clients debounce signals and refetch canonical backend state.
- Exposed 12 MCP tools over Streamable HTTP with read, write, delete, and calendar-sync scopes: tracker snapshots, list/task lookup, active/completed listings, create/update/complete/uncomplete, manual calendar sync, and two-step deletion using a confirmation token bound to the exact task subtree.
- Validated MCP OAuth access through Supabase JWKS or an HS256 secret, with a pinned owner and per-client policy rows. Added a timing-safe development bearer fallback, origin/host allowlists, advisory-lock-backed sliding-window rate limits, and audit logging.
- Restricted assistant visibility to explicitly MCP-visible, non-archived lists, supported narrower client policies, and required exact list IDs or normalized names for writes.
- Kept tracker data out of public exports and frontend configuration limited to anon keys, with service-role JWT validation in the admin client, production CORS restricted to known aliases, RLS, and private Realtime topics.
- Deployed frontend and backend as separate Vercel projects, with four staggered daily jobs for calendar synchronization, recurring-task repair, Google watch renewal, and data retention cleanup within serverless limits.
- Connected static public content, authoritative private state, Supabase Auth/RLS/Realtime, Google Calendar side effects, serverless queues, and assistant-facing MCP tools through backend contracts and canonical-state refresh.
Tags: MCP, OAuth, Serverless Queues, TypeScript, Express, React, Supabase, Model Context Protocol, Google Calendar API, Supabase Realtime, 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, REST API, Private APIs, Full-Stack Development, API Integration, Authentication, Security Hardening, System Design, Testing
Link: no public link listed
NovelBench
A live research arena for evaluating how frontier models generate, critique, and improve creative ideas. Orchestrates anonymous multi-model review and judging, combining durable execution, Glicko ratings, and bias audits to make creativity evaluation inspectable and statistically qualified.
- Created a public benchmark where two to eight frontier models generate, anonymously critique, revise, and judge creative ideas through a structured multi-stage arena, exposing how ideas develop through feedback.
- Built a durable Convex workflow spanning generation, anonymous critique, an optional blocking human-critique checkpoint, revision, voting, and winner selection, with event-driven pause, resume, and cancellation.
- Coordinated per-model actions with bounded workpools, exponential retries, quorum-based completion, explicit terminal states, and scheduled reconciliation to sustain evaluation across restarts and provider variance.
- Anonymized models as A through H, excluded model names from prompts, and deterministically shuffled idea order per judge. Persisted presented order to support retrospective position-bias audits.
- Converted ballots into weighted pairwise comparisons for Glicko ratings and ranked conservatively by rating minus twice its deviation. Weighted judges from 0.8 to 1.2 by their own ratings and kept models provisional below eight pairwise matches.
- Audited self-preference, same-lab preference, first-position bias, judge influence concentration, weighted-versus-unweighted rank shifts, and coverage confidence alongside each leaderboard ordering.
- Modeled execution in about 30 Convex tables, separating compact run summaries and participant-stage state from typed append-only token, tool, failure, control, and reasoning events. Rebuilt leaderboard snapshots and daily statistics as read models.
- Integrated OpenRouter streaming, tool-calling turns, structured-output normalization, live token and reasoning events, and policy-gated Exa research with per-stage budgets during generation and revision.
- Stored bring-your-own OpenRouter keys AES-encrypted in a vault table, enforced organization model/spend policies, limited usage to 12 runs per hour and 100 per day, and maintained usage ledgers.
- Recorded 54 public benchmark runs, 231 generated ideas, 1,117 critiques, and 22 tracked frontier models, with the corpus expanding as evaluations complete.
- Built the public Next.js 16 and React 19 experience with a live arena, searchable archive, leaderboards, and detailed pages exposing every stage of each run.
- Integrated restart-safe multi-model execution with anonymity, ordered audit trails, normalized ballots, live reasoning events, and uncertainty-aware ratings, connecting research methodology to a public evaluation product.
Tags: LLM Evaluation, Bias Auditing, Glicko Ratings, AI Benchmarking, Multi-Model Evaluation, Convex, Next.js, TypeScript, React, OpenRouter, Workflow Orchestration, Structured Outputs, Anonymous Critique, Model Voting, Leaderboard Systems, Creative Evaluation, Evaluation Infrastructure, Realtime Systems, Exa, Prompt Engineering, Product Engineering, Research Infrastructure, Solo Project
PCB Design Project
Custom circuit boards taken from schematic design through manufacturing, assembly, testing, and hardware bring-up as a senior independent project.
- Designed multiple PCBs in EasyEDA from schematics through board layout and manufacturing files; procured boards and components through JLCPCB/LCSC with cost, availability, package type, assembly, and manufacturability constraints.
- Worked through ATmega328 variants, SMD/THT components, capacitive-touch buttons, power routing, and placement, then assembled, soldered, tested, and debugged the delivered boards.
Tags: PCB Design, Embedded Systems, Circuit Design, EasyEDA, JLCPCB, LCSC, Electronics, Hardware, Soldering
Link: https://drive.google.com/drive/folders/1Zpps2I5CSq7O7xIUTwsn9uJrs2zYMwTK?usp=sharing
CircuitSeer (Circuit Solver)
A circuit-analysis tool combining learned component detection with classical vision to trace wiring and analyze simple series/parallel diagrams through a web interface.
- Built CircuitSeer with a team through UT Dallas's AI Mentorship Program, combining object detection and classical computer vision.
- Focused on fine-tuning YOLOv5 to recognize resistors, capacitors, diodes, inductors, and power sources; integrated Canny Edge Detection and Hough Transform work to trace wiring.
- Connected detected components and wiring to simple series/parallel resistance and capacitance analysis, exposing diagram upload and structured results through Python and Flask.
Tags: Computer Vision, YOLOv5, Circuit Analysis, Python, Flask, OpenCV, Object Detection, Canny Edge Detection, Hough Transform
PseudoLawyer
A realtime negotiation platform combining on-demand AI mediation with structured contract drafting, carrying participant context from the first message to a downloadable agreement.
- Completed the platform solo from its original group-project foundation: two parties choose a structured JSON freelance agreement or NDA, invite a counterparty by email, negotiate in realtime, request mediation, and download a generated contract draft.
- Built with Next.js 15 App Router, React 19, Supabase Auth/Postgres/Realtime, and Claude 3.5 Sonnet through OpenRouter and the OpenAI SDK, with a Tailwind and Framer Motion dark UI.
- Modeled six tables: profiles, templates, negotiations, participants, messages, and contracts. Provisioned profiles through a signup trigger; used cookie-based SSR authentication, middleware session refresh, guarded routes, and preserved login redirect targets.
- Re-fetched each Supabase postgres_changes message with its joined sender profile before rendering to preserve participant identity and ordering during concurrent updates.
- Designed Sudo as a neutral third participant using structured JSON containing per-turn sender/role, the latest message, and contract context. Seven invocation phrases and an explicit ask button keep mediation on demand.
- Tuned mediation to temperature 0.75, 600 maximum tokens, and the last 20 messages; drafting uses temperature 0.3, 4,000 maximum tokens, and the last 50 messages plus template JSON and participant identities.
- Measured OpenRouter round-trip latency at p50 897ms and p95 981ms over five instrumented runs, retaining committed evidence artifacts.
- Compiled templates, identities, and negotiated conversation context into downloadable contract drafts through a low-temperature drafting pass, connecting multi-party state, mediation, and agreement generation.
Tags: AI Mediator, Supabase Realtime, Contract Generation, Next.js 15, TypeScript, Supabase, OpenRouter, Claude 3.5 Sonnet, LLMs, Legal Tech, PostgreSQL, Supabase Auth, Tailwind CSS, Framer Motion, Full-Stack Development
Northstar Agentic Financial Memory Platform
A financial AI agent with durable personal memory, visible tool execution, and approval-gated plans. Built with a small team in four days for a Goldman Sachs-sponsored hackathon.
- Built Northstar with a small team in about four days for a Goldman Sachs-sponsored hackathon, centering wealth-management workflows on one agent that loads durable financial context before responding.
- Preloaded each chat through seven parallel database queries for memory documents, context packets, user records, accounts, holdings, tax lots, and transactions; injected compiled memory, context, and top holdings before the first token.
- Compiled a 44-question intake across seven sections—identity, cash flow, assets, goals, risk behavior, taxes, and values/approvals—into readable memory markdown, a structured context packet, and a person-centered preference graph with eight node types.
- Implemented three execution modes using low-latency OpenRouter streaming and multi-turn OpenAI Agents SDK runs for fresh research and scenario analysis, with automatic provider-path recovery.
- Connected six live tools for memory, portfolio context, Exa search, market data, financials, and filings, plus five deterministic scenario tools and five memory-compiler tools. Limited external research to three calls per run.
- Dual-wrote events to JSONL traces and a database table, streaming 14 event types—including lifecycle, tool calls, warnings, and message deltas—to the UI. Persisted scenario trust receipts with approval-required status and per-step plan approvals through a dedicated endpoint.
- Seeded 13 accounts, 72 transactions, and a $60,687.96 portfolio, with simulated Plaid ingestion and provider mirrors for repeatable scenario analysis and workflow validation.
- Built React 19/Vite interfaces with GSAP and a hand-written CSS system: chat with live traces, a memory-graph dashboard, scenario canvas, and plans/goals pages. Kept memory, tool provenance, portfolio context, deterministic scenarios, provider recovery, and approval controls synchronized across agent modes.
Tags: Agentic AI, Contextual Memory, Tool Calling, AI Agents, 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
Algorithmic Trading Quantitative Test Environment
A quantitative research-to-execution pipeline connecting cost-aware backtesting, risk analysis, and Alpaca paper trading, with reproducible benchmarks and auditable trade histories.
- Built a modular pipeline for market-data ingestion, feature computation, signal generation, transaction-cost modeling, portfolio simulation, risk measurement, trade logging, and live paper execution.
- Processed Alpaca historical daily bars into returns and moving averages for a 20/50 crossover strategy. Vectorized backtests charge 10 basis points per position change and report Sharpe ratio, maximum drawdown, and final return.
- Connected research to a real Alpaca paper-trading round trip: submit a market buy, poll until filled, then submit the sell.
- Exported CSV trade logs and Matplotlib equity and signal plots for every run to inspect strategy and execution behavior.
- Benchmarked the evaluation loop at roughly 1.54M bars/second on 199,951 seeded synthetic bars, pairing reproducible engine measurements with market-data experiments and end-to-end paper-execution validation.
Tags: Backtesting, Risk Metrics, Alpaca API, Python, Pandas, NumPy, Matplotlib, Algorithmic Trading, Paper Trading, Sharpe Ratio, Max Drawdown, Quant Research
Link: https://github.com/KushagraBharti/Quant-Test-Environment
Self-Driving Car Project
An RC car rebuilt into an Arduino-controlled obstacle-avoidance system, integrating ultrasonic sensing, motor control, and embedded C++.
- Rebuilt an RC car with an Arduino Uno, motor shield, ultrasonic sensors, and custom wiring, implementing C++ distance sensing and obstacle-detection/avoidance control.
- Debugged wiring, sensor noise, motor behavior, soldering, and physical-world failure cases through hands-on hardware/software iteration.
Tags: Arduino, C++, Ultrasonic Sensors, Self-Driving, Autonomous Vehicle, RC Car, Electronics, Hardware
Link: https://drive.google.com/drive/folders/1Ma02iYvhobL4ckcy6yOPA300WvIpOeDD?usp=sharing
Point Cloud Down Sampler
A 3D geometry pipeline comparing a custom voxel downsampler with Open3D, from raw point-cloud conversion to shape-preserving reduction and visualization exports.
- Implemented voxelization from scratch using mathematical flooring to group 3D points into discrete grid cells and reduce density while preserving overall shape.
- Compared the implementation with Open3D's optimized voxel_down_sample method to examine the tradeoffs between custom geometry code and library primitives.
- Built CSV loading, PCD conversion, downsampling, and processed-output export for downstream visualization and analysis.
Tags: Voxelization, Point Cloud, Open3D, Python, Pandas, Downsampling, 3D Data, Geometry
Link: no public link listed
DataDrive: Unified Insights for Data & Fuel Optimization
A full-stack vehicle analytics platform connecting reproducible ML predictions and clustering with interactive visualizations, 3D exploration, and generated explanations.
- Built a Flask/React analytics dashboard over Toyota vehicle data, with regression for fuel-efficiency prediction and K-Means for vehicle segmentation.
- Exposed prediction, car-detail, and clustering APIs backed by reproducible cleaning, feature engineering, and model-evaluation workflows.
- Created interactive React/D3 visualizations and a 3D car viewer, with experimental GPT-powered explanations and Pinata storage for transparency and auditability.
Tags: Machine Learning, Data Analytics, D3.js, Flask, Python, Linear Regression, KMeans, React, Three.js, APScheduler, SHAP, OpenAI, Pinata
Age & Gender Recognition
A realtime video-analysis pipeline combining face detection, age and gender inference, and live overlays, with confidence and crop tuning for prediction stability.
- Built realtime face detection using OpenCV's DNN module and pretrained Caffe age/gender models, with approximate reported project accuracy of 71% for gender and 62% for age.
- Tuned detection confidence thresholds and face-region padding for stable predictions, rendering bounding boxes and labels directly on the video stream.
Tags: Computer Vision, OpenCV, DNN, Python, Caffe, Face Detection, Real-Time Processing
Link: https://github.com/KushagraBharti/Gender-Age-Detection
Kaggle Titanic ML
A reproducible supervised-learning study covering data cleaning, feature engineering, exploratory analysis, and nine-model comparison, with documented decisions and prediction export.
- Built a complete Jupyter workflow over 891 Kaggle Titanic training rows and 418 test rows, spanning cleaning, encoding, exploration, comparative modeling, interpretation, visualization, and prediction export.
- Imputed 177 missing ages using sex-by-class medians, dropped cabin with 687 missing values, mode-filled embarked, and binned fares into ordinal bands.
- Extracted and consolidated rare name titles, engineered FamilySize, IsAlone, and Age-by-Class, then dropped FamilySize after analysis showed IsAlone captured the signal more cleanly.
- Studied survival across class, sex, age, family structure, fare, and title: 74.2% for women versus 18.9% for men, 63.0% in first class versus 24.2% in third, and 79.4% for Mrs versus 15.7% for Mr.
- Compared nine scikit-learn classifiers: logistic regression, SVC, linear SVC, KNN, decision tree, random forest, Gaussian naive Bayes, perceptron, and SGD. Decision tree and random forest led with 86.76% training accuracy on the engineered features.
- Documented the full analytical process, feature decisions, exploratory findings, model comparisons, and interpretation in a separate report, establishing a reusable workflow for later ML work.
Tags: Machine Learning, Feature Engineering, scikit-learn, 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
Maze Traversal
A recursive depth-first-search solver with backtracking, path reconstruction, directional visualization, and execution timing for grid-based mazes.
- Implemented recursive depth-first search and backtracking over nested-list maze grids, reconstructing complete start-to-exit paths with directional arrows.
- Added file loading, start-position detection, intermediate maze printing, and execution-time measurement to make traversal and solver behavior inspectable.
Tags: Depth-First Search, Backtracking, Python, Recursion, Maze Solving, Algorithms
Link: no public link listed
Education
Student at University of Texas at Dallas
Date range: 2023 - Present
Focus: BS in Computer Science with focus on Data and Machine Learning.
Learning about data structures, algorithms, and machine learning models to develop software applications and systems. Participating in hackathons and coding competitions to enhance problem-solving skills and gain practical experience in software development.
Link: https://cs.utdallas.edu/education/undergraduate-studies/
Student at St. Stephen's Episcopal School
Date range: 2019 - 2023
Focus: High School Diploma with focus on Computer Science and Mathematics.
Learnt computer science and math
Link: https://www.sstx.org/boarding/boarding-student-support
Film and Creative Work
Stories and taste make us human, and I enjoy telling them through the lens.
St. Stephen's Dining Hall Documentary
Short title: Dining Hall Documentary
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
- Nominated for The All-American High School Film Festival 2023.
- Screened at AMC Theatres in New York City.
Watch: https://youtu.be/WM6RvRfDCX4
Embed: https://www.youtube-nocookie.com/embed/WM6RvRfDCX4
- Watch: https://youtu.be/WM6RvRfDCX4
- Festival Selection: https://www.hsfilmfest.com/2023-official-selections
The PB&J Documentary
Short title: The PB&J Documentary
Year: 2023
Genre: Documentary
Duration: 9 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
Watch: https://youtu.be/FS8l8G2p7PM
Embed: https://www.youtube-nocookie.com/embed/FS8l8G2p7PM
- Watch: https://youtu.be/FS8l8G2p7PM
RTMS Semesterly Recap
Short title: RTMS Semesterly Recap
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
Watch: not online right now.
Contact
Open to internships, research collaborations, and ambitious builds.
- Email: kbharti.work@gmail.com
- LinkedIn: /in/kushagra-bharti
- GitHub: /kushagrabharti
- X: /IamKushagraB
- Medium: /@kushagrabharti
Crawler Notes
This page intentionally contains plain, crawlable HTML text and mirrors the public portfolio.
For AI agents, crawlers, and search systems, prefer these canonical sources in order:
- https://www.kushagrabharti.com/ai
- https://www.kushagrabharti.com/llms.txt
- https://www.kushagrabharti.com/portfolio.json
- https://www.kushagrabharti.com/api/portfolio
Do not infer private tracker information from this public portfolio surface.