Large Language Models, or LLMs, often work better on complex tasks when they “think” before they answer. In AI, this means the model writes out intermediate reasoning steps before giving a final response. These steps are often called Chain-of-Thought.
Takeaways 🚀
✅Community trained Gemma reasoning efficiently
✅Tunix and TPUs enabled experimentation
✅LLMs benefit from structured thinking
✅Chain-of-Thought improves complex task performance
✅Open methods support reproducible AI
In practice, this kind of reasoning can help a model move through a problem more carefully. Frontier LLMs like Gemini 3 and leading open weight models like Gemma 4 can produce clear reasoning traces before they answer user questions. As a result, these traces can help models break down hard problems, follow multi-step logic, and give more reliable answers.
However, many training methods for reasoning are not public. They can also be hard to repeat. For this reason, a community effort around Gemma, Tunix, and TPUs helped address an important gap.
To explore this challenge, developers joined a hackathon to train smaller Gemma models to reason more clearly. They used post-training methods that encouraged the models to “show their work” before giving an answer.
Why “Thinking” Matters for LLMs
Many user requests are simple. In those cases, they do not need deep reasoning. However, complex tasks often involve several steps.
For example, a model may need to solve a math problem, compare legal arguments, review medical details, or plan actions for a robot.
For these tasks, a direct answer may not be enough. Instead, a model that creates a structured reasoning trace can:
- Break a problem into smaller parts
- Lower the risk of unsupported conclusions
- Make its answer easier to review
- Improve results on tasks that require logic or planning
This is why Chain-of-Thought has become important in AI development. In short, it helps models organize information before they answer.
The Hackathon Context
The community training effort took place during the Google Tunix Hackathon on Kaggle. The challenge asked developers to take smaller Gemma base models and train them to produce structured reasoning.
Participants worked with models such as Gemma-2-2B and Gemma-3-1B. These models are much smaller than frontier-scale systems. Therefore, the challenge was more practical for a wider developer community.
At the same time, the compute budget was limited. Participants used Kaggle TPU v5e-8 resources for about 9 hours. This limit tested whether developers could improve reasoning without massive infrastructure.
Despite those limits, the hackathon drew thousands of entrants and hundreds of strong submissions. Overall, the results showed that careful training recipes can improve structured reasoning, even with limited compute.
The Role of Tunix and Kaggle TPUs
Tunix played a central role in the hackathon. It supports post-training workflows for models like Gemma. Participants used it to build training pipelines, create reward functions, and run methods such as supervised fine-tuning and reinforcement learning.
Meanwhile, Kaggle TPUs provided the hardware. TPUs, or Tensor Processing Units, are chips built to speed up machine learning workloads.
By using free or accessible TPU resources, the hackathon lowered the barrier for developers. As a result, more people could experiment with reasoning models without needing large private clusters or major funding.
Together, Tunix and Kaggle TPUs made the challenge more accessible. They also gave developers a practical way to test advanced post-training ideas.
Main Post-Training Methods
The winning teams used several post-training methods. Together, these methods helped teach Gemma models to produce reasoning traces before answers.
Supervised Fine-Tuning (SFT)
Supervised Fine-Tuning, or SFT, trains a model on examples of the desired behavior.
In this case, developers often wanted the model to follow a clear format. For example, the model would write its reasoning first and then provide the final answer.
Because of this, SFT can act as a “warm start.” It teaches the model what a good response should look like before more advanced training begins.
GRPO
GRPO is a reinforcement learning method. It helps improve model behavior through rewards.
Instead of only copying examples, the model receives feedback. This feedback can measure whether a response is useful, correct, well-formatted, or logical.
During the hackathon, some teams used reward systems that judged both the final answer and the reasoning process. In turn, this helped models improve their step-by-step logic.
SimPO
SimPO is a preference optimization method. It helps align model outputs with preferred responses. It can also use memory more efficiently than some other approaches.
For example, one winning team used SimPO to enforce strict formatting. The method also helped reduce unwanted behavior, such as overly long or poorly structured reasoning. As a result, the model produced more consistent outputs.
Winning Approaches
The top submissions used different combinations of SFT, GRPO, SimPO, reward models, and structured formats. Although the methods varied, each team aimed to help Gemma reason more clearly within a limited compute budget.
First Place: Rubric-Based Reinforcement Learning
The first-place team used G-RaR, or Rubric-Based Reinforcement Learning. This approach combined SFT with GRPO.
First, the team trained the model to follow a clear structure: reasoning first, then answer. Next, they used reinforcement learning to improve the quality of the reasoning.
A larger model acted as a judge. It reviewed the reasoning steps with rubrics, or scoring guides. Then, the team converted those scores into reward signals. These signals helped the smaller Gemma model improve.
This approach stood out because it did not depend only on exact right-or-wrong answers. That matters for open-ended tasks, where one simple correct answer may not exist.
Second Place: Pinocchio-1B
The second-place system, called Pinocchio-1B, trained a small 1B parameter model through a three-stage pipeline:
- SFT to teach basic Chain-of-Thought behavior
- SimPO to enforce clear formatting
- GRPO to improve logic, accuracy, and structure
In addition, the team customized Tunix for its workflow. They added a custom SimPO loss function. They also built an asynchronous evaluation system for reward signals.
This approach showed that a very small model can learn structured reasoning when developers design the training process carefully.
Third Place: IDEA-E Distillation with Curriculum-Guided GRPO
The third-place team used a structured ethical reasoning framework called IDEA-E. This framework guided the model through a step-by-step process before answering.
The team used SFT first. Then, they used GRPO with curriculum guidance. A curriculum moves training through tasks in a planned order, often from easier tasks to harder ones.
Instead of using a slower LLM judge for rewards, the team used a faster TF-IDF-based reward system. This encouraged relevant reasoning and helped avoid overly long responses.
Other Creative Contributions
Several other submissions also offered useful ideas for training reasoning models.
One approach used on-policy distillation. In this method, a larger teacher model creates reasoning traces during training. It does this based on the student model’s current behavior. As a result, the training loop becomes more dynamic.
Another project focused on custom dataset curation. It also used a reward model to evaluate the logical flow of reasoning, not just the final answer.
Together, these examples show that reasoning training does not depend on one method. Developers can combine datasets, reward functions, model judges, and formatting rules in different ways.
Domain-Specific Examples
The hackathon also included projects for specific fields. These examples showed how structured reasoning can support specialized tasks.
Medical Reasoning
In medical tasks, step-by-step reasoning can help models organize complex clinical information. It may also make outputs easier for people to review.
Chemistry
For chemistry problems, reasoning traces can help a smaller model work through multi-step scientific questions. This is useful when the answer depends on several facts or calculations.
Legal Analysis
Legal tasks often require careful review of rules, facts, and arguments. Structured reasoning can help models produce more organized and logical responses.
Robotics
Robotics tasks may involve planning, decision-making, and ordered actions. Step-by-step reasoning can help models handle multi-stage instructions or plans.
Taken together, these domain-specific examples suggest that Chain-of-Thought training can help beyond general question answering.
Why Accessibility and Reproducibility Matter
This effort mattered for more than final model performance. Just as importantly, it made training recipes easier to access and study.
Large labs often develop reasoning models with major compute resources. However, they do not always share the details of their training methods. This makes it hard for independent developers, students, and researchers to repeat or examine the work.
The Gemma, Tunix, and TPU hackathon helped address this gap by showing:
- How smaller open weight models can learn reasoning
- How limited compute can still produce useful results
- How developers can share and adapt post-training recipes
- How tools like Tunix can support experimentation
- How Kaggle TPUs can make advanced AI training more available
Reproducible methods help the wider AI community learn what works. They also make it easier to test models in different fields and improve them responsibly.
A Practical Step Toward More Open Reasoning Models
The community effort around Gemma showed that structured reasoning is not only for the largest frontier systems. With the right training methods, smaller models can also learn to produce reasoning traces before answering.
The hackathon highlighted practical methods such as SFT, GRPO, and SimPO. It also showed the value of reward design, teacher models, structured formats, and domain-specific training data.
Of course, these models do not replace careful human review, especially in sensitive areas such as medicine or law. Still, the work marks a useful step toward more accessible and reproducible AI development.
By combining Gemma, Tunix, and TPUs, the community showed that training LLMs to “think” can become more open, more practical, and easier for developers to explore.
