A **strategic context** defines the rules, structure, and logic of a game or competitive scenario. Think of it as the game engine that powers strategic reasoning. It specifies what actions are available, how the game state evolves, and how outcomes are determined.

## The Role of Strategic Contexts

Strategic contexts are the foundation for computing equilibrium strategies:

1. **Game Specification**: They define the complete rules of engagement: the players, actions, information structure, and payoffs
2. **Simulation**: They provide the computational logic to simulate game play and explore different strategies
3. **Equilibrium Computation**: They enable the calculation of Nash equilibria and other solution concepts

Without a strategic context, there's no game to analyze and no way to compute equilibrium behavior.

## Components of a Strategic Context

A strategic context typically includes:

- **Game ID**: A unique identifier for the game type (e.g., `:texas-hold-em`, `:kuhn-poker`)
- **Name**: A human-readable name for the game (e.g., "Texas Hold'em", "Kuhn Poker")
- **Form Schema**: A specification that defines what parameters can be configured (e.g., player count, stack sizes, betting structure)
- **Game Factory**: The computational implementation that creates game instances and enforces rules
- **Action Space**: The set of possible moves available to players at different decision points
- **Information Structure**: What each player knows and when they know it (perfect vs. imperfect information)

## Form Schema and Customization

Strategic contexts define a **form schema** that specifies what parameters are available for customization. When you create an equilibrium, you provide specific **form parameter values** that configure the game instance. 

In practice, computing an equilibrium always means pairing a **strategic context with a gameform**. The strategic context defines the runtime logic; the gameform supplies the specific configuration. Two equilibriums with the same strategic context but different form parameter values are different strategic objects because they correspond to different game instances.

Those gameforms do not have to be flat scalar settings. In domain-specific
contexts, a gameform can be a nested ontology configuration: firms, rivals,
buyer types, menus, offers, and objective weights.

For example, the pricing game strategic context has a form schema that allows configuration of:

- Competing firms, each with menus of offers
- Buyer types with different price sensitivities and feature preferences
- Market size and choice model parameters
- Objective weights (revenue, margin, market share)

This separation between the schema (defined by the strategic context) and the actual parameter values (specified per equilibrium) allows you to train multiple equilibria for different game configurations using the same underlying strategic context.

## Example: Pricing Game Strategic Context

Consider the pricing game strategic context:
- **Game ID**: `:pricing-game`
- **Form Schema**: Defines firms, buyer types, menus, and objective weights

When creating an equilibrium, you provide a specific market configuration:
- **Form Parameters**: Two SaaS firms each offering Starter and Pro tiers, two buyer segments (price-sensitive and power users), optimizing for margin
- **Result**: An equilibrium strategy telling each firm which menu to present, given the competitive landscape

You can create different equilibria by varying the market structure. Perhaps one with aggressive rival pricing to stress-test your margins, another with a premium-only competitor to explore upmarket positioning — each producing different equilibrium strategies.

## Strategic Contexts vs. Equilibria vs. Solvers

These three concepts work together in a specific hierarchy:

1. **Strategic Context**: The game type definition with its form schema (e.g., `:texas-hold-em` with configurable `player_count`)
2. **Equilibrium**: A computed equilibrium strategy for a specific configuration of that game (e.g., a 6-player Texas Hold'em equilibrium with form parameters `{:player_count 6}`)
3. **Solver**: A runtime component that loads an equilibrium's strategies into memory and serves strategic queries

Think of it this way:
- **Strategic Context** = The template that defines a type of game and what can be configured
- **Equilibrium** = A trained solution for one specific configuration of that game template
- **Solver** = The runtime system that loads a trained equilibrium and makes it queryable in practice

## Browsing Strategic Contexts

All public strategic contexts are browsable in the [Simulation Hub](/sim). You can search, filter by game type (normal-form or extensive-form), and sort by name or recency. Each game has a detail page showing its source code, README, and equilibrium stats.

Game owners can manage their games from the Settings tab on the detail page — toggle public/private visibility, rename, or delete.

## Working with Strategic Contexts

Strategic contexts are game types in the system's game library, created by developers and game theorists who understand both the game domain and the computational requirements. Once a strategic context exists in the library, users can:

- Browse available games in the [Simulation Hub](/sim)
- Create equilibria by selecting a strategic context and providing specific form parameter values
- Train equilibrium strategies for different configurations of the same game type
- Build agents that reason strategically using those trained equilibria

## Strategic Context Library

Strategic contexts exist in the system's game library and are available to all users. Examples include:
- **Pricing Game** (`:pricing-game`): Firms competing on menus and pricing under hidden information, with configurable buyer segments and objective weights
- **Texas Hold'em** (`:texas-hold-em`): Configurable for 2-7 players
- **Kuhn Poker** (`:kuhn-poker`): A simplified 2-player poker variant
- **Leduc Poker** (`:leduc-poker`): An intermediate complexity poker game
- **Rock Paper Scissors** (`:rock-paper-scissors`): A classic simultaneous-move game

Each strategic context in the library defines the rules and structure for a specific type of strategic interaction. Users then create equilibria for specific configurations of these games.

## Best Practices

1. **Understand the Game**: Before training equilibria, make sure you understand the strategic context's rules and what parameters can be configured in its form schema

2. **Start Simple**: Begin with simpler game types (like Kuhn Poker) and basic parameter configurations before moving to complex games (like Texas Hold'em with many players)

3. **Parameter Consistency**: When comparing strategies, ensure you're using consistent form parameter values across equilibria. Differences in configuration create fundamentally different strategic problems

4. **Check the Form Schema**: Review the strategic context's form schema to understand what parameters are available and what values are valid before creating an equilibrium

## See also
- [What is an Equilibrium?](/docs/what-is-an-equilibrium) - Computing equilibrium strategies for strategic contexts
- [What is a Solver?](/docs/what-is-a-solver) - Serving equilibrium strategies at runtime
- [What is Abstraction?](/docs/what-is-abstraction) - How strategic contexts manage complexity