Citadel Securities Terminal Guide

What is Citadel Securities Terminal?

Terminal is an online algorithmic game competition organised through Citadel Securities. Instead of answering interview questions, competitors write software that makes decisions inside a game, then see how their strategies perform against other teams.

The game has a tower defence format. Your algorithm decides how to place defensive structures, deploy attacking units and respond to the opponent using limited resources.

Terminal rewards practical engineering. A simple algorithm that runs reliably and exploits a real weakness in the opponent can outperform a complicated strategy that has not been tested.

This is separate from Citadel Securities job recruitment and the firm's Trading Invitational. Terminal is designed around software strategy and competitive programming, rather than simulated market making or a conventional trading interview.

Who can enter Terminal?

Terminal targets university students with basic programming knowledge and strong interests in mathematics, engineering, computer science, statistics, physics, economics or related subjects. Applicants must be at least 18, in good academic standing and eligible for the region in which they apply.

Regional eligibility matters more than the location of your university's headquarters. Match your actual residence, degree level and event listing before submitting an application.

If you study in Australia, the Asia regional eligibility is the relevant starting point. Check the specific event application for its academic requirements and participating countries when a new intake opens.

How to apply for Citadel Securities Terminal

Application is the selection stage, not the tournament. You first apply for an eligible regional event and complete the required online assessment, then selected applicants receive instructions to join the game platform and form a team.

1. Choose your regional event. Open the Citadel Securities Terminal page and select an event matching your residence, student status and availability.
2. Submit your application. Provide accurate academic details, relevant programming experience and the materials requested in the application form.
3. Complete the short assessment. Watch for an email from Citadel People Systems and finish the assessment by the stated deadline. The general Terminal FAQ also explains the assessment form for applicants who have not applied to a Terminal event within the past year.
4. Accept your place. Respond to your participation invitation and complete the requested eligibility and registration paperwork.
5. Join your team and platform. Selected participants receive access to Terminal and assistance forming teams with other accepted applicants.

How to prepare for the entry assessment

Make sure you can write small, correct programs and reason about data structures, loops, state changes and simple algorithmic choices. For an EverythingQuant practice benchmark, solve one intermediate coding exercise in 30 minutes and spend another 15 minutes testing edge cases and explaining your approach.

Have one substantial project ready to discuss in your application. Explain the goal, what you built, the hardest bug and how you measured whether your solution worked.

How does Terminal gameplay work?

Terminal is a turn based strategy game on a geometric board. Each team writes an algorithm that reads the current game state and chooses placements and attacks without a human controlling each move.

The familiar Terminal environment uses two broad resource categories: structure points for fixed defences and mobile points for attacking or moving units. The algorithm has to decide whether to spend immediately, improve a vulnerable area or save resources for a stronger move.

What does a bot actually do each turn?

In the Python starter kit, the engine supplies a game state to your strategy's on_turn method. The strategy inspects the board and resources, requests valid deployments or upgrades, and submits its turn for simulation.

A straightforward first bot might build a defensive turret near a common entry route, reinforce the side where the opponent last scored and send a small attacking wave down the less protected lane. A stronger bot calculates those decisions from the current board rather than repeating fixed coordinates.

The rules, unit statistics and legal moves are defined by the competition's game configuration. Read that configuration before tuning unit costs, damage estimates or the effectiveness of upgrades.

Terminal strategy: building a bot that wins matches

Start with a bot that always produces legal actions and defeats a trivial opponent. Once that works, improve one measurable weakness at a time rather than adding multiple complicated features without a clear test.

1. Build a reliable defensive baseline

Identify the routes an attacker can take to score and place enough defence to cover the most exposed approaches. Use match replays to find where enemies actually get through, then adapt your structures to those locations.

A useful experiment is to compare a fixed defensive layout with a reactive layout against the same set of opponents. Record how often each allows a breach, not just how impressive the board looks.

2. Target weak routes rather than attacking blindly

Estimate the damage that an attacker would receive on each candidate path. Favour routes where units are most likely to survive and choose the moment when enough resources are available to make the attack meaningful.

Test concentrated waves and smaller frequent attacks separately. Their relative strength depends on the actual firing behaviour, movement rules and opponent defence.

3. Understand pathfinding and funnels

Paths matter because your own structures can steer movement. A carefully planned defensive corridor can direct opposing units toward turrets, while an attacking corridor can guide your units toward an exposed enemy edge.

Before relying on a path, replay several real matches and inspect the actual routes taken. An assumption about shortest paths can fail when walls, unit targeting or a changed configuration affect movement.

4. Test against different opponents

Maintain at least three baselines: a passive defender, an aggressive attacker and a bot that changes its defence after being scored on. Run repeated matches from both player positions and record wins, breaches and failures.

Only keep a change when it improves results across several opponents. A strategy tuned exclusively against one bot can look strong until the tournament introduces a different style of play.

Teams, coding workflow and submissions

Selected Terminal competitors collaborate on a shared algorithm. The programme terms provide for teams of three or four and Citadel Securities helps accepted applicants connect with teammates.

