Raven

Every esports team captain has done this by hand at least once: open Discord, scroll through a dozen "I can play Thursday after 8" messages, cross-reference them against who plays Tank versus DPS, remember that one of your DPS is actually a sub, and try to assemble a starting five that can actually scrim tonight. It takes fifteen minutes, you get it slightly wrong, and you do it again the next day.

I build Supatimer, a free Discord bot for competitive gaming teams, and "generate the lineup for me" was the single most requested feature. This post is about how the lineup optimizer actually works, why it is genuinely AI (and not in the marketing sense), and where a large language model fits in versus where it absolutely does not.

"AI" is doing a lot of work in this industry

Half the Discord bots on the market slapped "AI" on their landing page the week ChatGPT launched. Usually it means there is a chatbot command somewhere that proxies to an LLM. That is fine, but it is not what your team needs when it is 7:45pm and you have a scrim at 8.

There are two honest definitions of AI worth separating:

  1. Search and optimization - the classical branch. Constraint satisfaction, combinatorial optimization, planning. This is the part of AI that solves "given these rules and these resources, find the best valid arrangement."
  2. Machine learning / LLMs - the statistical branch. Pattern recognition, generation, extraction from unstructured text.

The lineup problem is squarely a problem for the first kind. So that is what I built first.

The lineup problem, stated precisely

Strip away the gaming context and a lineup is a constrained assignment problem:

  • You have N players, each with a set of roles they can fill (Tank, DPS, Support, IGL, and so on).
  • Each player has an availability signal for a given time block (available, maybe, unavailable).
  • Each player has a roster status (starter, substitute, trial).
  • The game defines a required composition: Overwatch 2 wants 1 Tank, 2 DPS, 2 Support. Valorant wants 5 with flexible roles. CS2 wants 5.
  • You want the lineup that maximizes role coverage and availability confidence, preferring starters over subs, hard "available" over "maybe."

That is a textbook constraint satisfaction problem with an objective function on top. You are not asking a model to guess. You are enumerating feasible assignments and ranking them by an explicit score.

How the optimizer works

The core loop is unglamorous and that is the point:

1. Filter the player pool to "available" + "maybe" for the target time block.
2. Generate candidate assignments that satisfy the required composition
   (every required role slot filled by a player who can play that role).
3. Prune assignments that violate hard constraints
   (a player can't occupy two slots; required roles must be covered).
4. Score each surviving candidate:
       coverage  = required roles actually filled
       confidence = sum of availability weights (available > maybe)
       priority  = starters weighted above subs above trials
   score = w1*coverage + w2*confidence + w3*priority
5. Return the top-ranked lineup, plus the next best alternatives.

Enter fullscreen mode Exit fullscreen mode

For a 5-to-6 player slot out of a roster of 7-10, the candidate space is small enough to enumerate exhaustively in well under a second. There is no heuristic guessing and no "the model thinks this is good" hand-waving. If the optimizer says these five players give you full role coverage at the highest availability confidence, you can read exactly why.

The captain's job shifts from building the lineup to reviewing and overriding one. That is the whole ergonomic win. In Discord it is one command: /weekplan shows the optimal lineup for every block in the week, and /early-lineup focuses a single upcoming window.

Why not just ask an LLM?

This is the part developers tend to get wrong in 2026, so it is worth being blunt: you should not use a language model to pick a lineup.

  • It can violate hard constraints. An LLM will happily hand you a "lineup" with two Tanks and no Support because it pattern-matched plausible-looking output. A constraint solver cannot, by construction.
  • It is not auditable. When a captain asks "why is my main DPS benched?" you need a real answer ("they marked maybe, and the optimizer preferred a starter who marked available"), not a probability distribution.
  • It is slow and nondeterministic for something that should be instant and identical every time you run it on the same data.

The optimization problem is small, well-defined, and rule-bound. That is exactly the regime where classical AI beats a language model, and pretending otherwise just to claim "LLM-powered" would make the product worse.

Where the LLM does earn its place

There is one spot in the scrim workflow that is genuinely a language problem: the messy DM you get from the opposing team.

"yo we can run tn at 9 your time, bo3, we ban bind you ban split, our discord is ..."

That is unstructured natural language with time, format, map veto, and contact details all tangled together. Parsing it with regex is a losing battle. So Supatimer has a second, separate AI system: an LLM scrim parser (currently in beta) that extracts structured fields - time, opponent, format, map vetoes, lobby details - from any free-form scrim message and turns them into a clean confirmation.

That is the right tool for the right job: a language model for the language problem, a constraint solver for the constraint problem. Two different systems, neither one pretending to be the other.

A few things I learned

  • Model the domain before you model the math. Getting "roster status" and "maybe availability" into the data model was 80% of the work. The optimizer itself is short once the inputs are clean.
  • Determinism is a feature. Teams trust a tool they can predict. Same availability in, same lineup out, every time.
  • Explainability sells. Showing why a lineup was chosen converts skeptics faster than any accuracy claim.
  • Resist the urge to LLM everything. The interesting engineering was deciding what not to hand to a language model.

Try it

The lineup optimizer is live in Supatimer right now, free, for 21 competitive games with role presets already configured. Players mark availability by tapping buttons on a weekly calendar in Discord, and /weekplan builds the lineup. The scrim tooling handles confirmations and score tracking, and the LLM scrim parser is rolling out in beta.

If you run a competitive team and you are still building lineups by hand from scattered "I can play Thursday" messages, you do not have to.

I'm Raven, the developer behind Supatimer. I built the optimizer because I was tired of assembling Overwatch lineups by hand every night. Questions, feedback, or want to nerd out about constraint solvers? Find me on the Supatimer Discord.