Rucha
Agashe

The Intrinsic AI for Industry Challenge is a robotics + ML competition hosted by Intrinsic (Google/Alphabet) and Open Robotics, with a $180,000 prize pool. The task is deceptively precise: get a UR5e robot arm to insert SFP and NIC cables into a connector board in a simulated environment running Gazebo (Google DeepMind) and Isaac Lab (NVIDIA). Scoring rewards task completion (~75 points), trajectory smoothness (~24 points), and penalises collisions and excessive force. The challenge is non-trivial because cable physics in simulation is notoriously unpredictable — cables buckle, twist, and get physically stuck on ports in ways that deterministic policies cannot reliably handle.

My contributions are on the ML side of the stack — the team has specialists handling simulation infrastructure (Enrique), data collection (Ali), and cloud infrastructure (Evan). My focus:

• ACT (Action Chunking with Transformers) — A transformer-based imitation learning architecture that predicts sequences of actions (chunks) rather than single-step outputs. Chunking reduces compounding error and improves temporal coherence. Training on the experiment_8 dataset from HuggingFace; investigating a persistent GPU utilisation bottleneck (15–25% observed, 90%+ desired — almost certainly a CPU DataLoader bottleneck addressable with pin_memory and prefetching).
• Flow-Matching Policy — A continuous normalising flow approach to action generation. The policy learns a vector field that maps noise to actions along a learned trajectory — more stable training than diffusion with comparable expressiveness. My background in differential equations maps directly onto the mathematics here.
• W&B Experiment Tracking — 17+ training runs logged. Comparing loss curves, hyperparameter sensitivity (learning rate schedules, batch size, chunk length), and convergence behaviour across model variants.
• Data Curation — Post-processing brute-force collected trials to filter successful insertions. The cheat-code oracle policy fails non-deterministically (cables get stuck in Zone 2); the strategy is to collect at scale and filter, rather than fix the simulator physics.

Development runs on a dual-monitor setup: RViz and Gazebo Sim side by side, with four concurrent terminals managing simulation, recording, teleoperation, and episode control. Training runs remotely on AWS EC2 g6e instances (NVIDIA L40S GPU — the g4dn.xlarge is insufficient; the L40S is mandatory for Isaac Lab).

Left: Gazebo Sim + Isaac Lab environment. Right: RViz showing UR5e model with TF frame tree.

The UR5e arm performing the NIC card cable insertion task. These clips are from the data collection phase — the oracle cheat-code policy executing the insertion that the trained model is learning to replicate.

UR5e arm inserting a cable into the NIC card connector board. The policy must learn to replicate this motion from demonstration data.

The full stack spans four layers. The simulation layer runs a UR5e arm in Gazebo (Google DeepMind) / ROS 2 / Isaac Lab (NVIDIA) on AWS EC2 g6e instances (NVIDIA L40S GPU required). A data recorder captures bag files per trial at 20Hz — wrench, image, forward kinematics, and motion commands. A scenario generator randomises task board configurations for training variety.

Above that sits the policy training infrastructure: ACT and flow-matching models trained on the experiment_8 HuggingFace dataset, tracked on Weights & Biases. A non-trivial engineering problem: the standard AIC action space is 6-dimensional, but the team's recordings are 19-dimensional (extra metadata). Similarly, the standard observation space is 26-dimensional; recordings capture 48. Resolving this dimensionality mismatch without losing useful context is an open design question.

The team has analysed the wider competition and identified three key techniques to adopt. Force/Torque tare calibration (from competitor jlamperez): the raw wrist wrench reads ~20N because it measures the gripper's own weight — taring before each episode makes the policy weight-agnostic. Recording at 10Hz not 30Hz: cameras are capped at 20fps, so 30Hz recording introduces ~33% duplicate frames. Diffusion Policy over vanilla ACT (from ALOHA Unleashed): diffusion handles multimodal action distributions — multiple valid insertion approaches — without collapsing to a bad average. Sanjay leads this track.

Rangers-Intrinsic is distributed across three time zones. Tommy Ly (NY) leads the project and runs ML alongside a full-time day job. Shi Hao (London) handles RL and ACT training; 17+ W&B experiments logged. His independent portfolio and Project Automaton write-up: sienarindustries.com ↗ Enrique (London) built the simulation environment, data recorder, and HuggingFace dataset. Ali (London) built the scenario generator and ran 1,000 brute-force collection trials. Vladimir is a Senior ML Scientist at Booking.com specialising in RL for LLMs/VLMs. Sanjay (Illinois) leads diffusion policy. Justin (Boston) leads PPO exploration. Evan (London) manages AWS org-level infrastructure.

Social situations are genuinely difficult to navigate for many neurodivergent people — not because of any deficiency, but because the implicit communication layer of human interaction (body language, microexpressions, tone) is processed differently. No tool currently addresses all three channels simultaneously in real time. NeuroCue is a quiet, non-intrusive scaffolding system — not a replacement for social instinct, but a support layer for those who need it.

Three concurrent Python threads share a single threading.Lock state object, fully decoupling data production from LLM consumption:

Trained from scratch during the hackathon. ResNet-style residual blocks with Squeeze-Excite channel attention. 7-class softmax output with smart compound expression mapping — the model doesn't just output a single emotion, it reads the probability distribution: high happy + high fear → "smiling but may be masking discomfort"; surprise + fear → "looks confused." Graceful degradation built in — if fer_model_best.pt fails to load, the system continues on body language and transcript only, no crash.

The three data streams run on entirely different cadences — GPU inference has variable network latency, FER runs every 5s locally, and audio records continuously. The naive approach (waiting for synchronous responses from all three) would have made the system fragile and latency-bound. The solution was to treat the shared state object as a bulletin board: each thread posts its latest output whenever it's ready, and the LLM call reads the whole board atomically on its own 15-second clock. This decoupling is what makes the system robust in live conditions.

