September 3, 2026

How Hackathon Teams Fine-Tuned and Deployed Small Mistral Models

Bigger models did not automatically produce better hackathon projects. Several teams at the 2026 Mistral Worldwide Hackathons achieved strong results by adapting smaller models to one task and running them close to the user.

Some fine-tuned Ministral 3B with LoRA or QLoRA. Others distilled larger models, reduced memory requirements through quantization, or routed each request to a model suited to the job. The resulting systems ran on Brev GPU instances, local machines, and Jetson hardware.

OrinReachyClaw compressed its on-device model from 6.4GB to 2GB. Deep Scout divided research between two fine-tuned 3B models. Ecotopia trained four specialized models in under ten minutes each and reported better structured output results than Mistral Large.

These projects show how hackathon teams approached model selection, fine-tuning, local inference, and deployment under practical hardware and time constraints.

Small Mistral Model Projects at a Glance

Events: Mistral Worldwide Hackathons 2026
Main approaches: LoRA, QLoRA, supervised fine-tuning, GRPO, distillation, quantization, and model routing
Deployment environments: Brev GPU instances, Hugging Face Inference Endpoints, NVIDIA Jetson hardware, and local systems
Featured projects: OrinReachyClaw, Deep Scout, Ecotopia, AiOrDie, Redline, and MISSI
Smallest models used: Ministral 3B models appeared in OrinReachyClaw, Deep Scout, and AiOrDie
On-device example: OrinReachyClaw reduced its model from 6.4GB to 2GB before deploying it to a Jetson Orin Nano Super with 8GB
Multi-model example: MISSI routed requests across eight Mistral models instead of sending every task to the same system
Explore the projects: View the Mistral Worldwide Hackathons submissions on Iterate

How Teams Adapted Small Mistral Models

The projects did not follow one standard path from a base model to deployment. Each team selected a method based on the task, available hardware, and role assigned to the model.

Fine-Tuning for a Defined Task

→ Deep Scout fine-tuned one model to generate better search queries and another to evaluate retrieved evidence. AiOrDie trained Ministral 3B to decide when it should use a tool and how it should issue warnings. Redline adapted a Mistral model to extract structured decision logic from HR policy documents.

These teams narrowed the model’s responsibility instead of asking it to handle the complete application.

Distillation

→ OrinReachyClaw distilled Ministral 3B from Mistral Large. The team used supervised fine-tuning and GRPO on an RTX 5090 before preparing the smaller model for deployment on edge hardware.

Quantization

→ The same project applied Q4_K_M quantization, reducing the model size from 6.4GB to 2GB. This allowed it to run as the on-device brain of a Reachy Mini connected to a Jetson Orin Nano Super with 8GB.

Model Routing

→ MISSI took a different approach. Rather than adapting one model for every request, it routed queries across eight Mistral models.

Small handled quick greetings, Large supported research and analysis, Magistral Medium covered reasoning and mathematics, Codestral handled code, Pixtral processed vision, and Voxtral supported speech. The routing happened automatically.

Local and GPU-Backed Inference

→ Several teams served their models outside a frontier API. Deep Scout ran two fine-tuned models through vLLM on a GPU-backed Brev instance. Vibecraft also used vLLM on Brev to serve Voxtral-3B, Ministral3-14B, and Qwen3-TTS-1.7B.

Other projects moved inference directly onto Jetson hardware, with an API fallback reserved for tasks the local system could not handle.

Small Mistral Model Fine-Tuning and Deployment Examples

OrinReachyClaw: Distilling a Model for an On-Device Robot

OrinReachyClaw placed a compact language model inside Reachy Mini, Hugging Face’s desktop robot. The team aimed to move as much inference as possible onto the device instead of sending every request to an external API.

They distilled Ministral 3B from Mistral Large using supervised fine-tuning and GRPO on an RTX 5090. Q4_K_M quantization then reduced the model from 6.4GB to 2GB.

The compressed model ran on a Jetson Orin Nano Super with 8GB. It handled chat, robot control, and tool calls for web search, Spotify, calendars, email, and smart-home systems. The project reported sub-second latency for its local-first architecture.

More complex reasoning could fall back to the Mistral API. Pixtral covered vision, while Voxtral handled speech-to-text. The robot also used a camera, four microphones, a speaker, a six-degree-of-freedom head, and antenna movements for emotional expression.

The team tracked training across six Weights & Biases runs. Its stated target was to operate the entire stack on a single $249 Jetson.

Deep Scout: Splitting Research Between Two Fine-Tuned Models

