---
title: "Global Leaders"
kind: "Kit"
category: "Companions"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/602877db-7b56-4b62-83ca-2a1da1ecd223"
updated: "2026-11-12"
---

# Global Leaders

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Lets you govern a real world leader through the real events of 2025 in a strategy game, with a small language model as game master and a code engine that keeps the rules fair.

Global Leaders is a kit in the Companions category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by build-small-hackathon

## About

### What it is

Global Leaders is a political strategy game. Starting on 1 January 2025, you run one real world leader for a full year and answer the actual news of those months. A small language model plays game master. As game master it sets your objectives, speaks for the cabinet and the opposition, tells the story of every crisis and decides how your choices land. It was built for the Build Small hackathon.

### Who it suits

It suits people who enjoy strategy and simulation games, and developers who want to see how a small model can run a game without breaking its rules.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Games | Strategy game fans | Pick a leader and play through twelve months of crises | Govern France through a trade dispute |
| Education | Teachers of politics and case studies | Use the game for case-method decisions with no single right answer | Discuss a class member's choices after a round |
| AI development | Builders of small-model apps | Study how a code engine and a model share the work | Read the engine folder and the game design file |
| Research | Language model researchers | See how a model is kept inside a schema and guardrails | Review how failed outputs are retried |

You can skip it if you want a game with a fixed storyline, since the model narrates and judges your moves as you go.

### Where to use it

- A web browser: open the Space page on Hugging Face, where the app runs on cpu-basic hardware.
- Windows, macOS or Linux: run a copy with Python.
- A local model setup: the README says the game can also run fully locally through Ollama.

| Use case | Who | What they get back |
| --- | --- | --- |
| Play a leader | Game players | Crises to answer and a score that follows your calls |
| Type your own move | Players | The model interprets it and the engine applies the effect |
| Study the design | Developers | Rules, game design and country scenario files to read |

### How to set it up

The hosted page needs nothing from you. A local copy needs these things first.

- Python on Windows, macOS or Linux.
- pip, which installs the packages.
- The settings listed in the .env.example file.
- A model behind the game: the README names a self-hosted setup on Modal, or a local one through Ollama.

1. Install the huggingface\_hub package with pip.
2. Download the Space's files into a folder with the hf command.
3. Move into that folder.
4. Install Gradio 6.17.3, then the packages listed in requirements.txt.
5. Fill in the settings from .env.example, then start the app with Python.

```sh
pip install -U huggingface_hub
hf download build-small-hackathon/global-leaders --repo-type space --local-dir global-leaders
cd global-leaders
pip install gradio==6.17.3
pip install -r requirements.txt
python app.py
```

### How to use it

Online, open the Space page and pick a leader. On your own computer, run the last command above inside the downloaded folder. Then choose one of the suggested moves for each crisis, or type your own and let the model interpret it.

There are six leaders to pick from. Each has a deck of real 2025 events, both domestic and international, and a cast of eight to twelve real figures who reward or punish you by their own interests.

| Tool | What it does |
| --- | --- |
| app.py | Starts the Gradio game |
| engine | Holds the deterministic rules engine |
| GAME\_RULES.md | The rules of the game |
| GAME\_DESIGN.md | The design notes |
| COUNTRY\_SCENARIOS.md | The scenarios for each country |

### Example

You take the chair of the French president in the middle of 2025. A headline says a trade deal has collapsed under new tariffs, and your rivals and allies push you in different directions. You choose a suggested move or type your own, and the engine applies the effect.

### For newcomers and experts

If you are new, open the hosted page, pick a leader and play the first crisis with one of the suggested moves. Typing your own move comes after that.

If you know the field, the design gives the code the truth and the model only the story. A deterministic Python engine owns the eight indicators, the hidden faction meters, the dice and the win and lose logic. The model proposes effects through a validated JSON schema, retried on failure, and the engine clamps them to legal ranges and enforces a trade-off. A built-in fake model keeps the demo running without a key. The model named is NVIDIA Nemotron 30B-A3B, with about 3B active.

A real 2025 crisis appears → The model narrates it and proposes effects → The engine checks and clamps the effects → Your move and the dice decide the outcome → Indicators update and the next crisis starts

### Good to know

The model is kept inside a schema and a rules engine, so it can be inventive in the story but cannot break the game. Reasoning is off and history is compressed to save tokens, and the header shows a live token count.

- License: mit
- Cost to run: the live model is self-hosted on Modal, or you can run it locally with Ollama, and without a key a built-in fake model runs the demo
- Data it reaches: whatever you type as a move, and the model service you connect
- Coverage: six leaders and the year 2025 only

## README

````markdown
# Global Leaders

Lets you govern a real world leader through the real events of 2025 in a strategy game, with a small language model as game master and a code engine that keeps the rules fair.

Made by build-small-hackathon on Hugging Face. These notes are Mindket's, written from its Space page and README; the app's own files and license are on Hugging Face.

## About

What it is: Global Leaders is a political strategy game. Starting on 1 January 2025, you run one real world leader for a full year and answer the actual news of those months. A small language model plays game master. As game master it sets your objectives, speaks for the cabinet and the opposition, tells the story of every crisis and decides how your choices land. It was built for the Build Small hackathon.

Who it suits: It suits people who enjoy strategy and simulation games, and developers who want to see how a small model can run a game without breaking its rules.