The NeuroCue session report interface — showing emotion timeline, body language summary, and voice analysis in a single view. Built with the B2B enterprise use case in mind: exportable session reports, multi-signal visualisation, and a clean dashboard for reviewing what the system detected.

Left: Session report view — 15-minute session, 7 tips given, dominant emotion Neutral. Body language and voice analysis panels. Right: Emotions panel — real-time probability distribution and arousal/valence metrics.

Developing into a B2B SaaS product — target markets: HR departments, autism support organisations, and enterprise training platforms.

A standard on-chain stablecoin transfer publicly reveals the buyer's address, the merchant's address, the exact payment amount, and the precise timestamp. This metadata leakage creates real risks. FZAP ensures there is never a direct blockchain transaction between a buyer and a merchant — without becoming an arbitrary privacy mixer (which would be a regulatory problem).

1. One-time-use ephemeral identities. Each transaction generates a fresh set of cryptographically secure wallet identifiers, unique within the protocol lifetime. No reuse, no linkage.

2. Aggregation-based settlement. Buyer deposits are pooled before settlement — conceptually an omnibus account. Once aggregated, individual payment amounts lose their one-to-one correspondence with specific wallets. A deliberate propagation delay further weakens timing-based correlation attacks.

3. Multi-hop QAOA-optimised routing. Aggregated funds are converted across stablecoins and chains. Possible transitions are modelled as a graph — nodes represent currencies, edge weights represent swap and bridge fees. QAOA (via Qiskit) searches this cost landscape to identify routing configurations that minimise aggregate loss. Real-time pricing from the Flare Time Series Oracle (FTSO) API — temporary stablecoin depegs are modelled as negative cost offsets to preserve pooled value.

For each settlement, an attestation request references the transaction hash, destination chain, and payment type. This is processed during a Flare Data Connector (FDC) voting round. Once finalised, the result is committed to a Merkle tree. Merchants submit a Merkle proof to the settlement verification smart contract, which validates inclusion against the published FDC root. A settlement is only considered complete once verified on-chain — no linkage is ever created between buyers, intermediate hops, and the final merchant payment.

Unlike traditional privacy mixers, FZAP provides no arbitrary anonymisation or user-controlled withdrawal paths. All value flows are explicitly tied to merchant payments; withdrawals are restricted to predefined settlement addresses. This is what makes it commercially deployable rather than a regulatory liability — and the distinction the sponsors found compelling.

Instead of using python-chess, all core mechanics — valid move generation, checkmate detection, board state management — are implemented from the ground up. This gives full control over the game tree and was the point: I wanted to understand exactly what was happening at every level, not call a function and trust it.

The engine uses a Minimax algorithm to navigate the decision tree — identifying the move that maximises its advantage while assuming the opponent plays optimally to minimise it. Alpha-Beta Pruning cuts off branches that are mathematically proven to be worse than previously explored options, significantly reducing computation time. The Negamax variant is used where applicable, handling evaluation from a single perspective by negating scores for the opponent.

Traditional tree searches are limited by the exponential growth of possible moves. MCTS is integrated to balance exploration vs. exploitation. Selection and expansion use Minimax logic to prioritise high-value nodes. Simulation uses a pre-trained Transformer to estimate game outcomes from a given state — far more efficient than searching the entire subtree. Results back-propagate up the tree to update the value of each move.

FEN notation parsing — Forsyth-Edwards Notation is the standard for encoding board states. Implemented a full BNF-grammar-based parser so the engine can import, export, and resume any position.

Endgame tablebases — pre-computed optimal play for positions with few pieces remaining, used to guide the engine in the endgame rather than searching from scratch.

SQLite-backed history — user accounts and game history stored relationally, enabling game replay, analysis, and statistical aggregation across sessions.

Cycle detection — the search tree identifies and ignores repetitive move sequences to prevent infinite loops and enforce threefold repetition rules correctly.

Pygame interface — custom graphical board with piece loading, move highlighting, drag-and-drop input, and a real-time evaluation bar.

Formulate a high-frequency trading strategy to trade 4 assets, maximising the Sharpe ratio using market making and arbitrage strategies, such that PnL can be evaluated in under a minute.

Instead of quoting around the raw mid-price, the engine calculates a reservation price: mid + predicted short-term drift (μᵢ) + inventory penalty (k_inv). This skews quotes away from the direction of inventory exposure, reducing position risk. Spreads are dynamically widened or narrowed based on estimated volatility (σᵢ) and current risk-aversion parameters — wider in high-volatility regimes, tighter in stable ones.

Short-horizon predictors (XGBoost / LightGBM) forecast price movement over the next k ticks. Aggressive market orders are only executed when the signal-to-noise ratio E[R] / σ_est exceeds a calibrated threshold. Quotes are also aggressively skewed away from the predicted direction to avoid being filled on the wrong side of a trend (adverse selection avoidance).

Capital is allocated across the four assets by solving a mean-variance proxy: minimise J(w) = −wᵀμ + λwᵀΣw, subject to leverage caps, dollar neutrality, and maximum per-asset exposure. Recomputed periodically via scipy.optimize.

Raw Limit Order Book snapshots (top 5 levels) transformed into: mid-price, microprice, spread, multi-level imbalance, depth sums, queue imbalances, order-flow deltas, short-term realised volatility, VWAP, and rolling means. These features feed both the market-making reservation price and the directional predictors.

Later extended using Multi-Agent Reinforcement Learning, inspired by Google DeepMind's research on cooperative MARL. Each asset is treated as a separate agent with its own policy, sharing a global Sharpe ratio reward signal — agents learn to coordinate rather than compete for capital.