Deep Scout used two fine-tuned Ministral-3-3B-Instruct models to build a local-first research assistant. Instead of assigning search preparation, source evaluation, and answer generation to one large model, the team separated the workflow.

The first model converted a user’s question into an optimized web search query. The system then searched Brave or DuckDuckGo for live information.

A second model reviewed the retrieved material, ranked the sources, and produced a structured answer grounded in that evidence. Both models were fine-tuned with LoRA and served through vLLM on a GPU-backed Brev instance.

Users accessed the system through a Chrome extension, while port forwarding connected the interface to the locally reachable models.

Ecotopia: Fine-Tuning Models for Structured Simulation

Ecotopia was a political simulation game in which the player acted as the mayor of a city facing ecological collapse. Players delivered free-text speeches, and the models converted their words into structured information.

The system extracted promises, identified contradictions with earlier statements, and generated responses from the city’s residents. Each result had to follow a structured JSON format so the game could use it.

The team fine-tuned four models with QLoRA using 690 synthetic examples. Each training run took less than ten minutes. According to the team’s reported results, its 8B model outperformed Mistral Large across every structured output metric while delivering one-tenth of the latency and near-zero cost.

The project used Spring Boot, Phaser 3, Hugging Face Inference Endpoints, and Weights & Biases.

AiOrDie: Running a Safety-Focused Agent Offline

AiOrDie was built for situations where an internet connection may not be available. The system identified potentially dangerous wild species from a photograph while operating offline.

The team fine-tuned Ministral-3B to decide when it should call a tool and how to communicate a warning. Instead of relying on the model to recall safety-critical facts, the application stored that information in a local database.

This separation gave the model a defined role: interpret the request, select the necessary tool, and present the result. The factual information used for identification remained outside the model.

AiOrDie took third place overall at Mistral Hack Tokyo.

Redline: Extracting Rules From HR Policies

Redline checked HR policies against California and US federal labor rules. Team Redline finished second overall at Mistral Hack Paris.

The project used a fine-tuned Mistral model to extract structured decision logic from unstructured policy documents. A deterministic comparison engine then checked that structure against the applicable rules.

The model organized the source material, while regular code performed the compliance verification. This made the reasoning behind each result easier to inspect than an answer generated entirely inside a language model.

The team also created an autonomous improvement loop with Weights & Biases. It evaluated the extraction process and optimized the schema used by the model. The local engine was prepared for NVIDIA hardware.

MISSI: Routing Requests Across Eight Models

MISSI used model routing instead of sending every request to one general-purpose system. The voice-first AI operating system selected a model according to the type of input it received.

Mistral Large handled research and analysis, while Mistral Small answered simple greetings that required a faster response. Magistral Medium covered reasoning and mathematics, Mistral Medium handled creative writing, and Codestral generated code. Pixtral and Voxtral supported vision and speech.

The routing happened automatically, without asking the user to choose a model. This architecture matched the amount and type of compute to the task before generating a response.

MISSI received 40 public votes during the Mistral Worldwide Hackathons.

Vibecraft: Serving Multiple Models on a Brev Instance

Vibecraft turned natural-language instructions into working redstone circuits inside Minecraft. The project connected language models with a custom programming workflow rather than fine-tuning one model for the entire task.

A beginner-friendly subset of Python compiled to Verilog. The system then synthesized the Verilog into a redstone graph and built the resulting circuit inside the game.

The team developed the domain-specific language and its Verilog compiler. It also brought MinecraftHDL, a nine-year-old research project, to a modern version of Minecraft and added variable management.

Voxtral-3B handled speech recognition, Ministral3-14B supported language tasks, and Qwen3-TTS-1.7B generated speech. All three models ran through vLLM on a Brev NVIDIA instance.

Small Mistral Model Projects Compared

Project	Model approach	Training or optimization method	Deployment
OrinReachyClaw	Compact on-device model with API fallback	SFT, GRPO, distillation, and Q4_K_M quantization	Jetson Orin Nano Super
Deep Scout	Two specialized 3B models	LoRA fine-tuning	vLLM on a Brev GPU instance
Ecotopia	Four models trained for structured game outputs	QLoRA on 690 synthetic examples	Hugging Face Inference Endpoints
AiOrDie	Offline tool-calling and warning model	Fine-tuned Ministral-3B	Offline-first system
Redline	Model for structured policy extraction	Fine-tuned Mistral model	Local engine optimized for NVIDIA hardware
MISSI	Eight models selected by request type	Automatic model routing	Voice-first AI operating system
Vibecraft	Separate models for speech, language, and voice output	Multi-model orchestration	vLLM on a Brev NVIDIA instance

What These Hackathon Projects Show About Small Models

