Titan: AI bots that learned from real players

How 4,600 hours of human play became a fast, map-aware AI squad that can move, look, remember and coordinate in real time.

Counter-Strike player at a gaming monitor with an armored soldier behind him

Picture five football players walking onto a pitch together for the first time. Nobody hands them a script for every step. One scans the space ahead. Another tracks the defender who disappeared behind his shoulder. A third changes pace to open a passing lane. Someone calls out danger, and the whole team adjusts before the ball arrives.

That is what makes a team feel intelligent. Each player controls their own body, but every decision belongs to a shared situation.

Most game bots follow choreography. Titan learned by watching people play.

Titan is our family of AI models for Counter-Strike 2. It sits inside a complete bot stack built to play live on a real CS2 server: moving through Dust2, checking angles, remembering danger, sharing information and coordinating around the bomb sites. The goal was never to make one giant model do everything. We built a squad of specialists, each responsible for one part of the game.

A squad inside every bot

Every 125 milliseconds, several systems contribute to the next decision. Together they turn a changing match into movement, aim and teamwork that can be executed by the server.

The Tactician
Sets the objective: push, plant, cover, hold, rotate, retake or defuse.
The Map Reader
Finds a route across Dust2 and chooses a useful waypoint roughly ten seconds ahead.
The Movement Brain
Titan decides the direction, pace, stance and whether the bot should jump.
The Hands
Titan-walk turns that intention into W, A, S, D, jump, crouch and walk commands.
The Eyes
A learned aim model predicts where a player would look from the current position and situation.
The Instinct
Threat memory keeps track of recent danger and shares it across the team.
The Trigger Finger
Combat logic takes over when an enemy appears and applies weapon-specific firing rhythm.

The pieces are deliberately modular. The Tactician decides what should happen. The learned models decide how a player would carry it out. The server receives one clean package of controls and plays it back tick by tick.

A billion lessons from real matches

Titan learned movement from recorded human play. Its training data contains 12,646 matches and 1.07 billion game moments, equivalent to more than 4,600 hours of Counter-Strike 2. At every moment, the model can study the positions, movement, view and actions of all ten players together.

One match became millions of lessons. Thousands of matches became a sense for how players move.

A match recording shows what a player did, but not what they intended to do. We solved that with hindsight. During training, Titan sees where a player will be ten seconds later and learns the movement that gets them there. During live play, the Tactician provides the destination and the Map Reader turns it into the same kind of future waypoint.

From there, Titan chooses between 97 movement actions: sixteen directions relative to the camera, three movement styles, jump or no jump, plus stop. It is the vocabulary of movement a human player already understands intuitively.

The brain and the hands

Knowing where to move is not the same as pressing the right keys. Titan therefore works as a pair. The Movement Brain chooses the intention. Titan-walk, the Hands, turns it into exact keyboard controls for each of the next eight server ticks.

The Hands learned directly from human key presses, including strafes, counter-strafes and the timing of walking and crouching. It also knows where the camera will point next, because movement in Counter-Strike is always relative to the crosshair. A training constraint taught it to avoid a combination real players almost never use: crouch and walk together. The resulting co-press rate is just 0.0008%.

The brain chooses the move. The hands make it real.

One model sees the whole match

Titan does not make ten isolated decisions. It represents every player as a token inside one transformer, the same broad family of architecture behind modern language models. Each player can be understood in the context of the other nine: teammates, opponents, visibility and the shape of the round.

The model is deliberately small: 1.4 million parameters. A complete Titan v4 decision for all ten players takes less than one millisecond on a single CPU thread. That leaves the rest of the 125-millisecond cycle for tactics, routing, visibility, memory, aim and communication with the game server.

One model. Ten players. Less than one millisecond.

Dust2, read like a local

Earlier models could learn where walls probably were by observing where people walked. Titan v4 goes further: it can read the map itself. Dust2 becomes a graph of 2,243 navigation areas, connected by 5,150 walkable links, 648 drops and 473 jumps.

The Map Reader has roughly five million precomputed routes available before the round begins. It plans toward the destination, identifies the next useful waypoint and tells Titan what lies ahead. Eight virtual “whiskers” measure nearby walls, while map-area embeddings tell the model where it is, where it is going and which parts of the route come next.

The result is more than pathfinding. The bot can connect a tactical objective with movement that understands corners, elevation, jumps and the geometry around it.

Eyes that learned where players look

Movement is only half the story. A strong player keeps the crosshair somewhere useful even when no enemy is visible: on the next corner, down a corridor or at the entrance to a bomb site. Our Eyes model learned those habits from 200 million examples of real players looking around Dust2.

Its 7,200 decision trees use position, team, round time, bomb state and the route ahead to predict a useful direction. We deliberately removed the easiest shortcut—the player’s current view—from its inputs. Without that clue, the model has to learn the relationship between the map and the situation instead of simply repeating where the camera already points.

The final camera stays calm through sticky choices, smooth turns and natural pauses on an angle. When an enemy becomes visible, the combat layer adds varied aim points and weapon-specific bursts rather than using one identical response every time.

A team that remembers together

A football defender does not forget an attacker the moment he runs behind another player. Counter-Strike works the same way. Titan’s threat memory keeps recent danger alive after it leaves the screen: an enemy sighting, gunfire, damage or bomb activity.

Those memories are shared. When one bot spots an enemy, its teammates can react during the same decision cycle. Each memory fades with a two-second half-life, so fresh information matters most and old information gradually loses influence. The stack also computes its own smoke-aware line of sight for every player pair on every cycle.

One bot sees the danger. The whole team changes its next move.

From idea to live gameplay in 12 weeks

The first Titan prototype started with 300 matches and already chose the correct movement action 74% of the time. Each version then solved one focused problem: movement history, goals, real keystrokes, visibility, short-term memory, future position prediction and finally direct map awareness.

Twelve weeks after the first line of code, the complete stack reached live gameplay on our CS2 server. Getting there required far more than a model: a custom server plugin, a modular real-time pipeline, diagnostic tools, repeatable battle scenarios, deterministic replays and 983 automated tests.

Every cycle now follows the same rhythm: sense the match, remember what matters, assign the objective, plan the route, choose the view, decide the movement, press the keys and send the next eight ticks back to the server. Then it starts again, eight times every second.

The next player is a team

Back on the football pitch, intelligence was never one perfect kick. It was the chain between seeing space, remembering pressure, choosing a run and trusting the team to respond.

That is the idea behind Titan. Not a bot waiting for the next scripted instruction, but a fast collection of learned skills and tactical systems sharing one evolving picture of the game.

Titan learned from players so AI teammates can begin to play like a team.

More from the blog