Can you coach a football AI smarter than everyone else's?
Eleven AI footballers play a full 90 minutes automatically. They're okay — but you can make them better. Fine-tune your football team using weight sliders. Or tell an AI chatbot what tactics to use in plain English, generate the Python code then paste into the custom scorer function. Then watch your team take on the opponent AI team. Play 1v1 against your friend. Participate in the World Cup Tournament. Host your own league and climb the leaderboard!
Same opponent. Same seeded match. Every team starts from the identical neutral setup.
Your coached team plays the Benchmark XI across a fixed set of competition seeds. The team with the best aggregate goal difference wins.
There's no single "shot" — it's 22 players in continuous time. Every tick, each of your players scores its options and picks the best:
Your job: change how they score. Each option is a sum of metrics × weights.
| Metric | What it measures | Weight · default |
|---|---|---|
| progression | ground gained toward goal | wProgression +1.00 |
| shot | shot quality (angle + distance) | wShot +1.00 |
| retention | possession security after the action | wRetention +1.00 |
| risk | chance of being cut out (a penalty) | wRisk −1.20 |
| support | how open the receiver is | wSuppOn +0.80 |
| Metric | What it measures | Weight · default |
|---|---|---|
| formation | sticking to the team's shape | wFormation +1.50 |
| space | open space at the target spot | wSpace +0.85 |
| support | being a useful passing option | wSuppOff +0.75 |
| press | urgency to close down the ball | wPress +0.85 |
| marking | denying the nearest opponent | wMarking +1.05 |
Use any AI tool to assist you — ChatGPT, Claude, Gemini, your choice.
Pick a formation (4-4-2, 4-3-3, 4-2-3-1, 3-5-2, 5-3-2, 4-5-1), then drag 8 sliders (each 0–100, neutral 50). They reshape your team and set all the weights at once.
| Slider | Low ↔ High | What it drives |
|---|---|---|
| Line Height | deep ↔ high | pushes the team up the pitch — springs the offside trap |
| Width | narrow ↔ wide | how far the team spreads sideways |
| Compactness | loose ↔ tight | vertical gaps between the lines |
| Press Intensity | passive ↔ aggressive | how readily players leave shape to close down |
| Press Restraint | over-commit ↔ disciplined | how few players join the press & how much shape they keep |
| Aggressiveness | contain ↔ commit | tackle commitment — wins more balls but concedes fouls & cards |
| Tempo | patient ↔ direct | how fast & directly the team progresses and shoots |
| Attacking Bias | defensive ↔ attacking | balance of attack vs defensive safety |
Rewrite the two scoring expressions in the Tier 2 panel. Each term is a metric × its weight (the weights still come from your sliders).
onBallUtility (default): progression*wProgression + retention*wRetention + support*wSuppOn - risk*wRisk + shot*wShot offBallUtility (default): formation*wFormation + space*wSpace + support*wSuppOff + press*wPress + marking*wMarking Custom examples: onBallUtility: progression**1.5*wProgression + support*wSuppOn - risk**2*wRisk + shot*wShot offBallUtility: space*wSpace + formation*wFormation + press*wPress*1.5
Available variables — on-ball: progression retention risk shot support (weights wProgression wRetention wRisk wShot wSuppOn). Off-ball: formation space support press marking (weights wFormation wSpace wSuppOff wPress wMarking).
Operators: + − * / // % **, comparisons, and / or / not, ternary (a if cond else b), and min / max / abs / round — a restricted, safe Python-style expression. No imports or loops.
In the Tier 3 panel, write a Python function that adds a bonus or penalty on top of the built-in score. It's clamped to [−5, +5] — decisive, but not dictatorial. Can't code? Describe your strategy in plain English and your AI tool writes it for you.
def score(game_state, action):
# game_state:
# ball {x, y, owner_side}
# me {x, y, role, has_ball}
# teammates [{x, y, role, onside}], opponents [{x, y, role}]
# score {us, them}, time_sec, possession
# second_last_opponent_x (for offside timing)
# action:
# kind: 'pass' | 'dribble' | 'shoot' | 'move'
# target {x, y} (pitch is 105 x 68; you attack toward x = 105)
# return a number: positive = encourage, negative = discourage
if action['kind'] == 'pass' and action['target']['x'] > 70:
return 2.0 # reward passes into the final third
return 0.0Built-in playstyle presets — sliders + a sample scorer in one click
The Benchmark XI is a frozen, transparent 4-4-2 mid-block with three documented weaknesses. Study them:
Pin it deep with possession, then attack the space it cedes.
It lags a switch of play from one flank to the other.
Bodies pile onto the ball and open space in behind.
Click ⚽ Run Match, then ▶ Play. Where do they lose the ball? Where does the opponent hurt you?
Copy the sample prompt below and paste it into any chatbot.
Formation + 8 sliders — the quick wins.
Reshape how each option is scored.
Tactics the defaults can't express — or start from a preset.
Click 🏆 Score vs Official Seed Set — see your aggregate goal difference.
Describe what changed, ask your AI to improve it.
Export your best config and submit it to the Leaderboard.
Copy this into your AI tool to get a full recommendation for sliders, formulas, and a custom scorer.
I'm coaching a team in a Football AI tactics challenge. Every tick, each of my 11
players scores its options and picks the best. On the ball, the carrier scores each
pass/dribble/shoot; off the ball, players score where to move. Each option is a sum
of metrics x weights.
On-ball metrics: progression (+, ground toward goal), shot (+, shot quality),
retention (+, possession security after the action), risk (-, chance of being cut
out), support (+, receiver openness). Weights: wProgression, wShot, wRetention,
wRisk, wSuppOn.
Off-ball metrics: formation (+, staying in shape), space (+, open space), support
(+, being a passing option), press (+, closing the ball), marking (+, denying the
nearest opponent). Weights: wFormation, wSpace, wSuppOff, wPress, wMarking.
I control the team with a formation (4-4-2, 4-3-3, 4-2-3-1, 3-5-2, 5-3-2, 4-5-1) and
8 sliders, each 0-100 (neutral 50): Line Height, Width, Compactness, Press Intensity,
Press Restraint, Aggressiveness, Tempo, Attacking Bias.
Default formulas:
onBallUtility: progression*wProgression + retention*wRetention + support*wSuppOn - risk*wRisk + shot*wShot
offBallUtility: formation*wFormation + space*wSpace + support*wSuppOff + press*wPress + marking*wMarking
The opponent is a frozen 4-4-2 mid-block whose (1) defensive line drops deep under
sustained pressure, (2) is slow to shift across / vulnerable to switches of play and
wide overloads, and (3) over-commits when pressing, leaving space to counter into.
Please recommend:
1. A formation and a value (0-100) for each of the 8 sliders.
2. Custom onBallUtility / offBallUtility formulas (or DEFAULT). Allowed: + - * / // % **,
comparisons, and/or/not, ternary (a if cond else b), min/max/abs/round.
3. A Python scorer that exploits the opponent's weaknesses:
def score(game_state, action): ... return a number (positive = good, negative = bad; clamped to [-5,+5])
game_state has ball {x,y,owner_side}, me {x,y,role,has_ball}, teammates [{x,y,role,onside}],
opponents [{x,y,role}], score {us,them}, time_sec, possession, second_last_opponent_x.
action has kind ('pass'|'dribble'|'shoot'|'move') and target {x,y}. The pitch is 105 x 68
and I attack toward x = 105. Allowed Python subset only (no imports/loops).My football AI concedes on the counter - it commits too many players forward and gets caught. Which sliders (Press Restraint, Attacking Bias, Line Height) should I change, and write a scorer that discourages off-ball 'move' targets deep in the opponent half when we don't have possession.
The opponent's back line drops deep when I keep the ball in their third. Write a Python scorer that rewards fast forward passes and shots once the ball is past x = 70, and suggest slider values (high Line Height + direct Tempo) to pin them back.
My team sits off and lets the opponent play out. What Press Intensity / Press Restraint values make them hunt the ball, and write a scorer that rewards off-ball 'move' targets close to the ball when the opponent has possession?
My Python scorer won't parse - here's the exact error message: <paste it>. Here's the function: <paste it>. Please fix it and keep it within the allowed subset (no imports/loops; only + - * / // % **, comparisons, and/or/not, ternary, min/max/abs/round, and dict/attr access on game_state/action).
How to describe a problem clearly so AI gives you useful answers — not just for football, for any task.
Testing ideas quickly, learning from what fails, and improving — the core loop of working with AI.
You don't need to code. You need to think strategically about what to optimise — and let AI handle the details.
Defining what you actually want is harder than it looks — and it's the most human part of the job.
Crank Aggressiveness to win more tackles and you'll also rack up fouls, cards, and a red — the classic "optimised the wrong objective." The hardest, most human part is defining what you actually want.
Don't perfect one idea for 10 minutes. Change → Run Match → check goal difference → adjust. Speed wins.
"My full-backs get caught upfield and we concede on the counter" beats "make it better."
If a formula or scorer won't parse, the panel shows the exact error — paste it to your AI tool for an instant fix.
Watch a match and read the Match Stats table. Where you lose the ball is your target.
Presets set sliders + a sample scorer in one click. Run each, compare, then ask AI to combine the best bits.
A config holds your formation, sliders, formulas, and scorer. Export before big changes so you can always return.