Divide the engineering work into attack logic, defensive placement, testing and integration, but appoint one owner to make the final version run from start to finish. Every proposed strategy should be checked in the same game configuration before it enters the final bot.

The Correlation One starter kit provides a Python strategy entry file named algo_strategy.py and local testing tools. Use the kit for the competition configuration you receive, then test the exact folder or package that you intend to upload.

Keep a known working version throughout development. A bot that fails to start, exceeds the permitted resources or produces invalid commands cannot benefit from even an excellent strategic idea.

Tournament format, scoring and rankings

Terminal competition bots face one another across multiple matches. Citadel Securities describes a head to head, round robin style tournament, while the programme terms describe a tournament with multiple rounds and cash prizes based on bot performance.

Within the game, your algorithm tries to prevent enemy units from breaching your side while creating scoring opportunities against the opponent. In the event, tournament progression and final ranking depend on the match results under that event's specific rules.

What to track when preparing

• Match win rate: the number of wins divided by matches against the same opponent pool.
• Breaches conceded: where and how frequently the opponent scores against your defence.
• Attack efficiency: how much pressure your attacks create for the resources spent.
• Robustness: whether the strategy remains effective when the opponent changes opening moves.
• Runtime reliability: errors, invalid moves and failed submissions that compromise otherwise strong matches.

These are useful EverythingQuant development metrics, not an alternative official ranking formula. Use the tournament instructions for the actual match rules, advancement criteria and final results.

Citadel Securities Terminal prizes and career opportunities

Terminal awards cash prizes to successful teams. The programme terms linked from Citadel Securities' Terminal page contain the following United States dollar awards for team achievements.

The boss drawing is a separate challenge involving four organiser bots. Under the linked terms, defeating multiple bosses with one algorithm earns more drawing entries than defeating them with separate algorithms.

The linked terms allow those awards to accumulate and divide prize money evenly among the winning team's members. For any new Terminal event, use that event's rules to confirm its prize structure and requirements.

Citadel Securities also uses Terminal to meet technically strong students. Competing gives you a concrete engineering project and may create recruiting connections, but a tournament result is not an automatic interview or employment offer.

Original EverythingQuant practice: choose an attack lane

A useful beginner exercise is to write a small route selection function before connecting it to Terminal's real game API. The goal is to choose an attacking lane from predicted incoming damage, using a deliberately simplified model.

The problem

One attacking unit has 12 health points. The left route is expected to deal 3, 3 and 3 damage; the right route deals 4, 4, 4 and 4 damage.

The left route leaves 3 health, so the unit survives. The right route deals 16 total damage, so the unit is eliminated before reaching its destination.

Write a function that selects the route with the most remaining health, returning None if no route is survivable. For equal results, choose the alphabetically first lane so your behaviour remains deterministic.

def select_lane(health, predicted_hits):
    remaining = {
        lane: health - sum(hits)
        for lane, hits in predicted_hits.items()
    }
    viable = [
        lane for lane in sorted(remaining)
        if remaining[lane] > 0
    ]
    if not viable:
        return None
    return max(viable, key=remaining.get)


assert select_lane(12, {
    "left": [3, 3, 3],
    "right": [4, 4, 4, 4]
}) == "left"

assert select_lane(5, {
    "left": [3, 3],
    "right": [4, 4]
}) is None

assert select_lane(10, {
    "left": [2],
    "right": [2]
}) == "left"

assert select_lane(10, {}) is None

Turn the exercise into a real strategy

Replace the predicted damage lists with estimates derived from the game state, nearby defensive units and path geometry. Your bot should also learn when neither lane is worth attacking and saving resources is preferable.

Then test the method against a defender that reinforces whichever side you attacked last. If your route selection keeps becoming predictable, experiment with varying attack timing and targeting only when the data supports the change.

How to prepare for Terminal in ten days

Use this EverythingQuant preparation plan to move from programming fundamentals to a tested bot. The ten days are a suggested practice schedule, not the duration of a Terminal event.

Skills that matter most

Prioritise clean Python or another supported language, arrays and dictionaries for state handling, graph intuition for routes, and basic simulation for comparing actions. You should be comfortable debugging unfamiliar code and testing a strategy rather than only proving an algorithm is theoretically efficient.

The EverythingQuant Data Structures and Algorithms in Python course is useful for building those foundations. The best next step for Terminal itself is still to run the actual starter kit and measure how your changes affect matches.

Citadel Securities Terminal frequently asked questions

Official Terminal resources and further reading

Start with the organiser's event page for eligibility and entry, then move to the game platform and starter kit for practical preparation. A detailed participant writeup can help you develop and test ideas without assuming any one strategy will win every tournament.

• Citadel Securities Terminal: regional rules, application steps, supported languages and future event listings.
• Citadel programme terms: selection, team formation, awards and conduct.
• Terminal game platform: access to the game and its training environment.
• Correlation One Terminal starter kit: Python code, game configuration and local development tools.
• European Terminal participant strategy writeup: path selection, defensive funnels, match analysis and engineering lessons.
• EverythingQuant Python algorithms course: programming foundations for implementing and debugging bot strategies.