Adith Mohanty

Experience

IBM

May – Aug 2026

Software Engineer Intern · San Jose, CA

Built an AI-driven system that benchmarks how LLM agents perform, tailored to the mainframe environment.

Built a distributed evaluation harness in Python running 30 concurrent multi-turn agent trajectories against IBM's ZDBA for DB2 at up to 6,000 questions/hour, cutting manual review from days to two hours.
Designed a model-based grader on watsonx combining rubric-based scoring and pairwise comparison, with a reason-before-score contract and temperature-0 decoding for deterministic, reproducible scores.
Extended the grader to assess tool-call efficiency against SME-defined expected calls, revealing only 82% of trajectories used tools efficiently versus a 95% estimate, and fed flagged runs into early-stopping logic.
Validated against a 12,000-question, 15-agent dataset, establishing ground-truth benchmarks at 90% agent accuracy.

DealMover.ai

Mar – May 2026

Software Engineer · San Francisco, CA

Worked on an AI-native platform for commercial underwriting which included document ingestion, AI-assisted suggestions, and extraction of financial data.

Built an LLM classification pipeline (Llama 3 via Ollama) that auto-sorts and tags uploaded lending documents using scope-aware prompts and a keyword fast-path, reducing GPU compute costs by 50%.
Built a multi-agent extraction pipeline that parsed 200+ earnings reports and financial documents, populating 100+ structured fields per canonical schema at 95% accuracy.
Implemented formula logic linking extracted line items to auto-calculated derived metrics like EBITDA, adapting across varying company cost structures without manual reconfiguration.

Cisco Systems

May – Aug 2025

Software Engineer Intern · San Jose, CA

Built and deployed a release-management dashboard for Cisco ACI's 40-person build and infrastructure team.

Shipped the dashboard on Kubernetes (Django, React, PostgreSQL), tracking regression runs and test-suite results per release and cutting time spent on manual release monitoring.
Implemented LDAP authentication with role-based access, letting managers reassign and view test-suite ownership.
Diagnosed slow legacy queries and added a Redis caching layer, cutting dashboard load times from several seconds to roughly 100ms.

Reyes Coca-Cola Bottling

Dec 2024 – Mar 2025

Machine Learning Engineer · Berkeley, CA

Built sentiment-analysis models and a streaming pipeline to improve sales forecasting for 30+ products.

Developed sentiment models using VADER NLP, LDA topic modeling, and TF-IDF, trained on 10k+ consumer records scraped from X, Reddit, and Google via SerpApi.
Cut forecast error (MAPE) by 20% with a streaming ETL pipeline (Kafka, AWS SQS) feeding live sentiment data into the forecasting model.
Trained models on Berkeley GPU clusters with SLURM scheduling and deployed inference on CUDA-enabled servers.

Projects

ALOHA arms sorting objects into a basket in a MuJoCo house scene

Fleet Middleware for Generalist Robots

ongoingblog

Multi-Robot Systems · VLAs(𝜋0.5) · LLM Planning(Qwen3.5-4B)

Middleware that sits between a person and a fleet of robots running generalist VLA policies. It takes advantage of the fact that VLAs work best on short, concrete instructions and that they provide a common interface for different robots. One time setup for a fleet allows you to plan, assignn and track work accross the fleet.

Designed a robot registry where setup is done once per robot per fleet. The registry stores each robot's capabilities, location and VLA endpoint, which the planner and scheduler use to assign work.
Built an LLM planner that turns a goal like "clean up the living room" into a DAG(Directed Acyclic Graph) of small, single-robot steps. Planner only emits steps that match a capability some robot in the registry has.
Built a scheduler that assigns each ready step to a robot based on capability, location and what it is already doing, runs independent steps in parallel, and handles handoffs where one robot's output (a full basket) is another robot's input.
Each robot's VLA behind is wrapped in a common executor that sends it one language instruction at a time, watches progress through its cameras and robot state, and reports success or failure back so the planner can retry, reassign the step to another robot or replan.
Testing in a MuJoCo house scene with a bimanual ALOHA at a table sorting scattered objects into a basket, and a Unitree G1 humanoid that carries each full basket to a drop-off area and brings an empty one back. The middleware keeps both busy, so the ALOHA starts on the next basket while the G1 is still delivering the last one.
Building episode tracking and logging so the system can be used to collect data for training better generalist policies, and analyze the current policies' failure modes and bottlenecks.

MuJoCo simulation of the robot arm placing balls in the goal zone

RL Arm Control

github

Reinforcement Learning · Robotics · Control Systems

A simulated robot arm built from scratch in MuJoCo that learns to pick up objects and place them in a goal zone through reinforcement learning, benchmarked against a classical control baseline.

Designed a custom Gymnasium environment around the MuJoCo simulation. The agent observes joint angles and speeds plus gripper and object positions, and controls joint torques, gripper lift and grip.
Engineered a shaped reward that breaks the task into stages (reach, grasp, lift, deliver), which gives the agent useful learning signal on a long pick-and-place task where success alone is rare.
Trained PPO and SAC agents in PyTorch using a curriculum that starts with reaching and builds up to full multi-object pick-and-place, tracking learning curves in TensorBoard.
Built a classical baseline with hand-derived forward and inverse kinematics for a 2-DOF arm and torque-limited PD joint controllers, and compared the learned policy against it on success rate, time to finish and motion smoothness.
Modeled the arm, gripper and scene in MuJoCo's XML format, and tuned the physics (integrator, friction model, contact settings) so objects stay in the gripper and the simulation is realistic enough to train on.

