About Me
Hello! I'm Rishit, a Computer Science student at Santa Clara University (Class of 2027). I am highly passionate about agentic applications, machine learning, and building data-driven intelligent systems.
I love seeing how computers can make smart, autonomous decisions when provided with robust data and logical workflows. Whether it's developing dynamic multi-agent systems or optimizing algorithms, it feels amazing to build systems that can understand the world more deeply and solve real-life problems.
Currently, my coursework includes Data Structures, Object-Oriented Programming, Embedded Systems, and the Theory of Automata. Outside of class, I actively participate in hackathons and independent research to test new ideas and push the boundaries of what AI can automate.
Technical Arsenal
Projects
ToolForge
2nd Place • Llama Lounge HackathonA self-expanding multi-agent workflow that dynamically generates and validates its own tools instead of relying on a fixed toolset. Designed a Planner agent checking 150+ Composio integrations, and a Builder agent that writes and passes new tools to a Llama-based Validator.
Cineflow
1st Place • AIC x Adobe HackathonAn AI Video Transition Generator. Designed and fine-tuned a Vision Transformer on 10k clips, achieving a 23% higher cut-point F1 score than baselines. Deployed the model as a GPU-backed microservice on AWS, delivering sub-250 ms inference.
Gradient
JUN 2025A networking platform for university students built with modern web technologies, utilizing semantic search to match users based on high-dimensional text embeddings.
Experience
Canyon View Technology
Jun 2023 – Aug 2023Technology Intern · Remote
- Developed and implemented a Lua script utilizing the Haversine equation to enhance rover navigation precision based on GPS coordinates.
- Conducted comprehensive testing and created technical documentation detailing methodologies, implementation challenges, and solutions.
Mathnasium
Feb 2023 – Jun 2023Mathematics Tutor · Santa Clara, CA
- Tutored 15+ students in mathematics through individualized learning plans, improving grades by an average of one letter grade.
- Provided regular progress reports to parents and fostered positive learning relationships to ensure student success.
Research
AI and Multi-Agent Path Finding (MAPF) Solvers
Dec 2022 – May 2024Independent Research under Dr. Przemysław Walęga and Michał Zawidzki
- Conducted research on AI knowledge representation and algorithms.
- Authored comprehensive research paper evaluating MAPF solver efficacy, computational complexity, and scalability in dynamic environments.
Holographic Data Compression Systems
Feb 2022 – Apr 2023Independent Research under Prof. Andrew C. Freeman, Baylor University
- Developed Python-based compression algorithms for holographic storage systems, achieving a 40% improvement in data encoding efficiency.
- Authored research paper evaluating state-of-the-art holographic compression methods, analyzing computational complexity and future advancement trajectories.
Project: ToolForge
Overview: ToolForge is a self-expanding, multi-agent workflow architecture designed to overcome the limitations of fixed-toolset LLM agents. By allowing agents to dynamically write, test, and validate their own tools at runtime, the system scales its own capabilities autonomously. This project secured 2nd Place at the Cerebral Valley x Llama Lounge Hackathon at Snowflake (Mar 2026).
System Architecture
The system is built on top of CrewAI and orchestrates a multi-step generation pipeline. Instead of hardcoding API requests, the agents use context to generate custom Python logic.
Agent Roles & Orchestration
- The Planner Agent: Interfaces with Composio to scan through over 150+ available integration schemas, determining exactly what API endpoints are required to fulfill the user's task.
- The Builder Agent: Ingests the schema and writes functional Python execution code, formatting it into a callable tool structure.
- The Validator Agent: A Llama-based quality-control layer that dry-runs the generated code, catches syntax errors, and forces the Builder to iterate until production-ready.
Data Persistence & Infrastructure
To prevent the system from regenerating the same tools repeatedly, successfully validated tools are serialized and persisted into a Snowflake database. This essentially gives the agentic framework a long-term "memory" of skills that accumulates across runs.
Furthermore, we integrated Skyfire to handle autonomous API access and token management, completely eliminating rate-limit interruptions during long-running background workflows.
Project: Cineflow
Overview: cineflow is an AI-powered video processing microservice that autonomously generates perceptually seamless transitions between disparate video clips. Built during the SCU x AIC Hackathon (where it won 1st Place), the platform shifts the burden of tedious timeline keyframing to a highly optimized machine learning pipeline.
Computer Vision Pipeline
The core of the system relies on a Vision Transformer (ViT). Rather than using legacy heuristic algorithms for scene detection, the ViT parses incoming frames as sequential image patches, mapping vectors for motion topology, lighting, and camera angle.
During the hackathon, we fine-tuned this model on a proprietary dataset of 10,000 cinematic clips. This specialized training regimen resulted in a 23% higher cut-point F1 score compared to standard C3D baseline models.
Optimization & Deployment
- Dynamic Programming Algorithm: Once the ViT classifies the bounding scenes, a custom dynamic programming algorithm calculates the optimal temporal overlap for the transition. This specific optimization increased our perceptual continuity score by 18% in blind testing.
- AWS Microservice Architecture: Processing 1080p footage requires significant computational overhead. To manage this, the entire model was containerized and deployed as a GPU-backed microservice utilizing AWS Lambda and EFS.
- Performance: The distributed cloud architecture ensures sub-250 ms inference times for 1080p frame analysis, allowing the React frontend to remain entirely non-blocking.
Project: Gradient
Overview: Gradient is a localized networking platform designed to connect university students and alumni based on nuanced, technical interests rather than broad degree titles. It leverages a modern React/Firebase stack integrated with an AI-driven semantic search engine.
Technical Architecture
The application is structured as a Single Page Application (SPA) using React and styled with Tailwind CSS to ensure a highly responsive, low-latency UI. User schemas, session states, and profile metadata are securely managed via a Firebase Firestore NoSQL backend.
Semantic Matching Engine
The primary technical hurdle for Gradient was moving beyond basic exact-string matching (e.g., matching "Software Engineer" only with "Software Engineer").
By mapping user bios, project descriptions, and search queries into high-dimensional vector embeddings, Gradient calculates the nearest neighbors utilizing Cosine Similarity formulas. This allows the system to recognize that a search for "AI Developer" is semantically proximate to a user profile listing "Machine Learning Engineer", surfacing highly relevant connections that traditional relational database queries would drop.
To ensure high availability, the frontend utilizes local caching mechanisms and falls back to standard Firestore index queries if the embedding API experiences downtime.