When Chess Met Robotics: Inside IIT Delhi's RoboGambit

by Jyotsna Bhushan - 17/07/2026

We’re used to seeing AI crush grandmasters in a blink. But what happens when you take that brilliant silicon brain and force it to grapple with the physical world? At IIT Delhi’s RoboGambit, we didn't just see perfect chess engines; we watched them sweat. Or rather, we watched their robotic arms fumble, stutter, and run out of time while trying to move a simple plastic piece. It’s a humble, slightly chaotic reminder that while thinking about chess is easy, actually playing it with grace, speed, and under pressure is a whole different beast.

A Game With No History Behind It

RoboGambit was designed by Sanidhya Ojha and Nitye Gupta and organised by the ARIES Society and the Robotics Club at IIT Delhi, with support from the university's Technology Innovation Hub, IHFC. Fifteen hostel teams entered the competition, thirteen from the main Delhi campus and two from IIT Delhi's Abu Dhabi campus. It played out in two stages: first a software simulation round, then a hardware round where real robot arms took over the board.

The way teams dropped out along the way tells a lot. All fifteen attempted the software stage, and eleven managed to build a working chess engine. But only eight teams got their entire robot pipeline, the camera vision, the arm control, the whole mechanical choreography, working well enough to even qualify for the hardware round. So building a machine that could think about the game was something more than two thirds of the field pulled off. Building a machine that could physically play it was where most of the casualties happened.

The board and the pieces at IIT Delhi's Robogambit.

Rules:

The game itself was a compact variant played on a 6x6 board instead of the usual 8x8:

No rooks, and no castling
The back row was shuffled at the start of every game, Fischer Random style, with the two bishops always forced onto opposite coloured squares
Pawns could only ever move one square forward
Promotion was restricted: a pawn could only become a piece that had already been captured and was sitting off the board. If your opponent's queen was still alive, you had no way of conjuring a new one for yourself, no matter how far your pawn had marched

That promotion rule sounds like a small tweak, but it changes the whole feel of the game. Keeping your own big pieces alive suddenly matters in a very direct way, and every capture has consequences that echo into the endgame.

Nobody had ever played this exact game before RoboGambit. There was no opening theory, no archive of past games, no existing engine anywhere that already understood it. Whatever chess knowledge these engines ended up with, the teams had to build entirely from scratch, in roughly a week. Teaching a Machine to Understand a Game Nobody Had Ever Played

Teaching a Machine to Understand a Game Nobody Had Ever Played

To follow what the teams were up against, it helps to know how a modern chess engine works underneath the hood. Every engine really has just two jobs:

Search: imagining a tree of future moves, if I play this, you play that, I answer with this, and cutting away branches that obviously lead nowhere so the engine can spend its limited time looking deeper into lines that matter
Evaluation: once the search lands on a quiet position where nothing is hanging, something still has to hand down a verdict on who is better, and by roughly how much

For a long time, evaluation was written by hand. A programmer who understood chess would encode rules directly into the software, things like "a knight is worth about three pawns" or "a king stuck in the middle of the board is usually in danger." The big leap that produced today's superhuman engines, including modern Stockfish, came from replacing that hand-written judgment with a neural network trained to recognise good and bad positions the way human intuition does, except faster and never tired. These networks are called NNUE, and the team from Nilgiri Hostel, competing as Magnus Galgotias, set out to build one from nothing.

The first instinct was to build something big like Alphazero. It's a beautiful idea, and a punishingly expensive one to pull off. This kind of learning, called reinforcement learning, usually needs a huge number of self-played games and many rounds of retraining before it settles into strong play, far more time and computing power than a single week allows. With the clock running, the engine never found its footing, producing weak, scrambled moves. With the deadline closing in, they made the harder, more grown-up call and scrapped it. An engine that might one day become brilliant but that you cannot trust mid-competition is worse than a modest one that simply works.

Nilgiri's Integration lead Mehul Shakya and the playing arena.

So they switched to something cheaper, called supervised learning, training the network to imitate answers they already had in hand rather than discover them from scratch. Since no games of this variant existed anywhere, they had to manufacture their own:

The engine played about 50,000 games against itself at a shallow, quick search depth
That batch trained the evaluation network for the first time
The improved engine played another 50,000 games against itself, and the network was trained again on those, teaching it to guess what a slower, deeper search would have concluded just by glancing at a position
This cycle of self-play and retraining was repeated three times in total

That trained network was then paired with a fast, traditional search engine, built from scratch in C++, using the usual toolkit chess programmers reach for: memory of positions already analysed, smart ordering of which moves to consider first, pruning of hopeless lines, a special search that keeps calculating through a flurry of captures, and a way of narrowing the search around the score it expects to see.