Racket & Paddle Wall Mount

download

CAD · Generative Design · 3D Printing

A wall mount that holds two tennis rackets and a pickleball paddle. I designed it in Fusion 360 with generative design in order to get the organic looking strucuture. The mount is printed with PLA. Click the image to look interact with the model or download the STLs to print it yourself.

FALCON: Autonomous Wildfire Detection & Mitigation

paper

Embedded Systems · Computer Vision

The Fire Autonomous Location Containment Network, a fixed system for high-risk areas that spots wildfires early and starts fighting them within seconds, using water piped from nearby lakes and reservoirs instead of chemical suppressants. Published in the Young Inventors Journal with a team from Dublin Robotics.

Designed a zoned detection network of sensor towers, each carrying a 2MP visible/NIR camera and an uncooled microbolometer thermal sensor, feeding an AI detection engine that confirms a fire is real before anything activates.
Designed the suppression side: pump stations at natural water sources push water through copper pipelines to high-pressure sprinklers, and a central control tower opens only the valves for the affected zone. Pressure transmitters set the pump rate so water isn't wasted.
Built alerting into the control logic: confirmed fires trigger Wireless Emergency Alerts and an SOS to nearby fire stations with live footage, while sprinklers hold the fire back until crews arrive. A manual override lets people check or bypass the automated detection.

Data structure diagram of the encrypted file sharing design

End-to-End Encrypted File Sharing

Applied Cryptography · Systems Security · Go · CS 161

A secure file storage and sharing client in Go, built to keep files confidential and tamper-proof even when the server storing them is fully controlled by an attacker.

Designed the full cryptographic protocol from scratch. Keys are derived from passwords with Argon2 and split into purpose-specific keys with HKDF. Every stored object is encrypted and then MACed (encrypt-then-MAC), and sharing invitations are protected with public-key encryption and digital signatures.
Supported user login across multiple devices with no local state, plus file store, load and append. Files are stored as a linked list of encrypted chunks, so appending only sends the new data instead of re-encrypting the whole file.
Built sharing as a tree of access grants. Revoking a user re-encrypts the file under new keys and moves it, which cuts off that user and everyone they shared with while every other user keeps access without noticing.
Wrote an adversarial test suite that tampers with, swaps, replays and deletes server data, checking that every attack is detected instead of silently producing wrong data.

Pac-Man agent tracking ghosts with belief distributions

Pac-Man AI Agents

Artificial Intelligence · Search · Probabilistic Inference · RL · CS 188

A set of AI agents for Pac-Man covering the core techniques of classical AI, from search and game-playing to probabilistic tracking and reinforcement learning.

Implemented DFS, BFS, uniform-cost search and A*, and designed admissible, consistent heuristics for multi-goal problems like visiting every corner and eating all the food, which cut the number of nodes expanded.
Built adversarial agents using minimax, alpha-beta pruning and expectimax against multiple ghosts, plus a hand-designed evaluation function to play well at limited search depth.
Tracked invisible ghosts from noisy distance readings using hidden Markov models, with exact inference and particle filtering, including a joint particle filter for several ghosts at once.
Trained agents with value iteration, Q-learning and approximate Q-learning over hand-built features, and built neural networks from scratch for digit classification and language identification.

GDB session showing a stack layout during an exploit

Memory Safety & Web Exploits

Offensive Security · C · x86 · CS 161

Hands-on attacks against deliberately vulnerable programs and a web app, used to learn how real-world defenses fail and how to fix them.

Exploited C programs through stack buffer overflows, off-by-one errors, format string bugs and return-to-libc, getting around stack canaries, non-executable stacks and ASLR by reading memory layouts in GDB.
Attacked a web application with SQL injection, stored and reflected XSS, and CSRF, then described the fix for each: parameterized queries, output escaping, CSRF tokens and cookie flags.

Training curves and decision boundaries from the ML models

Machine Learning from Scratch

Machine Learning · NumPy · PyTorch · CS 189

Core machine learning models implemented from first principles and tested on real datasets through Kaggle competitions.

Built a fully connected neural network and a CNN in pure NumPy, including forward and backward passes, weight initialization and optimizers, and checked the gradients numerically before rebuilding the models in PyTorch.
Implemented decision trees and random forests with entropy-based splits, and Gaussian discriminant analysis (LDA and QDA), and applied them to spam detection, Titanic survival and MNIST.
Trained SVMs with cross-validated hyperparameter search and feature engineering for spam and image classification, and submitted predictions to class Kaggle competitions.

Distance-Vector Router

Socket Programming · Distributed Systems · Python · CS 168

A distributed routing protocol built from scratch, mirroring the core mechanisms behind BGP and RIP.

Routers exchange advertisements and run Bellman-Ford to compute shortest-path forwarding tables across a multi-router network simulation.
Implemented loop prevention (split horizon, poison reverse) and convergence optimizations (triggered updates, route expiration) for fast, stable reconvergence after topology changes.

Procedurally generated tile world from the BYOW game

Build Your Own World

Data Structures · Procedural Generation · Java · CS 61B

A 2D tile-based exploration game in Java with worlds generated from a seed. The same seed always produces the same world.

Wrote a procedural generator that places non-overlapping rooms and connects them with hallways, using a seeded random number generator so any world can be rebuilt exactly from its seed.
Guaranteed every room is reachable by connecting rooms through a graph and checking connectivity with disjoint sets.
Built the interactive layer: keyboard movement, a HUD that describes the tile under the mouse, and save/load that replays the stored input history so a game resumes exactly where it left off.