```table
Industry | Who uses it | How they use it | Example
Games | Strategy game fans | Pick a leader and play through twelve months of crises | Govern France through a trade dispute
Education | Teachers of politics and case studies | Use the game for case-method decisions with no single right answer | Discuss a class member's choices after a round
AI development | Builders of small-model apps | Study how a code engine and a model share the work | Read the engine folder and the game design file
Research | Language model researchers | See how a model is kept inside a schema and guardrails | Review how failed outputs are retried
```

You can skip it if you want a game with a fixed storyline, since the model narrates and judges your moves as you go.

Where to use it:

- A web browser: open the Space page on Hugging Face, where the app runs on cpu-basic hardware.
- Windows, macOS or Linux: run a copy with Python.
- A local model setup: the README says the game can also run fully locally through Ollama.

```table
Use case | Who | What they get back
Play a leader | Game players | Crises to answer and a score that follows your calls
Type your own move | Players | The model interprets it and the engine applies the effect
Study the design | Developers | Rules, game design and country scenario files to read
```

How to set it up: The hosted page needs nothing from you. A local copy needs these things first.

- Python on Windows, macOS or Linux.
- pip, which installs the packages.
- The settings listed in the .env.example file.
- A model behind the game: the README names a self-hosted setup on Modal, or a local one through Ollama.

1. Install the huggingface_hub package with pip.
2. Download the Space's files into a folder with the hf command.
3. Move into that folder.
4. Install Gradio 6.17.3, then the packages listed in requirements.txt.
5. Fill in the settings from .env.example, then start the app with Python.

```sh
pip install -U huggingface_hub
hf download build-small-hackathon/global-leaders --repo-type space --local-dir global-leaders
cd global-leaders
pip install gradio==6.17.3
pip install -r requirements.txt
python app.py
```

How to use it: Online, open the Space page and pick a leader. On your own computer, run the last command above inside the downloaded folder. Then choose one of the suggested moves for each crisis, or type your own and let the model interpret it.

There are six leaders to pick from. Each has a deck of real 2025 events, both domestic and international, and a cast of eight to twelve real figures who reward or punish you by their own interests.

```table
Tool | What it does
app.py | Starts the Gradio game
engine | Holds the deterministic rules engine
GAME_RULES.md | The rules of the game
GAME_DESIGN.md | The design notes
COUNTRY_SCENARIOS.md | The scenarios for each country
```

Example: You take the chair of the French president in the middle of 2025. A headline says a trade deal has collapsed under new tariffs, and your rivals and allies push you in different directions. You choose a suggested move or type your own, and the engine applies the effect.

For newcomers and experts: If you are new, open the hosted page, pick a leader and play the first crisis with one of the suggested moves. Typing your own move comes after that.

If you know the field, the design gives the code the truth and the model only the story. A deterministic Python engine owns the eight indicators, the hidden faction meters, the dice and the win and lose logic. The model proposes effects through a validated JSON schema, retried on failure, and the engine clamps them to legal ranges and enforces a trade-off. A built-in fake model keeps the demo running without a key. The model named is NVIDIA Nemotron 30B-A3B, with about 3B active.

```flow
A real 2025 crisis appears
The model narrates it and proposes effects
The engine checks and clamps the effects
Your move and the dice decide the outcome
Indicators update and the next crisis starts
```

Good to know: The model is kept inside a schema and a rules engine, so it can be inventive in the story but cannot break the game. Reasoning is off and history is compressed to save tokens, and the header shows a live token count.

- License: mit
- Cost to run: the live model is self-hosted on Modal, or you can run it locally with Ollama, and without a key a built-in fake model runs the demo
- Data it reaches: whatever you type as a move, and the model service you connect
- Coverage: six leaders and the year 2025 only

## On Hugging Face, 13 November 2026

- Likes: 7
- Built with: gradio
- License: mit

## Links

- Space: https://huggingface.co/spaces/build-small-hackathon/global-leaders
- Files: https://huggingface.co/spaces/build-small-hackathon/global-leaders/tree/main

## Try it

Open the Space in your browser, or copy it to your own Hugging Face account from its page. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[build-small-hackathon/global-leaders on Hugging Face](https://huggingface.co/spaces/build-small-hackathon/global-leaders)

## Compare with similar

Listed Hugging Face Spaces in the same category that share the most tags with this one.

| Product | Likes | Built with | License | Last change |
| --- | --- | --- | --- | --- |
| Global Leaders (this page) | 7 | gradio | mit | 2026-06-15 |
| [Rick \& Morty Bot](https://mindket.com/p/d0c22d56-879e-4f7c-aa3b-b19a6ab7dd6a) | 9 | gradio | apache-2.0 | 2025-06-17 |
| [GPT2-XL Conversational](https://mindket.com/p/8f7e6a03-bd1e-421c-8f6d-ceb32af96c43) | 8 | gradio | apache-2.0 | 2022-11-30 |
| [Reachy Stories](https://mindket.com/p/4924d6a6-2a33-4c5b-8c2c-6e7801f9875a) | 1 | gradio | apache-2.0 | 2026-06-02 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-06-15
- First published: 2026-06-07
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open build-small-hackathon/global-leaders on Hugging Face](https://huggingface.co/spaces/build-small-hackathon/global-leaders)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/602877db-7b56-4b62-83ca-2a1da1ecd223)
- [Its page on Mindket](https://mindket.com/p/602877db-7b56-4b62-83ca-2a1da1ecd223)