One Application Can Use Several Specialized Models

Deep Scout separated query generation from evidence assessment. MISSI routed requests according to the required capability, while Vibecraft assigned speech recognition, language processing, and voice output to different models.

These projects did not treat model selection as a single decision made for the whole product. They chose a model for each step of the workflow.

Local Models Can Work Alongside APIs

OrinReachyClaw handled chat, tools, and robot control on-device but retained access to the Mistral API for complex reasoning. Vision and speech also went through separate models.

The resulting architecture was local-first rather than local-only. It moved supported tasks onto the device without requiring every capability to run through the same compact model.

Fine-Tuning Can Target Output Structure

Ecotopia trained its models to transform free-text speeches into structured JSON. Redline focused on extracting decision logic from policy documents, and Deep Scout trained separate models around defined stages of a research workflow.

In each case, the fine-tuning objective matched a format or task that the surrounding application could use directly.

Quantization Makes Edge Deployment More Practical

OrinReachyClaw reduced its model from 6.4GB to 2GB with Q4_K_M quantization. The smaller version could then run on a Jetson Orin Nano Super with 8GB.

The project provides a concrete example of quantization being used to fit a model onto limited hardware rather than simply reducing storage requirements.

Models Do Not Need to Store Every Fact

AiOrDie kept its safety-critical information in a local database. The fine-tuned model decided when to call a tool and how to communicate the warning, while the database supplied the underlying facts.

This division placed factual retrieval and language generation in separate parts of the system.

Choosing an Approach for a Small Mistral Model Project

The hackathon submissions used different methods because they faced different technical constraints.

Use task-specific fine-tuning when the model needs to produce a defined output or perform one repeated function. Deep Scout, AiOrDie, and Redline followed this approach.
Use quantization when a model must fit within the memory limits of edge hardware. OrinReachyClaw used Q4_K_M before deploying its model to a Jetson.
Use model routing when requests vary enough to require different capabilities. MISSI selected among eight models in real time.
Use several specialized models when the application contains distinct stages. Deep Scout separated search-query generation from evidence evaluation.
Keep facts outside the model when the application depends on a controlled data source. AiOrDie stored safety information in a local database.
Retain an API fallback when the local model does not cover every request. OrinReachyClaw reserved the Mistral API for more complex reasoning.

Run a Model Fine-Tuning Hackathon With Iterate!

A short build event gives teams a practical setting in which to compare fine-tuning, quantization, routing, and local deployment approaches. The Mistral hackathon projects produced working examples across research, robotics, compliance, games, and offline assistance.

Want to explore what a smaller, specialized model could handle inside your product? Run a hackathon with Iterate and bring teams together to train, test, and present working AI systems around a defined use case.

Conclusion

The Mistral Worldwide Hackathons produced several alternatives to building every application around one large model. Teams divided workflows between specialized models, fine-tuned compact models for precise outputs, reduced memory requirements, and combined local inference with targeted API calls.

OrinReachyClaw demonstrated edge deployment after distillation and quantization. Deep Scout split research between two fine-tuned 3B models. Ecotopia trained four models for structured simulation outputs, while MISSI routed queries across eight different systems.

Together, the projects show how model architecture can follow the needs of an application rather than the assumption that every task requires the largest available model.

Frequently Asked Questions

What is a small Mistral model?

The projects covered here used compact Mistral models such as Ministral 3B alongside larger or specialized models. Teams selected them for task-specific fine-tuning, local inference, and deployment on hardware with limited memory.

Which fine-tuning methods did the teams use?

The documented methods included LoRA, QLoRA, supervised fine-tuning, and GRPO. OrinReachyClaw also used distillation from Mistral Large before quantizing its smaller model.

Can a Mistral model run on a Jetson?

OrinReachyClaw deployed a quantized Ministral 3B model to a Jetson Orin Nano Super with 8GB. The team reduced the model from 6.4GB to 2GB using Q4_K_M quantization.

Why did Deep Scout use two fine-tuned models?

One model converted the user’s question into a search query. The second evaluated the retrieved evidence, ranked sources, and generated a structured answer. Separating the tasks allowed each model to focus on one stage of the research workflow.

What is model routing?

Model routing sends a request to a model selected for that type of task. MISSI used this approach across eight Mistral models, assigning different systems to research, greetings, reasoning, creative writing, coding, vision, and speech.

Do local AI systems need to avoid external APIs entirely?

Not necessarily. OrinReachyClaw handled several functions on-device but retained the Mistral API as a fallback for complex reasoning. Its architecture combined local inference with external support for tasks beyond the compact model’s role.