All of it, the rules engine, half a million self-played training games, the neural network, and the fine-tuning, came together in about ten days. The finished engine played this two-week-old, never-before-seen variant at roughly the strength of a 2100-rated player on chess.com. For something built with no opening theory and nothing to learn from except its own games, that's like teaching someone an entirely new sport from a blank page and having them walk out playing at a strong club level within a fortnight.

The Part No Chess Player Sees Coming

This is where RoboGambit stops being a story about artificial intelligence and turns into a story about something chess players almost never have to think about: the physical world.

A match here was not engine against engine. It was a relay between a human and a robot. Each team alternated turns between its own player at the board and its autonomous robotic arm, a compact four-jointed machine with an electromagnet on the tip, built to lift and place the game's cylindrical pieces. Crucially, the human and the robot shared a single ten-minute clock for the whole game, with no extra time added per move. Every second the arm spent fumbling toward a piece came straight out of the same clock the human was using to calculate.

That one design choice changed everything. The human's job was no longer just to find the best move on the board, but to find a move the arm could actually carry out cleanly and quickly, all while a shared clock drained away regardless of whose turn it technically was. Captures made this worse: taking a piece meant the arm had to lift the captured piece off the board and set it aside, then move its own piece onto the empty square, almost two moves' worth of fiddly motion for one turn. Teams only got hands-on access to the real hardware about three hours before the event began, and the control interface had a habit of quietly queuing up repeated commands if you moved too quickly, so one rushed click could silently turn into two.

Calculation, as more than one team would later admit, turned out to be almost the easy part. Nerve, and a steady hand guiding a stubborn machine while the clock ran down, was the real test.

Four Podium Finishes, and One Game That Says It All

Combining software scores with hardware match results, four teams rose to the top: Girnar (as Stickfish) won all six hardware games to take first, Satpura finished second on five wins, Nilgiri (as Magnus Galgotias) took third on four wins, and Kailash (as Regina) finished fourth on three. Girnar's win looks thoroughly earned. By all accounts they best tamed their robotic arm, and once the hardware stopped fighting them, their strong engine did the rest.

But the game that best captures what RoboGambit was really about is Nilgiri's first meeting with Satpura. Early on, Satpura's engine made a slip that should have lost the game outright, and Nilgiri came out clearly better. The teams were closely matched in both engine strength and arm control, and with a shared clock and no increment, a winning position is worth nothing if you can't physically finish it in time. With about nineteen seconds left, Nilgiri's position called for a capture, that costly two-part motion of lifting the opponent's piece away and setting their own down. They were agonisingly close. Three more seconds would have done it. Instead, the flag fell with the move half made, and the game was lost on time, not on the board.

The arithmetic stings precisely: complete that one capture, win that one game, and the head-to-head flips, Nilgiri finishes second instead of third. The best chess in that game belonged to Nilgiri. The clock simply did not care.

The Organizers of this enticing event.

That's worth pausing on, because it turns something chess players take for granted on its head. Over the board, finding the best move earns you full credit the instant you play it. In RoboGambit, finding it was necessary but nowhere near enough, you then had to survive carrying it out, on a shared clock, through an imperfect machine. Two full matches did end in clean checkmates. But most of the drama, and most of what decided the trophy, came down to a robot arm and a stopwatch.

Why This Story Is Worth Telling

It would be easy to read RoboGambit as simply a robotics competition that borrowed chess as its theme. But it's more interesting read the other way around, as a small, sharp snapshot of exactly where the AI story in chess currently stands, and exactly what it still cannot reach.

Chess has spent the last decade as one of the great proving grounds for artificial intelligence, from Stockfish's neural evaluation networks to AlphaZero's self-taught rise to superhuman strength. RoboGambit compresses that entire arc into a single week: a team reaches first for the most powerful, most ambitious method on the table, discovers it doesn't fit the time they actually have, and finds a cheaper, more disciplined path that still produces something genuinely strong. That's a very honest picture of how real engineering under real deadlines tends to go, big ambition meeting the blunt reality of a clock, and a good team knowing exactly when to let go of the fancier idea.

And then the competition adds the one twist that no amount of engine strength can solve by itself: a body. Give a 2100-strength brain a clumsy robotic arm and a shared clock, and the outcome is decided as much by mechanical dexterity and composure as by calculation. In its own small way, that's a lovely echo of the oldest tension in chess itself, the gap between seeing the right move and having the nerve to carry it out under pressure. RoboGambit simply made that gap physical, mechanical, and completely unforgiving, and put a robot arm right in the middle of it

People stayed till 9 p.m., engrossed in the competition!!

Nilgiri Hostel's team, competing as Magnus Galgotias, was led by the engine and integration lead Mehul Shakya, with Ishan Anand as fellow software lead, Harshit Gupta and Honey handling robotics and hardware, and Kaushik Panigrahi playing as the team's human player at the board.