diff --git a/docs/reference/advanced/managed-variables.md b/docs/reference/advanced/managed-variables.md
new file mode 100644
index 000000000..d5c27558a
--- /dev/null
+++ b/docs/reference/advanced/managed-variables.md
@@ -0,0 +1,799 @@
+# Managed Variables
+
+Managed variables provide a way to dynamically configure values in your application—such as LLM prompts, model parameters, feature flags, and more—without redeploying code. They're particularly useful for AI applications where you want to iterate on prompts, adjust model settings, or run A/B tests.
+
+## Why Use Managed Variables?
+
+### LLM Prompt Management
+
+When building AI applications, you often need to:
+
+- **Iterate on prompts quickly** without code changes or deployments
+- **A/B test different prompts** to find what works best
+- **Manage model parameters** like temperature, max tokens, or model selection
+- **Roll out prompt changes gradually** to a subset of users
+
+### Beyond AI: Traditional Feature Flags
+
+Managed variables also work great for traditional use cases:
+
+- Feature flags and gradual rollouts
+- Configuration that varies by environment or user segment
+- Runtime-adjustable settings without restarts
+
+## Basic Usage
+
+### Creating a Variable
+
+Use `logfire.var()` to create a managed variable:
+
+```python
+import logfire
+
+logfire.configure()
+
+# Define a variable for your AI agent's system prompt
+agent_instructions = logfire.var(
+    name='agent_instructions',
+    default='You are a helpful assistant.',
+    type=str,
+)
+
+
+async def main():
+    # Get the variable's value
+    instructions = await agent_instructions.get()
+    print(f'Instructions: {instructions}')
+    #> Instructions: You are a helpful assistant.
+```
+
+### Variable Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| `name` | Unique identifier for the variable |
+| `default` | Default value when no configuration is found (can also be a function) |
+| `type` | Expected type(s) for validation — can be a single type or sequence of types |
+
+### Getting Variable Values
+
+Variables are resolved asynchronously. You can get just the value, or full resolution details:
+
+```python
+import logfire
+
+logfire.configure()
+
+my_variable = logfire.var(
+    name='my_variable',
+    default='default value',
+    type=str,
+)
+
+
+async def main():
+    # Get just the value
+    value = await my_variable.get()
+    print(f'Value: {value}')
+    #> Value: default value
+
+    # Get full resolution details (includes variant info, any errors, etc.)
+    details = await my_variable.get_details()
+    print(f'Resolved value: {details.value}')
+    #> Resolved value: default value
+    print(f'Selected variant: {details.variant}')
+    #> Selected variant: None
+```
+
+### Targeting and Attributes
+
+You can pass targeting information to influence which variant is selected:
+
+```python
+import logfire
+
+logfire.configure()
+
+agent_instructions = logfire.var(
+    name='agent_instructions',
+    default='You are a helpful assistant.',
+    type=str,
+)
+
+
+async def main():
+    # Target a specific user for consistent A/B test assignment
+    value = await agent_instructions.get(
+        targeting_key='user_123',  # Used for deterministic variant selection
+        attributes={'plan': 'enterprise', 'region': 'us-east'},
+    )
+    print(value)
+    #> You are a helpful assistant.
+```
+
+The `targeting_key` ensures the same user always gets the same variant (deterministic selection based on the key). Additional `attributes` can be used for condition-based targeting rules.
+
+!!! note "Automatic Context Enrichment"
+    By default, Logfire automatically merges OpenTelemetry resource attributes and [baggage](baggage.md) into the attributes used for variable resolution. This means your targeting rules can match against service name, environment, or request-scoped baggage without explicitly passing them. See [Automatic Context Enrichment](#automatic-context-enrichment) for details and how to disable this behavior.
+
+## Contextual Overrides
+
+Use `variable.override()` to temporarily override a variable's value within a context. This is useful for testing or for request-scoped customization:
+
+```python
+import logfire
+
+logfire.configure()
+
+model_temperature = logfire.var(
+    name='model_temperature',
+    default=0.7,
+    type=float,
+)
+
+
+async def main():
+    # Default value
+    temp = await model_temperature.get()
+    print(f'Default temperature: {temp}')
+    #> Default temperature: 0.7
+
+    # Override for creative mode
+    with model_temperature.override(1.0):
+        temp = await model_temperature.get()
+        print(f'Creative temperature: {temp}')
+        #> Creative temperature: 1.0
+
+    # Back to default after context exits
+    temp = await model_temperature.get()
+    print(f'Back to default: {temp}')
+    #> Back to default: 0.7
+```
+
+### Dynamic Override Functions
+
+You can also override with a function that computes the value dynamically based on the targeting key and attributes:
+
+```python
+from collections.abc import Mapping
+from typing import Any
+
+import logfire
+
+logfire.configure()
+
+model_temperature = logfire.var(
+    name='model_temperature',
+    default=0.7,
+    type=float,
+)
+
+
+def get_temperature_for_context(
+    targeting_key: str | None, attributes: Mapping[str, Any] | None
+) -> float:
+    """Compute temperature based on context."""
+    if attributes and attributes.get('mode') == 'creative':
+        return 1.0
+    return 0.5
+
+
+async def main():
+    with model_temperature.override(get_temperature_for_context):
+        # Temperature will be computed based on the attributes passed to get()
+        temp = await model_temperature.get(attributes={'mode': 'creative'})
+        print(f'Creative mode: {temp}')
+        #> Creative mode: 1.0
+
+        temp = await model_temperature.get(attributes={'mode': 'precise'})
+        print(f'Precise mode: {temp}')
+        #> Precise mode: 0.5
+```
+
+## Local Variable Provider
+
+The `LogfireLocalProvider` lets you configure variables from a local configuration object. This is useful for development, testing, or self-hosted deployments where you want full control over variable values.
+
+### Configuration Structure
+
+Variables are configured using `VariablesConfig`, which defines:
+
+- **Variables**: Each variable has variants (possible values) and rollout rules
+- **Variants**: Named values that can be selected
+- **Rollouts**: Probability weights for selecting variants
+- **Overrides**: Conditional rules that change the rollout based on attributes
+
+### Example: Configuring a PydanticAI Agent
+
+Here's a complete example that configures system prompts for a [PydanticAI](https://ai.pydantic.dev/) agent with A/B testing and user-based targeting:
+
+```python
+import logfire
+from pydantic_ai import Agent
+
+from logfire.variables.config import (
+    Rollout,
+    RolloutOverride,
+    VariableConfig,
+    VariablesConfig,
+    Variant,
+    ValueEquals,
+)
+
+# Define variable configurations
+variables_config = VariablesConfig(
+    variables={
+        'assistant_system_prompt': VariableConfig(
+            name='assistant_system_prompt',
+            variants={
+                'default': Variant(
+                    key='default',
+                    serialized_value='"You are a helpful AI assistant."',
+                ),
+                'detailed': Variant(
+                    key='detailed',
+                    serialized_value='"You are a helpful AI assistant. Always provide detailed explanations with examples. Structure your responses with clear headings."',
+                ),
+                'concise': Variant(
+                    key='concise',
+                    serialized_value='"You are a helpful AI assistant. Be brief and direct. Avoid unnecessary elaboration."',
+                ),
+            },
+            # Default rollout: 80% default, 10% detailed, 10% concise
+            rollout=Rollout(variants={'default': 0.8, 'detailed': 0.1, 'concise': 0.1}),
+            overrides=[
+                # Enterprise users always get the detailed prompt
+                RolloutOverride(
+                    conditions=[ValueEquals(attribute='plan', value='enterprise')],
+                    rollout=Rollout(variants={'detailed': 1.0}),
+                ),
+            ],
+            json_schema={'type': 'string'},
+        ),
+    }
+)
+
+# Configure Logfire with the local provider
+logfire.configure(
+    variables=logfire.VariablesOptions(provider=variables_config),
+)
+logfire.instrument_pydantic_ai()
+
+# Define the variable
+system_prompt = logfire.var(
+    name='assistant_system_prompt',
+    default='You are a helpful assistant.',
+    type=str,
+)
+
+
+async def run_agent(user_id: str, user_plan: str, user_message: str) -> str:
+    """Run the agent with the appropriate prompt for this user."""
+    # Get the prompt - variant selection is deterministic per user
+    prompt = await system_prompt.get(
+        targeting_key=user_id,
+        attributes={'plan': user_plan},
+    )
+
+    # Create the agent with the resolved prompt
+    agent = Agent('openai:gpt-4o-mini', system_prompt=prompt)
+    result = await agent.run(user_message)
+    return result.output
+
+
+async def main():
+    # Enterprise user gets the detailed prompt
+    response = await run_agent(
+        user_id='enterprise_user_1',
+        user_plan='enterprise',
+        user_message='What is Python?',
+    )
+    print(f'Enterprise user response: {response}')
+
+    # Free user gets one of the default rollout variants
+    response = await run_agent(
+        user_id='free_user_42',
+        user_plan='free',
+        user_message='What is Python?',
+    )
+    print(f'Free user response: {response}')
+```
+
+### Variant Selection
+
+Variants are selected based on:
+
+1. **Overrides**: Conditions are evaluated in order; the first matching override's rollout is used
+2. **Rollout weights**: Variants are selected probabilistically based on their weights
+3. **Targeting key**: When provided, ensures consistent selection for the same key (useful for A/B tests)
+
+If rollout weights sum to less than 1.0, there's a chance no variant is selected and the code default is used.
+
+## Rollout Schedules
+
+Rollout schedules enable time-based progression through multiple rollout stages, allowing for gradual rollouts where variant selection weights change over time. This is useful for:
+
+- **Canary deployments**: Start with a small percentage of traffic, then gradually increase
+- **Phased feature launches**: Roll out new features to more users over time
+- **Time-limited experiments**: Run A/B tests for specific durations
+
+### How Schedules Work
+
+A schedule has a `start_at` time and a list of stages. Each stage has:
+
+- **duration**: How long to remain in this stage
+- **rollout**: The variant selection weights for this stage
+- **overrides**: Optional conditional rules specific to this stage
+
+The schedule progresses through stages sequentially. When the current time is:
+
+- Before `start_at`: Uses the base rollout and overrides
+- Within a stage's duration: Uses that stage's rollout and overrides
+- After all stages complete: Returns to the base rollout and overrides
+
+### Example: Gradual Rollout
+
+Here's an example of a three-stage canary deployment:
+
+```python
+from datetime import datetime, timedelta, timezone
+
+from logfire.variables.config import (
+    Rollout,
+    RolloutSchedule,
+    RolloutStage,
+    VariableConfig,
+    Variant,
+)
+
+# Schedule a gradual rollout starting now
+config = VariableConfig(
+    name='new_feature_enabled',
+    variants={
+        'disabled': Variant(key='disabled', serialized_value='false'),
+        'enabled': Variant(key='enabled', serialized_value='true'),
+    },
+    # Base rollout: feature disabled (used before/after schedule)
+    rollout=Rollout(variants={'disabled': 1.0}),
+    overrides=[],
+    schedule=RolloutSchedule(
+        start_at=datetime.now(timezone.utc),
+        stages=[
+            # Stage 1: Canary - 5% for 1 hour
+            RolloutStage(
+                duration=timedelta(hours=1),
+                rollout=Rollout(variants={'disabled': 0.95, 'enabled': 0.05}),
+                overrides=[],
+            ),
+            # Stage 2: Early adopters - 25% for 4 hours
+            RolloutStage(
+                duration=timedelta(hours=4),
+                rollout=Rollout(variants={'disabled': 0.75, 'enabled': 0.25}),
+                overrides=[],
+            ),
+            # Stage 3: Full rollout - 100% for 24 hours
+            RolloutStage(
+                duration=timedelta(hours=24),
+                rollout=Rollout(variants={'enabled': 1.0}),
+                overrides=[],
+            ),
+        ],
+    ),
+)
+```
+
+### Stage-Specific Overrides
+
+Each stage can have its own conditional overrides, allowing different targeting rules at different stages:
+
+```python
+from datetime import datetime, timedelta, timezone
+
+from logfire.variables.config import (
+    Rollout,
+    RolloutOverride,
+    RolloutSchedule,
+    RolloutStage,
+    ValueEquals,
+    VariableConfig,
+    Variant,
+)
+
+config = VariableConfig(
+    name='new_prompt',
+    variants={
+        'old': Variant(key='old', serialized_value='"Old prompt"'),
+        'new': Variant(key='new', serialized_value='"New prompt"'),
+    },
+    rollout=Rollout(variants={'old': 1.0}),
+    overrides=[],
+    schedule=RolloutSchedule(
+        start_at=datetime.now(timezone.utc),
+        stages=[
+            # Stage 1: Only beta users get the new prompt
+            RolloutStage(
+                duration=timedelta(hours=2),
+                rollout=Rollout(variants={'old': 1.0}),
+                overrides=[
+                    RolloutOverride(
+                        conditions=[ValueEquals(attribute='is_beta', value=True)],
+                        rollout=Rollout(variants={'new': 1.0}),
+                    ),
+                ],
+            ),
+            # Stage 2: Beta users and enterprise users
+            RolloutStage(
+                duration=timedelta(hours=4),
+                rollout=Rollout(variants={'old': 1.0}),
+                overrides=[
+                    RolloutOverride(
+                        conditions=[ValueEquals(attribute='is_beta', value=True)],
+                        rollout=Rollout(variants={'new': 1.0}),
+                    ),
+                    RolloutOverride(
+                        conditions=[ValueEquals(attribute='plan', value='enterprise')],
+                        rollout=Rollout(variants={'new': 1.0}),
+                    ),
+                ],
+            ),
+            # Stage 3: Everyone gets the new prompt
+            RolloutStage(
+                duration=timedelta(hours=24),
+                rollout=Rollout(variants={'new': 1.0}),
+                overrides=[],
+            ),
+        ],
+    ),
+)
+```
+
+### Schedule Lifecycle
+
+!!! note "Local vs. Server-Side Schedules"
+    When using the local provider, schedules are evaluated client-side based on the current time. This means:
+
+    - The schedule progresses automatically as time passes
+    - After the schedule completes, the base rollout is used again
+    - To make the final stage permanent, update the configuration to set the base rollout to the desired final state
+
+    Server-side schedule management (with automated rollback based on error rates) will be available with the remote provider in a future release.
+
+## Condition Types
+
+Overrides use conditions to match against the provided attributes. Available condition types:
+
+| Condition | Description |
+|-----------|-------------|
+| `ValueEquals` | Attribute equals a specific value |
+| `ValueDoesNotEqual` | Attribute does not equal a specific value |
+| `ValueIsIn` | Attribute is in a list of values |
+| `ValueIsNotIn` | Attribute is not in a list of values |
+| `ValueMatchesRegex` | Attribute matches a regex pattern |
+| `ValueDoesNotMatchRegex` | Attribute does not match a regex pattern |
+| `KeyIsPresent` | Attribute key exists |
+| `KeyIsNotPresent` | Attribute key does not exist |
+
+### Example: Complex Targeting Rules
+
+```python
+from logfire.variables.config import (
+    KeyIsPresent,
+    Rollout,
+    RolloutOverride,
+    ValueEquals,
+    ValueIsIn,
+)
+
+overrides = [
+    # Beta users in US/UK get the experimental prompt
+    RolloutOverride(
+        conditions=[
+            ValueEquals(attribute='is_beta', value=True),
+            ValueIsIn(attribute='country', values=['US', 'UK']),
+        ],
+        rollout=Rollout(variants={'experimental': 1.0}),
+    ),
+    # Anyone with a custom_prompt attribute gets it used
+    RolloutOverride(
+        conditions=[KeyIsPresent(attribute='custom_prompt')],
+        rollout=Rollout(variants={'custom': 1.0}),
+    ),
+]
+```
+
+## Automatic Context Enrichment
+
+By default, Logfire automatically includes additional context when resolving variables:
+
+- **Resource attributes**: OpenTelemetry resource attributes (service name, version, etc.)
+- **Baggage**: Values set via `logfire.set_baggage()`
+
+This allows you to create targeting rules based on deployment environment, service identity, or request-scoped baggage without explicitly passing these values.
+
+```python
+import logfire
+from logfire._internal.config import VariablesOptions
+from logfire.variables.config import (
+    Rollout,
+    RolloutOverride,
+    VariableConfig,
+    VariablesConfig,
+    Variant,
+    ValueEquals,
+)
+
+variables_config = VariablesConfig(
+    variables={
+        'agent_prompt': VariableConfig(
+            name='agent_prompt',
+            variants={
+                'standard': Variant(key='standard', serialized_value='"Standard prompt"'),
+                'premium': Variant(key='premium', serialized_value='"Premium prompt"'),
+            },
+            rollout=Rollout(variants={'standard': 1.0}),
+            overrides=[
+                # This matches baggage set via logfire.set_baggage()
+                RolloutOverride(
+                    conditions=[ValueEquals(attribute='plan', value='enterprise')],
+                    rollout=Rollout(variants={'premium': 1.0}),
+                ),
+            ],
+            json_schema={'type': 'string'},
+        ),
+    }
+)
+
+logfire.configure(variables=VariablesOptions(provider=variables_config))
+
+agent_prompt = logfire.var(name='agent_prompt', default='Default prompt', type=str)
+
+
+async def main():
+    # Baggage is automatically included in variable resolution
+    with logfire.set_baggage(plan='enterprise'):
+        # No need to pass attributes - baggage is included automatically
+        prompt = await agent_prompt.get()
+        print(f'With enterprise baggage: {prompt}')
+        #> With enterprise baggage: Premium prompt
+
+    # Without matching baggage, gets the default rollout
+    prompt = await agent_prompt.get()
+    print(f'Without baggage: {prompt}')
+    #> Without baggage: Standard prompt
+```
+
+To disable automatic context enrichment:
+
+```python
+import logfire
+from logfire._internal.config import VariablesOptions
+from logfire.variables.config import VariablesConfig
+
+variables_config = VariablesConfig(variables={})
+
+logfire.configure(
+    variables=VariablesOptions(
+        provider=variables_config,
+        include_resource_attributes_in_context=False,
+        include_baggage_in_context=False,
+    ),
+)
+```
+
+## Remote Variable Provider
+
+!!! note "Coming Soon"
+    The `LogfireRemoteProvider` allows you to manage variables through the Logfire web interface, with automatic synchronization and real-time updates. Documentation will be added when this feature is available.
+
+    With the remote provider, you'll be able to:
+
+    - Edit prompts and configurations in the Logfire UI
+    - See which variants are being served in real-time
+    - Track the performance of different variants
+    - Roll out changes gradually with confidence
+
+## Complete Example: Support Agent with A/B Testing
+
+Here's a complete example showing a customer support agent with A/B testing on system prompts and configurable model settings:
+
+```python
+import logfire
+from pydantic import BaseModel
+from pydantic_ai import Agent
+
+from logfire._internal.config import VariablesOptions
+from logfire.variables.config import (
+    Rollout,
+    VariableConfig,
+    VariablesConfig,
+    Variant,
+)
+
+
+class ModelSettings(BaseModel):
+    """Configuration for the AI model."""
+
+    model: str
+    temperature: float
+    max_tokens: int
+
+
+# Variable configuration with two prompt variants for A/B testing
+variables_config = VariablesConfig(
+    variables={
+        'support_agent_prompt': VariableConfig(
+            name='support_agent_prompt',
+            variants={
+                'v1': Variant(
+                    key='v1',
+                    serialized_value='"You are a customer support agent. Be helpful and professional."',
+                    description='Original prompt',
+                    version='1.0.0',
+                ),
+                'v2': Variant(
+                    key='v2',
+                    serialized_value='"You are an expert customer support agent. Be empathetic and solution-oriented. Always acknowledge the customer\'s concern before providing assistance."',
+                    description='Improved prompt with empathy focus',
+                    version='2.0.0',
+                ),
+            },
+            rollout=Rollout(variants={'v1': 0.5, 'v2': 0.5}),  # 50/50 A/B test
+            overrides=[],
+            json_schema={'type': 'string'},
+        ),
+        'support_model_settings': VariableConfig(
+            name='support_model_settings',
+            variants={
+                'default': Variant(
+                    key='default',
+                    serialized_value='{"model": "openai:gpt-4o-mini", "temperature": 0.3, "max_tokens": 500}',
+                ),
+            },
+            rollout=Rollout(variants={'default': 1.0}),
+            overrides=[],
+            json_schema={'type': 'object'},
+        ),
+    }
+)
+
+# Configure Logfire
+logfire.configure(variables=VariablesOptions(provider=variables_config))
+logfire.instrument_pydantic_ai()
+
+# Define variables
+system_prompt = logfire.var(
+    name='support_agent_prompt',
+    default='You are a helpful assistant.',
+    type=str,
+)
+
+model_settings = logfire.var(
+    name='support_model_settings',
+    default=ModelSettings(model='openai:gpt-4o-mini', temperature=0.3, max_tokens=500),
+    type=ModelSettings,
+)
+
+
+async def handle_support_request(user_id: str, message: str) -> str:
+    """Handle a customer support request with managed configuration."""
+    # Get configuration - same user always gets same variant (deterministic)
+    prompt = await system_prompt.get(targeting_key=user_id)
+    settings = await model_settings.get(targeting_key=user_id)
+
+    # Get details for logging/observability
+    prompt_details = await system_prompt.get_details(targeting_key=user_id)
+
+    with logfire.span(
+        'support_request',
+        user_id=user_id,
+        prompt_variant=prompt_details.variant,
+        model=settings.model,
+    ):
+        # Create and run the agent with resolved configuration
+        agent = Agent(settings.model, system_prompt=prompt)
+        result = await agent.run(message)
+        return result.output
+
+
+async def main():
+    # Handle requests from different users
+    # Each user consistently gets the same variant due to targeting_key
+    users = ['user_alice', 'user_bob', 'user_charlie', 'user_diana']
+
+    for user_id in users:
+        # Check which variant this user gets
+        details = await system_prompt.get_details(targeting_key=user_id)
+        print(f'{user_id} -> prompt variant: {details.variant}')
+
+        # In a real app, you'd handle actual messages:
+        # response = await handle_support_request(user_id, "I need help with my order")
+```
+
+## Testing with Managed Variables
+
+Use contextual overrides to test specific variable values without modifying configuration:
+
+```python
+import logfire
+from pydantic import BaseModel
+
+from logfire._internal.config import VariablesOptions
+from logfire.variables.config import (
+    Rollout,
+    VariableConfig,
+    VariablesConfig,
+    Variant,
+)
+
+
+class ModelSettings(BaseModel):
+    model: str
+    temperature: float
+
+
+variables_config = VariablesConfig(
+    variables={
+        'test_prompt': VariableConfig(
+            name='test_prompt',
+            variants={
+                'production': Variant(
+                    key='production', serialized_value='"Production prompt"'
+                ),
+            },
+            rollout=Rollout(variants={'production': 1.0}),
+            overrides=[],
+            json_schema={'type': 'string'},
+        ),
+    }
+)
+
+logfire.configure(variables=VariablesOptions(provider=variables_config))
+
+system_prompt = logfire.var(name='test_prompt', default='Default prompt', type=str)
+
+model_settings = logfire.var(
+    name='model_settings',
+    default=ModelSettings(model='gpt-4o-mini', temperature=0.7),
+    type=ModelSettings,
+)
+
+
+async def test_prompt_override():
+    """Test that prompt overrides work correctly."""
+    # Production value from config
+    prompt = await system_prompt.get()
+    assert prompt == 'Production prompt'
+
+    # Override for testing
+    with system_prompt.override('Test prompt for unit tests'):
+        prompt = await system_prompt.get()
+        assert prompt == 'Test prompt for unit tests'
+
+    # Back to production after context exits
+    prompt = await system_prompt.get()
+    assert prompt == 'Production prompt'
+
+    print('All prompt override tests passed!')
+
+
+async def test_model_settings_override():
+    """Test overriding structured configuration."""
+    # Default value (no config for this variable)
+    settings = await model_settings.get()
+    assert settings.model == 'gpt-4o-mini'
+    assert settings.temperature == 0.7
+
+    # Override with custom settings
+    test_settings = ModelSettings(model='gpt-4', temperature=0.0)
+    with model_settings.override(test_settings):
+        settings = await model_settings.get()
+        assert settings.model == 'gpt-4'
+        assert settings.temperature == 0.0
+
+    print('All model settings override tests passed!')
+
+
+async def main():
+    await test_prompt_override()
+    await test_model_settings_override()
+```
diff --git a/logfire-api/logfire_api/__init__.py b/logfire-api/logfire_api/__init__.py
index 4509704d2..f6adaa098 100644
--- a/logfire-api/logfire_api/__init__.py
+++ b/logfire-api/logfire_api/__init__.py
@@ -199,6 +199,12 @@ def instrument_mcp(self, *args, **kwargs) -> None: ...
 
             def shutdown(self, *args, **kwargs) -> None: ...
 
+            def var(self, *args, **kwargs):
+                return MagicMock()
+
+            def get_variables(self, *args, **kwargs) -> list[Any]:
+                return []
+
         DEFAULT_LOGFIRE_INSTANCE = Logfire()
         span = DEFAULT_LOGFIRE_INSTANCE.span
         log = DEFAULT_LOGFIRE_INSTANCE.log
@@ -248,6 +254,14 @@ def shutdown(self, *args, **kwargs) -> None: ...
         instrument_mcp = DEFAULT_LOGFIRE_INSTANCE.instrument_mcp
         shutdown = DEFAULT_LOGFIRE_INSTANCE.shutdown
         suppress_scopes = DEFAULT_LOGFIRE_INSTANCE.suppress_scopes
+        var = DEFAULT_LOGFIRE_INSTANCE.var
+        get_variables = DEFAULT_LOGFIRE_INSTANCE.get_variables
+
+        def push_variables(*args, **kwargs) -> bool:
+            return False
+
+        def validate_variables(*args, **kwargs) -> bool:
+            return True
 
         def loguru_handler() -> dict[str, Any]:
             return {}
@@ -279,6 +293,9 @@ def __init__(self, *args, **kwargs) -> None: ...
         class MetricsOptions:
             def __init__(self, *args, **kwargs) -> None: ...
 
+        class VariablesOptions:
+            def __init__(self, *args, **kwargs) -> None: ...
+
         class PydanticPlugin:
             def __init__(self, *args, **kwargs) -> None: ...
 
diff --git a/logfire/__init__.py b/logfire/__init__.py
index 2badb3b4d..7cd895201 100644
--- a/logfire/__init__.py
+++ b/logfire/__init__.py
@@ -11,7 +11,15 @@
 from ._internal.auto_trace.rewrite_ast import no_auto_trace
 from ._internal.baggage import get_baggage, set_baggage
 from ._internal.cli import logfire_info
-from ._internal.config import AdvancedOptions, CodeSource, ConsoleOptions, MetricsOptions, PydanticPlugin, configure
+from ._internal.config import (
+    AdvancedOptions,
+    CodeSource,
+    ConsoleOptions,
+    MetricsOptions,
+    PydanticPlugin,
+    VariablesOptions,
+    configure,
+)
 from ._internal.constants import LevelName
 from ._internal.main import Logfire, LogfireSpan
 from ._internal.scrubbing import ScrubbingOptions, ScrubMatch
@@ -19,6 +27,7 @@
 from ._internal.utils import suppress_instrumentation
 from .integrations.logging import LogfireLoggingHandler
 from .integrations.structlog import LogfireProcessor as StructlogProcessor
+from .variables.push import push_variables, validate_variables
 from .version import VERSION
 
 DEFAULT_LOGFIRE_INSTANCE: Logfire = Logfire()
@@ -83,6 +92,10 @@
 metric_gauge_callback = DEFAULT_LOGFIRE_INSTANCE.metric_gauge_callback
 metric_up_down_counter_callback = DEFAULT_LOGFIRE_INSTANCE.metric_up_down_counter_callback
 
+# Variables
+var = DEFAULT_LOGFIRE_INSTANCE.var
+get_variables = DEFAULT_LOGFIRE_INSTANCE.get_variables
+
 
 def loguru_handler() -> Any:
     """Create a **Logfire** handler for Loguru.
@@ -167,6 +180,11 @@ def loguru_handler() -> Any:
     'loguru_handler',
     'SamplingOptions',
     'MetricsOptions',
+    'VariablesOptions',
+    'var',
+    'get_variables',
+    'push_variables',
+    'validate_variables',
     'logfire_info',
     'get_baggage',
     'set_baggage',
diff --git a/logfire/_internal/client.py b/logfire/_internal/client.py
index 38c473587..4247ca055 100644
--- a/logfire/_internal/client.py
+++ b/logfire/_internal/client.py
@@ -67,6 +67,17 @@ def _post_raw(self, endpoint: str, body: Any | None = None) -> Response:
         UnexpectedResponse.raise_for_status(response)
         return response
 
+    def _put_raw(self, endpoint: str, body: Any | None = None) -> Response:
+        response = self._session.put(urljoin(self.base_url, endpoint), json=body)
+        UnexpectedResponse.raise_for_status(response)
+        return response
+
+    def _put(self, endpoint: str, *, body: Any | None = None, error_message: str) -> Any:
+        try:
+            return self._put_raw(endpoint, body).json()
+        except UnexpectedResponse as e:
+            raise LogfireConfigError(error_message) from e
+
     def _post(self, endpoint: str, *, body: Any | None = None, error_message: str) -> Any:
         try:
             return self._post_raw(endpoint, body).json()
@@ -133,3 +144,37 @@ def get_prompt(self, organization: str, project_name: str, issue: str) -> dict[s
             params={'issue': issue},
             error_message='Error retrieving prompt',
         )
+
+    # --- Variables API ---
+
+    def get_variables_config(self, organization: str, project_name: str) -> dict[str, Any]:
+        """Get the variables configuration for a project."""
+        return self._get(
+            f'/api/organizations/{organization}/projects/{project_name}/variables/config/',
+            error_message='Error retrieving variables configuration',
+        )
+
+    def get_variable_by_name(self, organization: str, project_name: str, variable_name: str) -> dict[str, Any]:
+        """Get a variable definition by name."""
+        return self._get(
+            f'/api/organizations/{organization}/projects/{project_name}/variables/by-name/{variable_name}/',
+            error_message=f'Error retrieving variable {variable_name!r}',
+        )
+
+    def create_variable(self, organization: str, project_name: str, body: dict[str, Any]) -> dict[str, Any]:
+        """Create a new variable definition."""
+        return self._post(
+            f'/api/organizations/{organization}/projects/{project_name}/variables/',
+            body=body,
+            error_message='Error creating variable',
+        )
+
+    def update_variable(
+        self, organization: str, project_name: str, variable_id: str, body: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Update an existing variable definition."""
+        return self._put(
+            f'/api/organizations/{organization}/projects/{project_name}/variables/{variable_id}/',
+            body=body,
+            error_message='Error updating variable',
+        )
diff --git a/logfire/_internal/config.py b/logfire/_internal/config.py
index 4638786c2..09c97ffef 100644
--- a/logfire/_internal/config.py
+++ b/logfire/_internal/config.py
@@ -12,6 +12,7 @@
 from collections.abc import Sequence
 from contextlib import suppress
 from dataclasses import dataclass, field
+from datetime import timedelta
 from pathlib import Path
 from threading import RLock, Thread
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Literal, TypedDict
@@ -63,6 +64,7 @@
 from logfire.exceptions import LogfireConfigError
 from logfire.sampling import SamplingOptions
 from logfire.sampling._tail_sampling import TailSamplingProcessor
+from logfire.variables.abstract import NoOpVariableProvider, VariableProvider
 from logfire.version import VERSION
 
 from ..propagate import NoExtractTraceContextPropagator, WarnOnExtractTraceContextPropagator
@@ -115,6 +117,8 @@
 if TYPE_CHECKING:
     from typing import TextIO
 
+    from logfire.variables import VariablesConfig
+
     from .main import Logfire
 
 
@@ -301,6 +305,28 @@ class CodeSource:
     """
 
 
+@dataclass
+class RemoteVariablesConfig:
+    block_before_first_resolve: bool = True
+    """Whether the remote variables should be fetched before first resolving a value."""
+    polling_interval: timedelta | float = timedelta(seconds=30)
+    """The time interval for polling for updates to the variables config."""
+
+
+@dataclass
+class VariablesOptions:
+    """Configuration of managed variables."""
+
+    config: VariablesConfig | RemoteVariablesConfig | VariableProvider | None = None
+    """A local or remote variables config, or an arbitrary variable provider."""
+    include_resource_attributes_in_context: bool = True
+    """Whether to include OpenTelemetry resource attributes when resolving variables."""
+    include_baggage_in_context: bool = True
+    """Whether to include OpenTelemetry baggage when resolving variables."""
+
+    # TODO: Add OTel-related config here
+
+
 class DeprecatedKwargs(TypedDict):
     # Empty so that passing any additional kwargs makes static type checkers complain.
     pass
@@ -325,6 +351,7 @@ def configure(
     min_level: int | LevelName | None = None,
     add_baggage_to_attributes: bool = True,
     code_source: CodeSource | None = None,
+    variables: VariablesOptions | None = None,
     distributed_tracing: bool | None = None,
     advanced: AdvancedOptions | None = None,
     **deprecated_kwargs: Unpack[DeprecatedKwargs],
@@ -389,6 +416,7 @@ def configure(
         add_baggage_to_attributes: Set to `False` to prevent OpenTelemetry Baggage from being added to spans as attributes.
             See the [Baggage documentation](https://logfire.pydantic.dev/docs/reference/advanced/baggage/) for more details.
         code_source: Settings for the source code of the project.
+        variables: Options related to managed variables.
         distributed_tracing: By default, incoming trace context is extracted, but generates a warning.
             Set to `True` to disable the warning.
             Set to `False` to suppress extraction of incoming trace context.
@@ -525,6 +553,7 @@ def configure(
         sampling=sampling,
         add_baggage_to_attributes=add_baggage_to_attributes,
         code_source=code_source,
+        variables=variables,
         distributed_tracing=distributed_tracing,
         advanced=advanced,
     )
@@ -589,6 +618,9 @@ class _LogfireConfigData:
     code_source: CodeSource | None
     """Settings for the source code of the project."""
 
+    variables: VariablesOptions
+    """Settings related to managed variables."""
+
     distributed_tracing: bool | None
     """Whether to extract incoming trace context."""
 
@@ -616,6 +648,7 @@ def _load_configuration(
         min_level: int | LevelName | None,
         add_baggage_to_attributes: bool,
         code_source: CodeSource | None,
+        variables: VariablesOptions | None,
         distributed_tracing: bool | None,
         advanced: AdvancedOptions | None,
     ) -> None:
@@ -682,6 +715,13 @@ def _load_configuration(
             code_source = CodeSource(**code_source)  # type: ignore
         self.code_source = code_source
 
+        if isinstance(variables, dict):
+            # This is particularly for deserializing from a dict as in executors.py
+            variables = VariablesOptions(**variables)  # type: ignore
+        elif variables is None:
+            variables = VariablesOptions()
+        self.variables = variables
+
         if isinstance(advanced, dict):
             # This is particularly for deserializing from a dict as in executors.py
             advanced = AdvancedOptions(**advanced)  # type: ignore
@@ -725,6 +765,7 @@ def __init__(
         sampling: SamplingOptions | None = None,
         min_level: int | LevelName | None = None,
         add_baggage_to_attributes: bool = True,
+        variables: VariablesOptions | None = None,
         code_source: CodeSource | None = None,
         distributed_tracing: bool | None = None,
         advanced: AdvancedOptions | None = None,
@@ -754,6 +795,7 @@ def __init__(
             min_level=min_level,
             add_baggage_to_attributes=add_baggage_to_attributes,
             code_source=code_source,
+            variables=variables,
             distributed_tracing=distributed_tracing,
             advanced=advanced,
         )
@@ -763,6 +805,7 @@ def __init__(
         # note: this reference is important because the MeterProvider runs things in background threads
         # thus it "shuts down" when it's gc'ed
         self._meter_provider = ProxyMeterProvider(NoOpMeterProvider())
+        self._variable_provider: VariableProvider = NoOpVariableProvider()
         self._logger_provider = ProxyLoggerProvider(NoOpLoggerProvider())
         # This ensures that we only call OTEL's global set_tracer_provider once to avoid warnings.
         self._has_set_providers = False
@@ -787,6 +830,7 @@ def configure(
         min_level: int | LevelName | None,
         add_baggage_to_attributes: bool,
         code_source: CodeSource | None,
+        variables: VariablesOptions | None,
         distributed_tracing: bool | None,
         advanced: AdvancedOptions | None,
     ) -> None:
@@ -809,6 +853,7 @@ def configure(
                 min_level,
                 add_baggage_to_attributes,
                 code_source,
+                variables,
                 distributed_tracing,
                 advanced,
             )
@@ -1121,6 +1166,29 @@ def fix_pid():  # pragma: no cover
             )  # note: this may raise an Exception if it times out, call `logfire.shutdown` first
             self._meter_provider.set_meter_provider(meter_provider)
 
+            from logfire.variables import LocalVariableProvider, LogfireRemoteVariableProvider, VariablesConfig
+
+            self._variable_provider.shutdown()
+            if isinstance(self.variables.config, VariableProvider):
+                self._variable_provider = self.variables.config
+            elif isinstance(self.variables.config, VariablesConfig):
+                self._variable_provider = LocalVariableProvider(self.variables.config)
+            elif isinstance(self.variables.config, RemoteVariablesConfig):
+                # TODO: Need to use a non-write-token
+                token = self.token
+                if token:
+                    base_url = self.advanced.base_url or get_base_url_from_token(token)
+                    self._variable_provider = LogfireRemoteVariableProvider(
+                        base_url=base_url,
+                        token=token,
+                        config=self.variables.config,
+                    )
+                else:
+                    # No token, so can't use the remote variable provider
+                    self._variable_provider = NoOpVariableProvider()
+            elif self.variables.config is None:
+                self._variable_provider = NoOpVariableProvider()
+
             multi_log_processor = SynchronousMultiLogRecordProcessor()
             for processor in log_record_processors:
                 multi_log_processor.add_log_record_processor(processor)
@@ -1231,6 +1299,16 @@ def get_logger_provider(self) -> ProxyLoggerProvider:
         """
         return self._logger_provider
 
+    def get_variable_provider(self) -> VariableProvider:
+        """Get a variable provider from this `LogfireConfig`.
+
+        This is used internally and should not be called by users of the SDK.
+
+        Returns:
+            The variable provider.
+        """
+        return self._variable_provider
+
     def warn_if_not_initialized(self, message: str):
         ignore_no_config_env = os.getenv('LOGFIRE_IGNORE_NO_CONFIG', '')
         ignore_no_config = ignore_no_config_env.lower() in ('1', 'true', 't') or self.ignore_no_config
diff --git a/logfire/_internal/main.py b/logfire/_internal/main.py
index 0cfc1fc1e..5c96f130f 100644
--- a/logfire/_internal/main.py
+++ b/logfire/_internal/main.py
@@ -5,7 +5,7 @@
 import json
 import sys
 import warnings
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable, Mapping, Sequence
 from contextlib import AbstractContextManager
 from contextvars import Token
 from enum import Enum
@@ -109,6 +109,7 @@
     from ..integrations.redis import RequestHook as RedisRequestHook, ResponseHook as RedisResponseHook
     from ..integrations.sqlalchemy import CommenterOptions as SQLAlchemyCommenterOptions
     from ..integrations.wsgi import RequestHook as WSGIRequestHook, ResponseHook as WSGIResponseHook
+    from ..variables.variable import ResolveFunction, Variable
     from .integrations.asgi import ASGIApp, ASGIInstrumentKwargs
     from .integrations.aws_lambda import LambdaEvent, LambdaHandler
     from .integrations.mysql import MySQLConnection
@@ -125,6 +126,8 @@
     # 3. The argument name exc_info is very suggestive of the sys function.
     ExcInfo = Union[SysExcInfo, BaseException, bool, None]
 
+T = TypeVar('T')
+
 
 class Logfire:
     """The main logfire class."""
@@ -143,11 +146,16 @@ def __init__(
         self._sample_rate = sample_rate
         self._console_log = console_log
         self._otel_scope = otel_scope
+        self._variables: dict[str, Variable[Any]] = {}
 
     @property
     def config(self) -> LogfireConfig:
         return self._config
 
+    @property
+    def resource_attributes(self) -> Mapping[str, Any]:
+        return self._tracer_provider.resource.attributes
+
     @cached_property
     def _tracer_provider(self) -> ProxyTracerProvider:
         self._config.warn_if_not_initialized('No logs or spans will be created')
@@ -2319,24 +2327,52 @@ def shutdown(self, timeout_millis: int = 30_000, flush: bool = True) -> bool:  #
             `False` if the timeout was reached before the shutdown was completed, `True` otherwise.
         """
         start = time()
-        if flush:  # pragma: no branch
-            self._tracer_provider.force_flush(timeout_millis)
+
+        self.config.get_variable_provider().shutdown()
         remaining = max(0, timeout_millis - (time() - start))
         if not remaining:  # pragma: no cover
             return False
-        self._tracer_provider.shutdown()
 
+        if flush:  # pragma: no branch
+            self._tracer_provider.force_flush(timeout_millis)
+            remaining = max(0, timeout_millis - (time() - start))
+            if not remaining:  # pragma: no cover
+                return False
+
+        self._tracer_provider.shutdown()
         remaining = max(0, timeout_millis - (time() - start))
         if not remaining:  # pragma: no cover
             return False
+
         if flush:  # pragma: no branch
             self._meter_provider.force_flush(remaining)
+            remaining = max(0, timeout_millis - (time() - start))
+            if not remaining:  # pragma: no cover
+                return False
+
+        self._meter_provider.shutdown(remaining)
         remaining = max(0, timeout_millis - (time() - start))
         if not remaining:  # pragma: no cover
             return False
-        self._meter_provider.shutdown(remaining)
+
         return (start - time()) < timeout_millis
 
+    def var(self, *, name: str, default: T | ResolveFunction[T], type: type[T] | Sequence[type[T]]) -> Variable[T]:
+        from logfire.variables.variable import Variable
+
+        tp: type[T]
+        if isinstance(type, Sequence):
+            tp = Union[tuple(type)]  # pyright: ignore[reportAssignmentType]
+        else:
+            tp = type
+        variable = Variable[T](name, default=default, type=tp, logfire_instance=self)
+        self._variables[name] = variable
+        return variable
+
+    def get_variables(self) -> list[Variable[Any]]:
+        """Get all variables registered with this Logfire instance."""
+        return list(self._variables.values())
+
 
 class FastLogfireSpan:
     """A simple version of `LogfireSpan` optimized for auto-tracing."""
diff --git a/logfire/variables/__init__.py b/logfire/variables/__init__.py
new file mode 100644
index 000000000..a683ca647
--- /dev/null
+++ b/logfire/variables/__init__.py
@@ -0,0 +1,91 @@
+# pyright: reportUnusedImport=false
+# ruff: noqa: F401
+from importlib.util import find_spec
+from typing import TYPE_CHECKING
+
+from logfire.variables.abstract import NoOpVariableProvider, VariableProvider, VariableResolutionDetails
+
+if TYPE_CHECKING:
+    # We use a TYPE_CHECKING block here because we need to do these imports lazily to prevent issues due to loading the
+    # logfire pydantic plugin.
+    # If you change the imports here, you need to update the __getattr__ definition below to match.
+    if find_spec('pydantic'):
+        from logfire.variables.config import (
+            KeyIsNotPresent,
+            KeyIsPresent,
+            Rollout,
+            RolloutOverride,
+            # RolloutSchedule,
+            # RolloutStage,
+            ValueDoesNotEqual,
+            ValueDoesNotMatchRegex,
+            ValueEquals,
+            ValueIsIn,
+            ValueIsNotIn,
+            ValueMatchesRegex,
+            VariableConfig,
+            VariablesConfig,
+            Variant,
+        )
+        from logfire.variables.local import LocalVariableProvider
+        from logfire.variables.remote import LogfireRemoteVariableProvider
+        from logfire.variables.variable import Variable
+
+__all__ = [
+    'KeyIsNotPresent',
+    'KeyIsPresent',
+    'LocalVariableProvider',
+    'LogfireRemoteVariableProvider',
+    'NoOpVariableProvider',
+    'Rollout',
+    'RolloutOverride',
+    # 'RolloutSchedule',
+    # 'RolloutStage',
+    'ValueDoesNotEqual',
+    'ValueDoesNotMatchRegex',
+    'ValueEquals',
+    'ValueIsIn',
+    'ValueIsNotIn',
+    'ValueMatchesRegex',
+    'Variable',
+    'VariableConfig',
+    'VariableProvider',
+    'VariableResolutionDetails',
+    'VariablesConfig',
+    'Variant',
+]
+
+
+def __getattr__(name: str):
+    if name not in __all__:
+        raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
+
+    if not find_spec('pydantic'):
+        raise ImportError(
+            'Using managed variables requires the `pydantic` package.\n'
+            'You can install this with:\n'
+            "    pip install 'logfire[variables]'"
+        )
+
+    from logfire.variables.config import (
+        KeyIsNotPresent,
+        KeyIsPresent,
+        Rollout,
+        RolloutOverride,
+        # RolloutSchedule,
+        # RolloutStage,
+        ValueDoesNotEqual,
+        ValueDoesNotMatchRegex,
+        ValueEquals,
+        ValueIsIn,
+        ValueIsNotIn,
+        ValueMatchesRegex,
+        VariableConfig,
+        VariablesConfig,
+        Variant,
+    )
+    from logfire.variables.local import LocalVariableProvider
+    from logfire.variables.remote import LogfireRemoteVariableProvider
+    from logfire.variables.variable import Variable
+
+    return locals()[name]
diff --git a/logfire/variables/abstract.py b/logfire/variables/abstract.py
new file mode 100644
index 000000000..6cea1b621
--- /dev/null
+++ b/logfire/variables/abstract.py
@@ -0,0 +1,97 @@
+from __future__ import annotations as _annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, Generic, Literal, TypeVar
+
+__all__ = ('VariableResolutionDetails', 'VariableProvider', 'NoOpVariableProvider')
+
+T = TypeVar('T')
+T_co = TypeVar('T_co', covariant=True)
+
+
+@dataclass(kw_only=True)
+class VariableResolutionDetails(Generic[T_co]):
+    """Details about a variable resolution including value, variant, and any errors."""
+
+    value: T_co
+    """The resolved value of the variable."""
+    variant: str | None = None
+    """The key of the selected variant, if any."""
+    exception: Exception | None = None
+    """Any exception that occurred during resolution."""
+    _reason: Literal[
+        'resolved',
+        'context_override',
+        'missing_config',
+        'unrecognized_variable',
+        'validation_error',
+        'other_error',
+        'no_provider',
+    ]  # we might eventually make this public, but I didn't want to yet
+    """Internal field indicating how the value was resolved."""
+
+
+class VariableProvider(ABC):
+    """Abstract base class for variable value providers."""
+
+    @abstractmethod
+    def get_serialized_value(
+        self,
+        variable_name: str,
+        targeting_key: str | None = None,
+        attributes: Mapping[str, Any] | None = None,
+    ) -> VariableResolutionDetails[str | None]:
+        """Retrieve the serialized value for a variable.
+
+        Args:
+            variable_name: The name of the variable to resolve.
+            targeting_key: Optional key for deterministic variant selection (e.g., user ID).
+            attributes: Optional attributes for condition-based targeting rules.
+
+        Returns:
+            A VariableResolutionDetails containing the serialized value (or None if not found).
+        """
+        raise NotImplementedError
+
+    def refresh(self, force: bool = False):
+        """Refresh the value provider.
+
+        Only relevant to remote providers where initial retrieval may be asynchronous.
+        Calling this method is intended to block until an initial retrieval happens, but is not guaranteed
+        to eagerly retrieve any updates if the provider implements some kind of caching; the `force` argument
+        is provided as a way to ignore any caching.
+
+        Args:
+            force: Whether to force refresh. If using a provider with caching, setting this to `True` triggers a refresh
+            ignoring the cache.
+        """
+        pass
+
+    def shutdown(self):
+        """Clean up any resources used by the provider."""
+        pass
+
+
+@dataclass
+class NoOpVariableProvider(VariableProvider):
+    """A variable provider that always returns None, used when no provider is configured."""
+
+    def get_serialized_value(
+        self,
+        variable_name: str,
+        targeting_key: str | None = None,
+        attributes: Mapping[str, Any] | None = None,
+    ) -> VariableResolutionDetails[str | None]:
+        """Return None for all variable lookups.
+
+        Args:
+            variable_name: The name of the variable to resolve (ignored).
+            targeting_key: Optional key for deterministic variant selection (ignored).
+            attributes: Optional attributes for condition-based targeting rules (ignored).
+
+        Returns:
+            A VariableResolutionDetails with value=None.
+        """
+        return VariableResolutionDetails(value=None, _reason='no_provider')
diff --git a/logfire/variables/config.py b/logfire/variables/config.py
new file mode 100644
index 000000000..81dd4b5b4
--- /dev/null
+++ b/logfire/variables/config.py
@@ -0,0 +1,532 @@
+from __future__ import annotations as _annotations
+
+import random
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Annotated, Any, Literal
+
+from pydantic import Discriminator, TypeAdapter, ValidationError, field_validator, model_validator
+from typing_extensions import TypeAliasType
+
+from logfire.variables.variable import Variable
+
+
+@dataclass(kw_only=True)
+class ValueEquals:
+    """Condition that matches when an attribute equals a specific value."""
+
+    attribute: str
+    """The name of the attribute to check."""
+    value: Any
+    """The value the attribute must equal."""
+    kind: Literal['value-equals'] = 'value-equals'
+    """Discriminator field for condition type."""
+
+    def matches(self, attributes: Mapping[str, Any]) -> bool:
+        """Check if the attribute equals the expected value."""
+        return attributes.get(self.attribute, object()) == self.value
+
+
+@dataclass(kw_only=True)
+class ValueDoesNotEqual:
+    """Condition that matches when an attribute does not equal a specific value."""
+
+    attribute: str
+    """The name of the attribute to check."""
+    value: Any
+    """The value the attribute must not equal."""
+    kind: Literal['value-does-not-equal'] = 'value-does-not-equal'
+    """Discriminator field for condition type."""
+
+    def matches(self, attributes: Mapping[str, Any]) -> bool:
+        """Check if the attribute does not equal the specified value."""
+        return attributes.get(self.attribute, object()) != self.value
+
+
+@dataclass(kw_only=True)
+class ValueIsIn:
+    """Condition that matches when an attribute value is in a set of values."""
+
+    attribute: str
+    """The name of the attribute to check."""
+    values: Sequence[Any]
+    """The set of values the attribute must be in."""
+    kind: Literal['value-is-in'] = 'value-is-in'
+    """Discriminator field for condition type."""
+
+    def matches(self, attributes: Mapping[str, Any]) -> bool:
+        """Check if the attribute value is in the allowed set."""
+        value = attributes.get(self.attribute, object())
+        return value in self.values
+
+
+@dataclass(kw_only=True)
+class ValueIsNotIn:
+    """Condition that matches when an attribute value is not in a set of values."""
+
+    attribute: str
+    """The name of the attribute to check."""
+    values: Sequence[Any]
+    """The set of values the attribute must not be in."""
+    kind: Literal['value-is-not-in'] = 'value-is-not-in'
+    """Discriminator field for condition type."""
+
+    def matches(self, attributes: Mapping[str, Any]) -> bool:
+        """Check if the attribute value is not in the excluded set."""
+        value = attributes.get(self.attribute, object())
+        return value not in self.values
+
+
+@dataclass(kw_only=True)
+class ValueMatchesRegex:
+    """Condition that matches when an attribute value matches a regex pattern."""
+
+    attribute: str
+    """The name of the attribute to check."""
+    pattern: str | re.Pattern[str]
+    """The regex pattern the attribute value must match."""
+    kind: Literal['value-matches-regex'] = 'value-matches-regex'
+    """Discriminator field for condition type."""
+
+    def matches(self, attributes: Mapping[str, Any]) -> bool:
+        """Check if the attribute value matches the regex pattern."""
+        value = attributes.get(self.attribute)
+        if not isinstance(value, str):
+            return False
+        return bool(re.search(self.pattern, value))
+
+
+@dataclass(kw_only=True)
+class ValueDoesNotMatchRegex:
+    """Condition that matches when an attribute value does not match a regex pattern."""
+
+    attribute: str
+    """The name of the attribute to check."""
+    pattern: str | re.Pattern[str]
+    """The regex pattern the attribute value must not match."""
+    kind: Literal['value-does-not-match-regex'] = 'value-does-not-match-regex'
+    """Discriminator field for condition type."""
+
+    def matches(self, attributes: Mapping[str, Any]) -> bool:
+        """Check if the attribute value does not match the regex pattern."""
+        value = attributes.get(self.attribute)
+        if not isinstance(value, str):
+            return False
+        return not re.search(self.pattern, value)
+
+
+@dataclass(kw_only=True)
+class KeyIsPresent:
+    """Condition that matches when an attribute key is present."""
+
+    attribute: str
+    """The name of the attribute key that must be present."""
+    kind: Literal['key-is-present'] = 'key-is-present'
+    """Discriminator field for condition type."""
+
+    def matches(self, attributes: Mapping[str, Any]) -> bool:
+        """Check if the attribute key exists in the attributes."""
+        return self.attribute in attributes
+
+
+@dataclass(kw_only=True)
+class KeyIsNotPresent:
+    """Condition that matches when an attribute key is not present."""
+
+    attribute: str
+    """The name of the attribute key that must not be present."""
+    kind: Literal['key-is-not-present'] = 'key-is-not-present'
+    """Discriminator field for condition type."""
+
+    def matches(self, attributes: Mapping[str, Any]) -> bool:
+        """Check if the attribute key does not exist in the attributes."""
+        return self.attribute not in attributes
+
+
+Condition = TypeAliasType(
+    'Condition',
+    Annotated[
+        ValueEquals
+        | ValueDoesNotEqual
+        | ValueIsIn
+        | ValueIsNotIn
+        | ValueMatchesRegex
+        | ValueDoesNotMatchRegex
+        | KeyIsPresent
+        | KeyIsNotPresent,
+        Discriminator('kind'),
+    ],
+)
+
+
+VariantKey = str
+VariableName = str
+
+# TODO: Do we need to make the following dataclasses into pydantic dataclasses or BaseModels so the validators run when
+#  initializing (and not just when deserializing with a TypeAdapter)?
+
+
+@dataclass(kw_only=True)
+class Rollout:
+    """Configuration for variant selection with weighted probabilities."""
+
+    variants: dict[VariantKey, float]
+    """Mapping of variant keys to their selection weights (must sum to at most 1.0)."""
+
+    def __post_init__(self):
+        # pre-compute the population and weights.
+        # Note that this means that the `variants` field should be treated as immutable
+        population: list[VariantKey | None] = []
+        weights: list[float] = []
+        for k, v in self.variants.items():
+            population.append(k)
+            weights.append(v)
+
+        p_code_default = 1 - sum(weights)
+        if p_code_default > 0:
+            population.append(None)
+            weights.append(p_code_default)
+
+        self._population = population
+        self._weights = weights
+
+    @field_validator('variants')
+    @classmethod
+    def _validate_variant_proportions(cls, v: dict[VariantKey, float]):
+        # Note: if the values sum to _less_ than 1, the remaining proportion corresponds to the probability of using
+        # the code default.
+        if sum(v.values()) > 1:
+            raise ValueError('Variant proportions must not sum to more than 1.')
+        return v
+
+    def select_variant(self, seed: str | None) -> VariantKey | None:
+        """Select a variant based on configured weights using optional seeded randomness.
+
+        Args:
+            seed: Optional seed for deterministic variant selection. If provided, the same seed
+                will always select the same variant.
+
+        Returns:
+            The key of the selected variant, or None if no variant is selected (when weights sum to less than 1.0).
+        """
+        rand = random.Random(seed)
+        return rand.choices(self._population, self._weights)[0]
+
+
+@dataclass(kw_only=True)
+class Variant:
+    """A specific variant of a managed variable with its serialized value."""
+
+    key: VariantKey
+    """Unique identifier for this variant."""
+    serialized_value: str
+    """The JSON-serialized value for this variant."""
+    # format: Literal['json', 'yaml']  # TODO: Consider supporting yaml, and not just JSON; allows comments and better formatting
+    description: str | None = None
+    """Optional human-readable description of this variant."""
+    version: str | None = None  # TODO: should this be required?
+    """Optional version identifier for this variant."""
+
+
+@dataclass(kw_only=True)
+class RolloutOverride:
+    """An override of the default rollout when specific conditions are met."""
+
+    conditions: list[Condition]
+    """List of conditions that must all match for this override to apply."""
+    rollout: Rollout
+    """The rollout configuration to use when all conditions match."""
+
+
+# @dataclass(kw_only=True)
+# class RolloutStage:
+#     """A single stage in a scheduled rollout sequence.
+#
+#     Rollout schedules progress through stages sequentially, with each stage having its own
+#     duration, rollout configuration, and optional conditional overrides. This allows for
+#     gradual rollouts where traffic percentages can increase over time.
+#
+#     Example: A three-stage rollout might have:
+#     - Stage 1: 5% of traffic for 1 hour (canary)
+#     - Stage 2: 25% of traffic for 4 hours (early adopters)
+#     - Stage 3: 100% of traffic (full rollout)
+#     """
+#
+#     duration: timedelta
+#     """Duration to remain in this stage before progressing to the next.
+#
+#     Once a stage's duration has elapsed, the schedule automatically advances to the
+#     next stage. If this is the final stage and its duration has elapsed, the schedule
+#     is considered complete.
+#
+#     Note: Automated rollback based on error rates is only supported server-side and should
+#     be performed before the final stage completes. After completion, the variable config
+#     should be updated to make the final stage's rollout the new default.
+#     """
+#
+#     rollout: Rollout
+#     """The rollout configuration used during this stage.
+#
+#     Defines the probability weights for selecting each variant during this stage.
+#     For example, an early stage might have `{'new_variant': 0.05}` (5% rollout)
+#     while the final stage might have `{'new_variant': 1.0}` (100% rollout).
+#     """
+#     overrides: list[RolloutOverride]
+#     """Conditional overrides that take precedence over the stage's default rollout.
+#
+#     Evaluated in order; the first matching override's rollout is used instead of
+#     this stage's default rollout. This allows for stage-specific targeting rules.
+#     """
+
+
+# @dataclass(kw_only=True)
+# class RolloutSchedule:
+#     """A time-based progression through multiple rollout stages.
+#
+#     Rollout schedules enable gradual rollouts where the variant selection weights
+#     change over time. Starting from `start_at`, the schedule progresses through
+#     each stage sequentially, with each stage lasting for its specified duration.
+#
+#     Use cases:
+#     - Canary deployments: Start with 1% traffic, increase to 10%, then 100%
+#     - Time-limited experiments: Run an A/B test for a specific duration
+#     - Phased feature launches: Gradually expose new features to more users
+#
+#     The schedule is considered active when `start_at` is set and is in the past.
+#     Once all stages have completed (i.e., current time exceeds start_at plus the
+#     sum of all stage durations), the base rollout and overrides from the parent
+#     VariableConfig are used.
+#     """
+#
+#     start_at: datetime | None
+#     """The datetime when this schedule becomes active.
+#
+#     If None, the schedule is inactive and the base rollout is used.
+#     If set to a time in the future, the base rollout is used until that time.
+#     If set to a time in the past, the appropriate stage is determined based
+#     on elapsed time since start_at.
+#
+#     Note: Datetimes should be timezone-aware for consistent behavior across
+#     different deployment environments.
+#     """
+#     stages: list[RolloutStage]
+#     """The sequence of rollout stages to progress through.
+#
+#     Stages are processed in order. The active stage is determined by comparing
+#     the current time against start_at and the cumulative durations of previous stages.
+#     """
+#
+#     def get_active_stage(self, now: datetime | None = None) -> RolloutStage | None:
+#         """Determine the currently active stage based on the current time.
+#
+#         Args:
+#             now: The current datetime. If None, uses datetime.now() with the same
+#                 timezone as start_at (or naive if start_at is naive).
+#
+#         Returns:
+#             The currently active RolloutStage, or None if:
+#             - The schedule is not active (start_at is None)
+#             - The schedule hasn't started yet (start_at is in the future)
+#             - The schedule has completed (all stage durations have elapsed)
+#         """
+#         if self.start_at is None:
+#             return None
+#
+#         if now is None:
+#             # Use the same timezone as start_at for consistency
+#             if self.start_at.tzinfo is not None:
+#                 now = datetime.now(self.start_at.tzinfo)
+#             else:
+#                 # Treat naive datetimes as UTC
+#                 now = datetime.now(tz=timezone.utc)
+#
+#         if now < self.start_at:
+#             # Schedule hasn't started yet
+#             return None
+#
+#         elapsed = now - self.start_at
+#         cumulative_duration = timedelta()
+#
+#         for stage in self.stages:
+#             cumulative_duration += stage.duration
+#             if elapsed < cumulative_duration:
+#                 return stage
+#
+#         # All stages have completed
+#         return None
+
+
+@dataclass(kw_only=True)
+class VariableConfig:
+    """Configuration for a single managed variable including variants and rollout rules."""
+
+    name: VariableName
+    """Unique name identifying this variable."""
+    variants: dict[VariantKey, Variant]
+    """Mapping of variant keys to their configurations."""
+    rollout: Rollout
+    """Default rollout configuration for variant selection."""
+    overrides: list[RolloutOverride]
+    """Conditional overrides evaluated in order; first match takes precedence."""
+    json_schema: dict[str, Any] | None = None
+    """JSON schema describing the expected type of this variable's values."""
+    # schedule: RolloutSchedule | None = None
+    # TODO: Consider adding config-based management of targeting_key, rather than requiring the value at the call-site
+    # TODO: Should we add a validator that all variants match the provided JSON schema?
+
+    @model_validator(mode='after')
+    def _validate_variants(self):
+        # Validate lookup keys on variants dict
+        for k, v in self.variants.items():
+            if v.key != k:
+                raise ValueError(f'`variants` has invalid lookup key {k!r} for value with key {v.key!r}.')
+
+        # Validate rollout variant references
+        for k, v in self.rollout.variants.items():
+            if k not in self.variants:
+                raise ValueError(f'Variant {k!r} present in `rollout.variants` is not present in `variants`.')
+
+        # Validate rollout override variant references
+        for i, override in enumerate(self.overrides):
+            for k, v in override.rollout.variants.items():
+                if k not in self.variants:
+                    raise ValueError(f'Variant {k!r} present in `overrides[{i}].rollout` is not present in `variants`.')
+
+        # Validate schedule stage variant references
+        # if self.schedule is not None:
+        #     for stage_idx, stage in enumerate(self.schedule.stages):
+        #         for k, v in stage.rollout.variants.items():
+        #             if k not in self.variants:
+        #                 raise ValueError(
+        #                     f'Variant {k!r} present in `schedule.stages[{stage_idx}].rollout` is not present in `variants`.'
+        #                 )
+        #         for override_idx, override in enumerate(stage.overrides):
+        #             for k, v in override.rollout.variants.items():
+        #                 if k not in self.variants:
+        #                     raise ValueError(
+        #                         f'Variant {k!r} present in `schedule.stages[{stage_idx}].overrides[{override_idx}].rollout` '
+        #                         f'is not present in `variants`.'
+        #                     )
+
+        return self
+
+    def resolve_variant(
+        self, targeting_key: str | None = None, attributes: Mapping[str, Any] | None = None
+    ) -> Variant | None:
+        """Evaluate a managed variable configuration and return the selected variant.
+
+        The resolution process:
+        1. Check if there's an active rollout schedule with a current stage
+        2. If a schedule stage is active, use that stage's rollout and overrides
+        3. Otherwise, use the base rollout and overrides from this config
+        4. Evaluate overrides in order; the first match takes precedence
+        5. Select a variant based on the rollout weights (deterministic if targeting_key is provided)
+
+        Args:
+            targeting_key: A string identifying the subject of evaluation (e.g., user ID).
+                When provided, ensures deterministic variant selection for the same key.
+            attributes: Additional attributes for condition matching in override rules.
+
+        Returns:
+            The selected Variant, or None if no variant is selected (can happen when
+            rollout weights sum to less than 1.0).
+        """
+        if attributes is None:
+            attributes = {}
+
+        # Step 1: Determine the rollout and overrides to use (from schedule or base config)
+        base_rollout = self.rollout
+        base_overrides = self.overrides
+
+        # if self.schedule is not None:
+        #     active_stage = self.schedule.get_active_stage()
+        #     if active_stage is not None:
+        #         base_rollout = active_stage.rollout
+        #         base_overrides = active_stage.overrides
+
+        # Step 2: Find the first matching override, or use the base rollout
+        selected_rollout = base_rollout
+        for override in base_overrides:
+            if _matches_all_conditions(override.conditions, attributes):
+                selected_rollout = override.rollout
+                break  # First match takes precedence
+
+        seed = None if targeting_key is None else f'{self.name!r}:{targeting_key!r}'
+        selected_variant_key = selected_rollout.select_variant(seed)
+
+        if selected_variant_key is None:
+            return None
+
+        return self.variants[selected_variant_key]
+
+
+@dataclass(kw_only=True)
+class VariablesConfig:
+    """Container for all managed variable configurations."""
+
+    variables: dict[VariableName, VariableConfig]
+    """Mapping of variable names to their configurations."""
+
+    @model_validator(mode='after')
+    def _validate_variables(self):
+        # Validate lookup keys on variants dict
+        for k, v in self.variables.items():
+            if v.name != k:
+                raise ValueError(f'`variables` has invalid lookup key {k!r} for value with name {v.name!r}.')
+        return self
+
+    def get_validation_errors(self, variables: list[Variable[Any]]) -> dict[str, dict[str | None, Exception]]:
+        """Validate that all variable variants can be deserialized to their expected types.
+
+        Args:
+            variables: List of Variable instances to validate against this configuration.
+
+        Returns:
+            A dict mapping variable names to dicts of variant keys (or None for general errors) to exceptions.
+        """
+        errors: dict[str, dict[str | None, Exception]] = {}
+        for variable in variables:
+            try:
+                config = self.variables.get(variable.name)
+                if config is None:
+                    raise ValueError(f'No config for variable with name {variable.name!r}')
+                for k, v in config.variants.items():
+                    try:
+                        variable.type_adapter.validate_json(v.serialized_value)
+                    except ValidationError as e:
+                        errors.setdefault(variable.name, {})[k] = e
+            except Exception as e:
+                errors.setdefault(variable.name, {})[None] = e
+        return errors
+
+    @staticmethod
+    def validate_python(data: Any) -> VariablesConfig:
+        """Parse and validate a VariablesConfig from a Python object.
+
+        Args:
+            data: A Python object (typically a dict) to validate as a VariablesConfig.
+
+        Returns:
+            A validated VariablesConfig instance.
+        """
+        return _VariablesConfigAdapter.validate_python(data)
+
+
+_VariablesConfigAdapter = TypeAdapter(VariablesConfig)
+
+
+def _matches_all_conditions(conditions: list[Condition], attributes: Mapping[str, Any]) -> bool:
+    """Check if all conditions match the provided attributes.
+
+    Args:
+        conditions: List of conditions to evaluate.
+        attributes: Attributes to match against.
+
+    Returns:
+        True if all conditions match, False otherwise.
+    """
+    for condition in conditions:
+        if not condition.matches(attributes):
+            return False
+    return True
diff --git a/logfire/variables/local.py b/logfire/variables/local.py
new file mode 100644
index 000000000..7091088f0
--- /dev/null
+++ b/logfire/variables/local.py
@@ -0,0 +1,62 @@
+from __future__ import annotations as _annotations
+
+from collections.abc import Mapping
+from typing import Any, Callable
+
+from logfire.variables.abstract import VariableProvider, VariableResolutionDetails
+from logfire.variables.config import VariablesConfig
+
+__all__ = ('LocalVariableProvider',)
+
+
+class LocalVariableProvider(VariableProvider):
+    """Variable provider that resolves values from a local in-memory configuration."""
+
+    def __init__(
+        self,
+        config: VariablesConfig | Callable[[], VariablesConfig],
+    ):
+        """Create a new local variable provider.
+
+        Args:
+            config: Either a VariablesConfig instance, or a callable that returns one.
+                Using a callable allows for dynamic configuration reloading.
+        """
+        super().__init__()
+        if isinstance(config, VariablesConfig):
+
+            def get_config() -> VariablesConfig:
+                return config
+        else:
+            get_config = config
+
+        self.get_config = get_config
+
+    def get_serialized_value(
+        self,
+        variable_name: str,
+        targeting_key: str | None = None,
+        attributes: Mapping[str, Any] | None = None,
+    ) -> VariableResolutionDetails[str | None]:
+        """Resolve a variable's serialized value from the local configuration.
+
+        Args:
+            variable_name: The name of the variable to resolve.
+            targeting_key: Optional key for deterministic variant selection (e.g., user ID).
+            attributes: Optional attributes for condition-based targeting rules.
+
+        Returns:
+            A VariableResolutionDetails containing the serialized value (or None if not found).
+        """
+        variables_config = self.get_config()
+
+        # TODO: Move the following down to a method on VariablesConfig
+        variable_config = variables_config.variables.get(variable_name)
+        if variable_config is None:
+            return VariableResolutionDetails(value=None, _reason='unrecognized_variable')
+
+        variant = variable_config.resolve_variant(targeting_key, attributes)
+        if variant is None:
+            return VariableResolutionDetails(value=None, _reason='resolved')
+        else:
+            return VariableResolutionDetails(value=variant.serialized_value, variant=variant.key, _reason='resolved')
diff --git a/logfire/variables/push.py b/logfire/variables/push.py
new file mode 100644
index 000000000..e2b71c905
--- /dev/null
+++ b/logfire/variables/push.py
@@ -0,0 +1,601 @@
+"""Variable push functionality for syncing local variables to Logfire server."""
+
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from pydantic import ValidationError
+
+from logfire.variables.variable import Variable, is_resolve_function
+
+if TYPE_CHECKING:
+    from logfire._internal.client import LogfireClient
+
+__all__ = ('push_variables', 'validate_variables', 'VariableDiff', 'VariableChange')
+
+
+@dataclass
+class VariantCompatibility:
+    """Result of checking a variant's compatibility with a schema."""
+
+    variant_key: str
+    serialized_value: str
+    is_compatible: bool
+    error: str | None = None
+
+
+@dataclass
+class VariableChange:
+    """Represents a change to be made to a variable."""
+
+    name: str
+    change_type: str  # 'create', 'update_schema', 'no_change'
+    local_schema: dict[str, Any] | None = None
+    server_schema: dict[str, Any] | None = None
+    initial_variant_value: str | None = None  # JSON serialized
+    incompatible_variants: list[VariantCompatibility] | None = None
+    server_id: str | None = None  # For updates
+
+
+@dataclass
+class VariableDiff:
+    """Represents the diff between local and server variables."""
+
+    changes: list[VariableChange]
+    orphaned_server_variables: list[str]  # Variables on server not in local code
+
+    @property
+    def has_changes(self) -> bool:
+        """Return True if there are any changes to apply."""
+        return any(c.change_type != 'no_change' for c in self.changes)
+
+
+def _get_json_schema(variable: Variable[Any]) -> dict[str, Any]:
+    """Get the JSON schema for a variable's type."""
+    return variable.type_adapter.json_schema()
+
+
+def _get_default_serialized(variable: Variable[Any]) -> str | None:
+    """Get the serialized default value for a variable.
+
+    Returns None if the default is a ResolveFunction (can't serialize a function).
+    """
+    if is_resolve_function(variable.default):
+        return None
+    # Serialize the default value using Pydantic
+    return variable.type_adapter.dump_json(variable.default).decode('utf-8')
+
+
+def _check_variant_compatibility(
+    variable: Variable[Any],
+    variant_key: str,
+    serialized_value: str,
+) -> VariantCompatibility:
+    """Check if a variant's value is compatible with the variable's type."""
+    try:
+        variable.type_adapter.validate_json(serialized_value)
+        return VariantCompatibility(
+            variant_key=variant_key,
+            serialized_value=serialized_value,
+            is_compatible=True,
+        )
+    except ValidationError as e:
+        return VariantCompatibility(
+            variant_key=variant_key,
+            serialized_value=serialized_value,
+            is_compatible=False,
+            error=str(e),
+        )
+
+
+def _compute_diff(
+    variables: list[Variable[Any]],
+    server_config: dict[str, Any],
+) -> VariableDiff:
+    """Compute the diff between local variables and server config."""
+    changes: list[VariableChange] = []
+    local_names = {v.name for v in variables}
+    server_variables = server_config.get('variables', {})
+
+    for variable in variables:
+        local_schema = _get_json_schema(variable)
+        server_var = server_variables.get(variable.name)
+
+        if server_var is None:
+            # New variable - needs to be created
+            default_serialized = _get_default_serialized(variable)
+            changes.append(
+                VariableChange(
+                    name=variable.name,
+                    change_type='create',
+                    local_schema=local_schema,
+                    initial_variant_value=default_serialized,
+                )
+            )
+        else:
+            # Variable exists - check if schema changed
+            server_schema = server_var.get('json_schema')
+
+            # Normalize schemas for comparison (remove $defs if empty, etc.)
+            local_normalized = json.dumps(local_schema, sort_keys=True)
+            server_normalized = json.dumps(server_schema, sort_keys=True) if server_schema else '{}'
+
+            if local_normalized != server_normalized:
+                # Schema changed - check variant compatibility
+                incompatible: list[VariantCompatibility] = []
+                for variant_key, variant_data in server_var.get('variants', {}).items():
+                    compat = _check_variant_compatibility(
+                        variable,
+                        variant_key,
+                        variant_data.get('serialized_value', ''),
+                    )
+                    if not compat.is_compatible:
+                        incompatible.append(compat)
+
+                changes.append(
+                    VariableChange(
+                        name=variable.name,
+                        change_type='update_schema',
+                        local_schema=local_schema,
+                        server_schema=server_schema,
+                        incompatible_variants=incompatible if incompatible else None,
+                        server_id=server_var.get('id'),
+                    )
+                )
+            else:
+                # No change needed
+                changes.append(
+                    VariableChange(
+                        name=variable.name,
+                        change_type='no_change',
+                    )
+                )
+
+    # Find orphaned server variables (on server but not in local code)
+    orphaned = [name for name in server_variables.keys() if name not in local_names]
+
+    return VariableDiff(changes=changes, orphaned_server_variables=orphaned)
+
+
+def _format_diff(diff: VariableDiff) -> str:
+    """Format the diff for display to the user."""
+    lines: list[str] = []
+
+    creates = [c for c in diff.changes if c.change_type == 'create']
+    updates = [c for c in diff.changes if c.change_type == 'update_schema']
+    unchanged = [c for c in diff.changes if c.change_type == 'no_change']
+
+    if creates:
+        lines.append('\n\033[32m=== Variables to CREATE ===\033[0m')
+        for change in creates:
+            lines.append(f'  \033[32m+ {change.name}\033[0m')
+            if change.initial_variant_value:
+                lines.append(f'    Default variant: {change.initial_variant_value}')
+            else:
+                lines.append('    (No default variant - default is a function)')
+
+    if updates:
+        lines.append('\n\033[33m=== Variables to UPDATE (schema changed) ===\033[0m')
+        for change in updates:
+            lines.append(f'  \033[33m~ {change.name}\033[0m')
+            if change.incompatible_variants:
+                lines.append('    \033[31mWarning: Incompatible variants:\033[0m')
+                for compat in change.incompatible_variants:
+                    lines.append(f'      - {compat.variant_key}: {compat.error}')
+
+    if unchanged:
+        lines.append(f'\n\033[90m=== No changes needed ({len(unchanged)} variables) ===\033[0m')
+        for change in unchanged:
+            lines.append(f'  \033[90m  {change.name}\033[0m')
+
+    if diff.orphaned_server_variables:
+        lines.append('\n\033[90m=== Server-only variables (not in local code) ===\033[0m')
+        for name in diff.orphaned_server_variables:
+            lines.append(f'  \033[90m? {name}\033[0m')
+
+    return '\n'.join(lines)
+
+
+def _apply_changes(
+    client: LogfireClient,
+    organization: str,
+    project: str,
+    diff: VariableDiff,
+) -> None:
+    """Apply the changes to the server."""
+    for change in diff.changes:
+        if change.change_type == 'create':
+            _create_variable(client, organization, project, change)
+        elif change.change_type == 'update_schema':
+            _update_variable_schema(client, organization, project, change)
+
+
+def _create_variable(
+    client: LogfireClient,
+    organization: str,
+    project: str,
+    change: VariableChange,
+) -> None:
+    """Create a new variable on the server."""
+    body: dict[str, Any] = {
+        'name': change.name,
+        'json_schema': change.local_schema,
+    }
+
+    if change.initial_variant_value is not None:
+        # Has a static default - create a 'default' variant with 100% rollout
+        body['variants'] = {
+            'default': {
+                'serialized_value': change.initial_variant_value,
+                'description': 'Default value from code',
+            }
+        }
+        body['rollout'] = {'variants': {'default': 1.0}}
+    else:
+        # Default is a function - no server-side variant, empty rollout
+        body['variants'] = {}
+        body['rollout'] = {'variants': {}}
+
+    body['overrides'] = []
+
+    client.create_variable(organization, project, body)
+    print(f'  \033[32mCreated: {change.name}\033[0m')
+
+
+def _update_variable_schema(
+    client: LogfireClient,
+    organization: str,
+    project: str,
+    change: VariableChange,
+) -> None:
+    """Update an existing variable's schema on the server."""
+    server_id = change.server_id
+    if not server_id:
+        # Need to look up the variable by name to get its ID
+        var_data = client.get_variable_by_name(organization, project, change.name)
+        server_id = var_data['id']
+
+    body = {
+        'json_schema': change.local_schema,
+    }
+
+    client.update_variable(organization, project, server_id, body)
+    print(f'  \033[33mUpdated schema: {change.name}\033[0m')
+
+
+def _get_project_credentials(data_dir: str | None = None) -> tuple[str, str]:
+    """Get the organization and project from local credentials.
+
+    Args:
+        data_dir: Optional path to the data directory. Defaults to '.logfire'.
+
+    Returns:
+        Tuple of (organization, project_name)
+
+    Raises:
+        RuntimeError: If credentials are not found or cannot determine organization.
+    """
+    from pathlib import Path
+    from urllib.parse import urlparse
+
+    from logfire._internal.config import LogfireCredentials
+
+    creds_dir = Path(data_dir) if data_dir else Path('.logfire')
+    creds = LogfireCredentials.load_creds_file(creds_dir)
+
+    if creds is None:
+        raise RuntimeError(
+            f'No Logfire credentials found in {creds_dir.resolve()}. '
+            'Run your application with LOGFIRE_TOKEN set, '
+            'or use `logfire projects use` to select a project.'
+        )
+
+    # Parse org and project from project_url
+    # project_url is like: https://logfire.pydantic.dev/org-name/project-name
+    parsed = urlparse(creds.project_url)
+    path_parts = [p for p in parsed.path.split('/') if p]
+
+    if len(path_parts) >= 2:
+        return path_parts[0], path_parts[1]
+
+    # Fallback: try to get from the project list using the project_name
+    raise RuntimeError(
+        f'Could not determine organization from project URL: {creds.project_url}. '
+        'Expected format: https://logfire.pydantic.dev/org/project'
+    )
+
+
+def push_variables(
+    variables: list[Variable[Any]] | None = None,
+    *,
+    dry_run: bool = False,
+    yes: bool = False,
+    strict: bool = False,
+    data_dir: str | None = None,
+) -> bool:
+    """Push variable definitions to the Logfire server.
+
+    This function syncs local variable definitions with the server:
+    - Creates new variables that don't exist on the server
+    - Updates JSON schemas for existing variables if they've changed
+    - Warns about existing variants that are incompatible with new schemas
+
+    Args:
+        variables: Variable instances to push to the server. If None, all variables
+            registered with the default Logfire instance will be pushed.
+        dry_run: If True, only show what would change without applying.
+        yes: If True, skip confirmation prompt.
+        strict: If True, fail if any existing variants are incompatible with new schemas.
+        data_dir: Directory containing Logfire credentials. Defaults to '.logfire'.
+
+    Returns:
+        True if changes were applied (or would be applied in dry_run mode), False otherwise.
+
+    Example:
+        ```python
+        import logfire
+
+        feature_enabled = logfire.var(name='feature-enabled', default=False, type=bool)
+        max_retries = logfire.var(name='max-retries', default=3, type=int)
+
+        if __name__ == '__main__':
+            # Push all registered variables
+            logfire.push_variables()
+
+            # Or push specific variables only
+            logfire.push_variables([feature_enabled])
+        ```
+    """
+    import logfire as logfire_module
+    from logfire._internal.client import LogfireClient
+
+    if variables is None:
+        variables = logfire_module.DEFAULT_LOGFIRE_INSTANCE.get_variables()
+
+    if not variables:
+        print('No variables to push. Create variables using logfire.var() first.')
+        return False
+
+    # Get credentials
+    try:
+        organization, project = _get_project_credentials(data_dir)
+    except RuntimeError as e:
+        print(f'\033[31mError: {e}\033[0m', file=sys.stderr)
+        return False
+
+    print(f'Syncing variables for project: {organization}/{project}')
+
+    # Create client with user auth
+    try:
+        client = LogfireClient.from_url(None)
+    except Exception as e:
+        print('\033[31mError: Failed to authenticate. Run `logfire auth` first.\033[0m', file=sys.stderr)
+        print(f'\033[31m{e}\033[0m', file=sys.stderr)
+        return False
+
+    # Fetch current server config
+    try:
+        server_config = client.get_variables_config(organization, project)
+    except Exception as e:
+        print(f'\033[31mError fetching server config: {e}\033[0m', file=sys.stderr)
+        return False
+
+    # Compute diff
+    diff = _compute_diff(variables, server_config)
+
+    # Show diff
+    print(_format_diff(diff))
+
+    if not diff.has_changes:
+        print('\n\033[32mNo changes needed. Server is up to date.\033[0m')
+        return False
+
+    # Check for incompatible variants in strict mode
+    if strict:
+        has_incompatible = any(c.incompatible_variants for c in diff.changes if c.change_type == 'update_schema')
+        if has_incompatible:
+            print(
+                '\n\033[31mError: Some existing variants are incompatible with the new schema. '
+                'Remove --strict flag to proceed anyway.\033[0m',
+                file=sys.stderr,
+            )
+            return False
+
+    if dry_run:
+        print('\n\033[33mDry run mode - no changes applied.\033[0m')
+        return True
+
+    # Confirm with user
+    if not yes:
+        print()
+        try:
+            response_input = input('Apply these changes? [y/N] ')
+        except (EOFError, KeyboardInterrupt):
+            print('\nAborted.')
+            return False
+
+        if response_input.lower() not in ('y', 'yes'):
+            print('Aborted.')
+            return False
+
+    # Apply changes
+    print('\nApplying changes...')
+    try:
+        _apply_changes(client, organization, project, diff)
+    except Exception as e:
+        print(f'\033[31mError applying changes: {e}\033[0m', file=sys.stderr)
+        return False
+
+    print('\n\033[32mDone! Variables synced successfully.\033[0m')
+    return True
+
+
+@dataclass
+class VariantValidationError:
+    """Represents a validation error for a specific variant."""
+
+    variable_name: str
+    variant_key: str | None
+    error: Exception
+
+
+@dataclass
+class ValidationReport:
+    """Report of variable validation results."""
+
+    errors: list[VariantValidationError]
+    variables_checked: int
+    variables_not_on_server: list[str]
+
+    @property
+    def has_errors(self) -> bool:
+        """Return True if there are any validation errors."""
+        return len(self.errors) > 0 or len(self.variables_not_on_server) > 0
+
+
+def _format_validation_report(report: ValidationReport) -> str:
+    """Format a validation report for display to the user."""
+    lines: list[str] = []
+
+    if report.errors:
+        lines.append('\n\033[31m=== Validation Errors ===\033[0m')
+        for error in report.errors:
+            if error.variant_key is None:
+                lines.append(f'  \033[31m✗ {error.variable_name}: {error.error}\033[0m')
+            else:
+                lines.append(f'  \033[31m✗ {error.variable_name} (variant: {error.variant_key})\033[0m')
+                # Format the error message, indenting each line
+                error_lines = str(error.error).split('\n')
+                for line in error_lines[:5]:  # Limit to first 5 lines
+                    lines.append(f'      {line}')
+                if len(error_lines) > 5:
+                    lines.append(f'      ... ({len(error_lines) - 5} more lines)')
+
+    if report.variables_not_on_server:
+        lines.append('\n\033[33m=== Variables Not Found on Server ===\033[0m')
+        for name in report.variables_not_on_server:
+            lines.append(f'  \033[33m? {name}\033[0m')
+
+    valid_count = report.variables_checked - len(report.errors) - len(report.variables_not_on_server)
+    if valid_count > 0:
+        lines.append(f'\n\033[32m=== Valid ({valid_count} variables) ===\033[0m')
+
+    return '\n'.join(lines)
+
+
+def validate_variables(
+    variables: list[Variable[Any]] | None = None,
+    *,
+    data_dir: str | None = None,
+) -> bool:
+    """Validate that server-side variable variants match local type definitions.
+
+    This function fetches the current variable configuration from the server and
+    validates that all variant values can be deserialized to the expected types
+    defined in the local Variable instances.
+
+    Args:
+        variables: Variable instances to validate. If None, all variables
+            registered with the default Logfire instance will be validated.
+        data_dir: Directory containing Logfire credentials. Defaults to '.logfire'.
+
+    Returns:
+        True if all variables validated successfully, False if there were errors.
+
+    Example:
+        ```python
+        import logfire
+
+        feature_enabled = logfire.var(name='feature-enabled', default=False, type=bool)
+        max_retries = logfire.var(name='max-retries', default=3, type=int)
+
+        if __name__ == '__main__':
+            # Validate all registered variables
+            logfire.validate_variables()
+
+            # Or validate specific variables only
+            logfire.validate_variables([feature_enabled])
+        ```
+    """
+    import logfire as logfire_module
+    from logfire._internal.client import LogfireClient
+    from logfire.variables.config import VariablesConfig
+
+    if variables is None:
+        variables = logfire_module.DEFAULT_LOGFIRE_INSTANCE.get_variables()
+
+    if not variables:
+        print('No variables to validate. Create variables using logfire.var() first.')
+        return True  # No variables to validate is not an error
+
+    # Get credentials
+    try:
+        organization, project = _get_project_credentials(data_dir)
+    except RuntimeError as e:
+        print(f'\033[31mError: {e}\033[0m', file=sys.stderr)
+        return False
+
+    print(f'Validating variables for project: {organization}/{project}')
+
+    # Create client with user auth
+    try:
+        client = LogfireClient.from_url(None)
+    except Exception as e:
+        print('\033[31mError: Failed to authenticate. Run `logfire auth` first.\033[0m', file=sys.stderr)
+        print(f'\033[31m{e}\033[0m', file=sys.stderr)
+        return False
+
+    # Fetch current server config
+    try:
+        server_config_raw = client.get_variables_config(organization, project)
+    except Exception as e:
+        print(f'\033[31mError fetching server config: {e}\033[0m', file=sys.stderr)
+        return False
+
+    # Parse into VariablesConfig
+    try:
+        config = VariablesConfig.validate_python(server_config_raw)
+    except Exception as e:
+        print(f'\033[31mError parsing server config: {e}\033[0m', file=sys.stderr)
+        return False
+
+    # Find variables not on server
+    variables_not_on_server = [v.name for v in variables if v.name not in config.variables]
+
+    # Filter to variables that are on the server
+    variables_on_server = [v for v in variables if v.name in config.variables]
+
+    # Get validation errors
+    error_dict = config.get_validation_errors(variables_on_server)
+
+    # Build report
+    errors: list[VariantValidationError] = []
+    for var_name, variant_errors in error_dict.items():
+        for variant_key, error in variant_errors.items():
+            errors.append(
+                VariantValidationError(
+                    variable_name=var_name,
+                    variant_key=variant_key,
+                    error=error,
+                )
+            )
+
+    report = ValidationReport(
+        errors=errors,
+        variables_checked=len(variables),
+        variables_not_on_server=variables_not_on_server,
+    )
+
+    # Print report
+    print(_format_validation_report(report))
+
+    if report.has_errors:
+        error_count = len(report.errors) + len(report.variables_not_on_server)
+        print(f'\n\033[31mValidation failed: {error_count} error(s) found.\033[0m')
+        return False
+    else:
+        print(f'\n\033[32mValidation passed: All {report.variables_checked} variable(s) are valid.\033[0m')
+        return True
diff --git a/logfire/variables/remote.py b/logfire/variables/remote.py
new file mode 100644
index 000000000..59f5b4992
--- /dev/null
+++ b/logfire/variables/remote.py
@@ -0,0 +1,192 @@
+from __future__ import annotations as _annotations
+
+import os
+import threading
+import warnings
+import weakref
+from collections.abc import Mapping
+from datetime import datetime, timedelta, timezone
+from typing import Any
+from urllib.parse import urljoin
+
+from opentelemetry.util._once import Once
+from pydantic import ValidationError
+from requests import Session
+
+from logfire._internal.client import UA_HEADER
+from logfire._internal.config import RemoteVariablesConfig
+from logfire._internal.utils import UnexpectedResponse
+from logfire.variables.abstract import VariableProvider, VariableResolutionDetails
+from logfire.variables.config import VariablesConfig
+
+__all__ = ('LogfireRemoteVariableProvider',)
+
+
+# TODO: Do we need to provide a mechanism for whether the LogfireRemoteProvider should block to retrieve the config
+#   during startup or do synchronize in the background?
+class LogfireRemoteVariableProvider(VariableProvider):
+    """Variable provider that fetches configuration from a remote Logfire API.
+
+    The threading implementation draws heavily from opentelemetry.sdk._shared_internal.BatchProcessor.
+    """
+
+    def __init__(self, base_url: str, token: str, config: RemoteVariablesConfig):
+        """Create a new remote variable provider.
+
+        Args:
+            base_url: The base URL of the Logfire API.
+            token: Authentication token for the Logfire API.
+            config: Config for retrieving remote variables.
+        """
+        super().__init__()
+
+        block_before_first_resolve = config.block_before_first_resolve
+        polling_interval = config.polling_interval
+
+        self._base_url = base_url
+        self._session = Session()
+        self._session.headers.update({'Authorization': token, 'User-Agent': UA_HEADER})
+        self._block_before_first_fetch = block_before_first_resolve
+        self._polling_interval: timedelta = (
+            timedelta(seconds=polling_interval) if isinstance(polling_interval, float | int) else polling_interval
+        )
+
+        self._reset_once = Once()
+        self._has_attempted_fetch: bool = False
+        self._last_fetched_at: datetime | None = None
+
+        self._config: VariablesConfig | None = None
+        self._worker_thread = threading.Thread(
+            name='LogfireRemoteProvider',
+            target=self._worker,
+            daemon=True,
+        )
+
+        self._shutdown = False
+        self._shutdown_timeout_exceeded = False
+        self._refresh_lock = threading.Lock()
+        self._worker_awaken = threading.Event()
+        self._worker_thread.start()
+        if hasattr(os, 'register_at_fork'):
+            weak_reinit = weakref.WeakMethod(self._at_fork_reinit)
+            os.register_at_fork(after_in_child=lambda: weak_reinit()())  # pyright: ignore[reportOptionalCall]
+        self._pid = os.getpid()
+
+    def _at_fork_reinit(self):
+        # Recreate all things threading related
+        self._refresh_lock = threading.Lock()
+        self._worker_awaken = threading.Event()
+        self._worker_thread = threading.Thread(
+            name='LogfireRemoteProvider',
+            target=self._worker,
+            daemon=True,
+        )
+        self._worker_thread.start()
+        self._pid = os.getpid()
+
+    def _worker(self):
+        while not self._shutdown:
+            # Note: Ideally we'd be able to terminate while the following request was going even if it takes a while,
+            # it's far more reasonable to terminate this worker thread "gracelessly" than an OTel exporter's.
+            # But given this is pretty unlikely to cause issues, Alex and I decided are okay leaving this as-is.
+            # We can change this if we run into issues, but it doesn't seem to be causing any now.
+            self.refresh()
+            self._worker_awaken.clear()
+            self._worker_awaken.wait(self._polling_interval.total_seconds())
+            if self._shutdown:
+                break
+
+    def refresh(self, force: bool = False):
+        """Fetch the latest variable configuration from the remote API.
+
+        Args:
+            force: If True, fetch configuration even if the polling interval hasn't elapsed.
+        """
+        if self._refresh_lock.locked():
+            # If we're already fetching, we'll get a new value, so no need to force
+            force = False
+
+        # TODO: Probably makes sense to replace this with something that just polls for a version number or hash
+        #   or similar, rather than the whole config, and only grabs the whole config if that version or hash changes.
+        with self._refresh_lock:  # Make at most one request at a time
+            # TODO: Do we need to rethink how the force-refreshing works?
+            #   Right now if you tried to force-refresh multiple times in parallel,
+            #   it would jankily do all the requests in serial... this is presumably rare but still feels like bad implementation?
+            if (
+                not force
+                and self._last_fetched_at is not None
+                and self._last_fetched_at > datetime.now(tz=timezone.utc) - self._polling_interval
+            ):
+                return  # nothing to do
+
+            try:
+                variables_response = self._session.get(urljoin(self._base_url, '/v1/variables/'))
+                UnexpectedResponse.raise_for_status(variables_response)
+            except UnexpectedResponse:
+                # TODO: Update the following logic to be smarter
+                # TODO: Handle any error here, not just UnexpectedResponse, so we don't crash user application on failure
+                warnings.warn('Error retrieving variables', category=RuntimeWarning)
+                return
+
+            variables_config_data = variables_response.json()
+            try:
+                self._config = VariablesConfig.validate_python(variables_config_data)
+            except ValidationError as e:
+                # TODO: Update the following logic to be smarter
+                warnings.warn(str(e), category=RuntimeWarning)
+            finally:
+                self._has_attempted_fetch = True
+
+            # TODO: Should we set `_last_fetched_at` even on failure?
+            self._last_fetched_at = datetime.now(tz=timezone.utc)
+
+    def get_serialized_value(
+        self,
+        variable_name: str,
+        targeting_key: str | None = None,
+        attributes: Mapping[str, Any] | None = None,
+    ) -> VariableResolutionDetails[str | None]:
+        """Resolve a variable's serialized value from the remote configuration.
+
+        Args:
+            variable_name: The name of the variable to resolve.
+            targeting_key: Optional key for deterministic variant selection (e.g., user ID).
+            attributes: Optional attributes for condition-based targeting rules.
+
+        Returns:
+            A VariableResolutionDetails containing the serialized value (or None if not found).
+        """
+        if self._pid != os.getpid():
+            self._reset_once.do_once(self._at_fork_reinit)
+
+        if not self._has_attempted_fetch and self._block_before_first_fetch:
+            # Block while waiting for the request to be sent
+            # TODO: Should we have an async version of this method that doesn't block the event loop?
+            #   Note that we could add a force_refresh option to both this method and the async one to force it to eagerly get the latest value, perhaps useful during development..
+            # TODO: What's a good way to force the request to happen now and block until it's done?
+            #   The following should work thanks to the refresh_lock and the early exiting, but it feels like there's got to be a cleaner way to do all this?
+            self.refresh()
+
+        if self._config is None:
+            return VariableResolutionDetails(value=None, _reason='missing_config')
+
+        # TODO: Move the following down to a method on VariablesConfig
+        variable_config = self._config.variables.get(variable_name)
+        if variable_config is None:
+            return VariableResolutionDetails(value=None, _reason='unrecognized_variable')
+
+        variant = variable_config.resolve_variant(targeting_key, attributes)
+        if variant is None:
+            return VariableResolutionDetails(value=None, _reason='resolved')
+        else:
+            return VariableResolutionDetails(value=variant.serialized_value, variant=variant.key, _reason='resolved')
+
+    def shutdown(self):
+        """Stop the background polling thread and clean up resources."""
+        if self._shutdown:
+            return
+        self._shutdown = True
+        self._worker_awaken.set()
+
+        # TODO: Is there any circumstance under which we _should_ join the thread here?
+        # self._worker_thread.join(None)
diff --git a/logfire/variables/variable.py b/logfire/variables/variable.py
new file mode 100644
index 000000000..19d0e70bd
--- /dev/null
+++ b/logfire/variables/variable.py
@@ -0,0 +1,202 @@
+from __future__ import annotations as _annotations
+
+import inspect
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import replace
+from importlib.util import find_spec
+from typing import Any, Generic, Protocol, TypeVar
+
+from pydantic import TypeAdapter, ValidationError
+from typing_extensions import TypeIs
+
+if find_spec('anyio') is not None:
+    # Use anyio for running sync functions on separate threads in an event loop if it is available
+    from anyio.to_thread import run_sync as to_thread
+else:
+    from asyncio import to_thread
+
+import logfire
+from logfire.variables.abstract import VariableResolutionDetails
+
+__all__ = ('ResolveFunction', 'is_resolve_function', 'Variable')
+
+T = TypeVar('T')
+T_co = TypeVar('T_co', covariant=True)
+
+
+_VARIABLE_OVERRIDES = ContextVar[dict[str, Any] | None]('_VARIABLE_OVERRIDES', default=None)
+
+_DEFAULT_SENTINEL = object()
+
+
+class ResolveFunction(Protocol[T_co]):
+    """Protocol for functions that resolve variable values based on context."""
+
+    def __call__(self, targeting_key: str | None, attributes: Mapping[str, Any] | None) -> T_co:
+        """Resolve the variable value given a targeting key and attributes."""
+        raise NotImplementedError
+
+
+def is_resolve_function(f: Any) -> TypeIs[ResolveFunction[Any]]:
+    """Check if a callable matches the ResolveFunction signature.
+
+    Args:
+        f: The object to check.
+
+    Returns:
+        True if the callable has a signature matching ResolveFunction.
+    """
+    if not callable(f):
+        return False
+    signature = inspect.signature(f)
+    params = list(signature.parameters.values())
+    if len(params) == 2 and params[0].name == 'targeting_key' and params[1].name == 'attributes':
+        return True
+    return False
+
+
+class Variable(Generic[T]):
+    """A managed variable that can be resolved dynamically based on configuration."""
+
+    name: str
+    """Unique name identifying this variable."""
+    default: T | ResolveFunction[T]
+    """Default value or function to compute the default."""
+    value_type: type[T] | None = None
+    """The expected type of this variable's values."""
+
+    logfire_instance: logfire.Logfire
+    """The Logfire instance this variable is associated with."""
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        default: T | ResolveFunction[T],
+        type: type[T],
+        logfire_instance: logfire.Logfire,
+    ):
+        """Create a new managed variable.
+
+        Args:
+            name: Unique name identifying this variable.
+            default: Default value to use when no configuration is found, or a function
+                that computes the default based on targeting_key and attributes.
+            type: The expected type of this variable's values, used for validation.
+            logfire_instance: The Logfire instance this variable is associated with. Used to determine config, etc.
+        """
+        self.name = name
+        self.default = default
+
+        self.logfire_instance = logfire_instance
+        self.type_adapter = TypeAdapter[T](type)
+
+    @contextmanager
+    def override(self, value: T | ResolveFunction[T]) -> Iterator[None]:
+        """Context manager to temporarily override this variable's value.
+
+        Args:
+            value: The value to use within this context, or a function that computes
+                the value based on targeting_key and attributes.
+        """
+        current = _VARIABLE_OVERRIDES.get() or {}
+        token = _VARIABLE_OVERRIDES.set({**current, self.name: value})
+        try:
+            yield
+        finally:
+            _VARIABLE_OVERRIDES.reset(token)
+
+    async def refresh(self, force: bool = False):
+        """Asynchronously refresh the variable."""
+        await to_thread(self.refresh_sync, force)
+
+    def refresh_sync(self, force: bool = False):
+        """Synchronously refresh the variable."""
+        self.logfire_instance.config.get_variable_provider().refresh(force=force)
+
+    # TODO: add ok_or_default() to VariableResolutionDetails and make this just be get_details; so you do
+    #   .get().ok_or_default() to get the current behavior of this
+    def get(self, targeting_key: str | None = None, attributes: Mapping[str, Any] | None = None) -> T:
+        """Resolve and return the variable's value.
+
+        Args:
+            targeting_key: Optional key for deterministic variant selection (e.g., user ID).
+            attributes: Optional attributes for condition-based targeting rules.
+
+        Returns:
+            The resolved value of the variable.
+        """
+        return (self.get_details(targeting_key, attributes)).value
+
+    def get_details(
+        self, targeting_key: str | None = None, attributes: Mapping[str, Any] | None = None
+    ) -> VariableResolutionDetails[T]:
+        """Resolve the variable and return full details including variant and any errors.
+
+        Args:
+            targeting_key: Optional key for deterministic variant selection (e.g., user ID).
+            attributes: Optional attributes for condition-based targeting rules.
+
+        Returns:
+            A VariableResolutionDetails object containing the resolved value, selected variant,
+            and any errors that occurred.
+        """
+        merged_attributes = self._get_merged_attributes(attributes)
+
+        # TODO: How much of the following code should be in the try: except:?
+        try:
+            if (context_overrides := _VARIABLE_OVERRIDES.get()) is not None and (
+                context_value := context_overrides.get(self.name)
+            ) is not None:
+                if is_resolve_function(context_value):
+                    context_value = context_value(targeting_key, merged_attributes)
+                return VariableResolutionDetails(value=context_value, _reason='context_override')
+
+            provider = self.logfire_instance.config.get_variable_provider()
+            serialized_result = provider.get_serialized_value(self.name, targeting_key, merged_attributes)
+
+            if serialized_result.value is None:
+                default = self._get_default(targeting_key, merged_attributes)
+                return _with_value(serialized_result, default)
+
+            try:
+                value = self.type_adapter.validate_json(serialized_result.value)
+            except ValidationError as e:
+                default = self._get_default(targeting_key, merged_attributes)
+                return VariableResolutionDetails(value=default, exception=e, _reason='validation_error')
+
+            return VariableResolutionDetails(value=value, variant=serialized_result.variant, _reason='resolved')
+
+        except Exception as e:
+            default = self._get_default(targeting_key, merged_attributes)
+            return VariableResolutionDetails(value=default, exception=e, _reason='other_error')
+
+    def _get_default(self, targeting_key: str | None = None, merged_attributes: Mapping[str, Any] | None = None) -> T:
+        if is_resolve_function(self.default):
+            return self.default(targeting_key, merged_attributes)
+        else:
+            return self.default
+
+    def _get_merged_attributes(self, attributes: Mapping[str, Any] | None = None) -> Mapping[str, Any]:
+        result = dict(attributes) if attributes else {}
+        variables_options = self.logfire_instance.config.variables
+        if variables_options.include_baggage_in_context:
+            result.update(logfire.get_baggage())
+        if variables_options.include_resource_attributes_in_context:
+            result.update(self.logfire_instance.resource_attributes)
+        return result
+
+
+def _with_value(details: VariableResolutionDetails[Any], new_value: T) -> VariableResolutionDetails[T]:
+    """Return a copy of the provided resolution details, just with a different value.
+
+    Args:
+        details: Existing resolution details to modify.
+        new_value: The new value to use.
+
+    Returns:
+        A new VariableResolutionDetails with the given value.
+    """
+    return replace(details, value=new_value)
diff --git a/mkdocs.yml b/mkdocs.yml
index ac7878642..4bf1fca1c 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -171,6 +171,7 @@ nav:
   - Reference:
       - SQL: reference/sql.md
       - Advanced:
+          - Managed Variables: reference/advanced/managed-variables.md
           - Baggage: reference/advanced/baggage.md
           - Generators: reference/advanced/generators.md
           - Testing: reference/advanced/testing.md
diff --git a/pyproject.toml b/pyproject.toml
index 9167b9691..565b0e745 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -80,6 +80,7 @@ sqlite3 = ["opentelemetry-instrumentation-sqlite3 >= 0.42b0"]
 aws-lambda = ["opentelemetry-instrumentation-aws-lambda >= 0.42b0"]
 google-genai = ["opentelemetry-instrumentation-google-genai >= 0.4b0"]
 litellm = ["openinference-instrumentation-litellm >= 0"]
+variables = ["pydantic>=2.0.0"]  # TODO: Change minimum pydantic version?
 
 [project.urls]
 Homepage = "https://logfire.pydantic.dev/"
@@ -109,7 +110,7 @@ dev = [
     "pytest >= 8.3.4",
     "pytest-django >= 4.6.0",
     "pytest-pretty >= 1.2.0",
-    "pydantic @ git+https://github.com/pydantic/pydantic",
+    "pydantic >= 2.12.5",
     "requests >= 2.31.0",
     "sqlalchemy >= 1.4.54",
     "pandas>=2.1.2",
diff --git a/tests/test_configure.py b/tests/test_configure.py
index a462e12be..887cc9a7a 100644
--- a/tests/test_configure.py
+++ b/tests/test_configure.py
@@ -3,6 +3,7 @@
 import dataclasses
 import json
 import os
+import pickle
 import sys
 import threading
 from collections.abc import Iterable, Sequence
@@ -52,6 +53,7 @@
     ConsoleOptions,
     LogfireConfig,
     LogfireCredentials,
+    RemoteVariablesConfig,
     get_base_url_from_token,
     sanitize_project_name,
 )
@@ -846,6 +848,9 @@ def test_config_serializable():
         sampling=logfire.SamplingOptions(),
         scrubbing=logfire.ScrubbingOptions(),
         code_source=logfire.CodeSource(repository='https://github.com/pydantic/logfire', revision='main'),
+        variables=logfire.VariablesOptions(
+            config=RemoteVariablesConfig(block_before_first_resolve=False), include_baggage_in_context=False
+        ),
         advanced=logfire.AdvancedOptions(id_generator=SeededRandomIdGenerator(seed=42)),
     )
 
@@ -853,14 +858,14 @@ def test_config_serializable():
         # Check that the full set of dataclass fields is known.
         # If a new field appears here, make sure it gets deserialized properly in configure, and tested here.
         assert dataclasses.is_dataclass(getattr(GLOBAL_CONFIG, field.name)) == (
-            field.name in ['console', 'sampling', 'scrubbing', 'advanced', 'code_source']
+            field.name in ['console', 'sampling', 'scrubbing', 'advanced', 'code_source', 'variables']
         )
 
     serialized = serialize_config()
     assert serialized is not None  # Config should be picklable in this test
     GLOBAL_CONFIG._initialized = False  # type: ignore  # ensure deserialize_config actually configures
-    deserialize_config(serialized)
-    serialized2 = serialize_config()
+    deserialize_config(pickle.loads(pickle.dumps(serialized)))
+    serialized2 = pickle.loads(pickle.dumps(serialize_config()))
     assert serialized2 is not None  # Config should be picklable in this test
 
     def normalize(s: dict[str, Any]) -> dict[str, Any]:
@@ -875,6 +880,7 @@ def normalize(s: dict[str, Any]) -> dict[str, Any]:
     assert isinstance(GLOBAL_CONFIG.scrubbing, logfire.ScrubbingOptions)
     assert isinstance(GLOBAL_CONFIG.advanced, logfire.AdvancedOptions)
     assert isinstance(GLOBAL_CONFIG.advanced.id_generator, SeededRandomIdGenerator)
+    assert isinstance(GLOBAL_CONFIG.variables, logfire.VariablesOptions)
     assert GLOBAL_CONFIG.advanced.id_generator.seed == 42
 
 
diff --git a/tests/test_logfire_api.py b/tests/test_logfire_api.py
index 9b3702419..56714ae0a 100644
--- a/tests/test_logfire_api.py
+++ b/tests/test_logfire_api.py
@@ -128,6 +128,14 @@ def test_runtime(logfire_api_factory: Callable[[], ModuleType], module_name: str
     logfire_api.ConsoleOptions(colors='auto')
     logfire__all__.remove('ConsoleOptions')
 
+    assert hasattr(logfire_api, 'VariablesOptions')
+    logfire_api.VariablesOptions()
+    logfire__all__.remove('VariablesOptions')
+
+    assert hasattr(logfire_api, 'var')
+    logfire_api.var(name='test_var', default='default', type=str)
+    logfire__all__.remove('var')
+
     assert hasattr(logfire_api, 'PydanticPlugin')
     logfire_api.PydanticPlugin()
     logfire__all__.remove('PydanticPlugin')
@@ -276,6 +284,18 @@ def func() -> None: ...
         pass
     logfire__all__.remove('attach_context')
 
+    assert hasattr(logfire_api, 'get_variables')
+    assert isinstance(logfire_api.get_variables(), list)
+    logfire__all__.remove('get_variables')
+
+    assert hasattr(logfire_api, 'push_variables')
+    # NOTE: We don't call push_variables because it requires server connectivity.
+    logfire__all__.remove('push_variables')
+
+    assert hasattr(logfire_api, 'validate_variables')
+    # NOTE: We don't call validate_variables because it requires server connectivity.
+    logfire__all__.remove('validate_variables')
+
     # If it's not empty, it means that some of the __all__ members are not tested.
     assert logfire__all__ == set(), logfire__all__
 
diff --git a/tests/test_push_variables.py b/tests/test_push_variables.py
new file mode 100644
index 000000000..d1f7809d6
--- /dev/null
+++ b/tests/test_push_variables.py
@@ -0,0 +1,433 @@
+"""Tests for the push_variables functionality."""
+
+# pyright: reportPrivateUsage=false
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+import logfire
+from logfire.variables.push import (
+    ValidationReport,
+    VariableChange,
+    VariableDiff,
+    VariantValidationError,
+    _check_variant_compatibility,
+    _compute_diff,
+    _format_diff,
+    _format_validation_report,
+    _get_default_serialized,
+    _get_json_schema,
+)
+from logfire.variables.variable import Variable
+
+
+@dataclass
+class MockLogfire:
+    """Mock Logfire instance for testing."""
+
+    config: Any = None
+
+
+@pytest.fixture
+def mock_logfire_instance() -> MockLogfire:
+    """Create a mock Logfire instance."""
+    return MockLogfire()
+
+
+def test_get_json_schema_bool(mock_logfire_instance: MockLogfire) -> None:
+    """Test JSON schema generation for boolean type."""
+    var = Variable[bool](
+        name='test-bool',
+        default=False,
+        type=bool,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    schema = _get_json_schema(var)
+    assert schema == {'type': 'boolean'}
+
+
+def test_get_json_schema_int(mock_logfire_instance: MockLogfire) -> None:
+    """Test JSON schema generation for integer type."""
+    var = Variable[int](
+        name='test-int',
+        default=42,
+        type=int,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    schema = _get_json_schema(var)
+    assert schema == {'type': 'integer'}
+
+
+def test_get_json_schema_str(mock_logfire_instance: MockLogfire) -> None:
+    """Test JSON schema generation for string type."""
+    var = Variable[str](
+        name='test-str',
+        default='hello',
+        type=str,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    schema = _get_json_schema(var)
+    assert schema == {'type': 'string'}
+
+
+def test_get_default_serialized_static(mock_logfire_instance: MockLogfire) -> None:
+    """Test serialization of static default values."""
+    var = Variable[int](
+        name='test',
+        default=42,
+        type=int,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    serialized = _get_default_serialized(var)
+    assert serialized == '42'
+
+
+def test_get_default_serialized_bool(mock_logfire_instance: MockLogfire) -> None:
+    """Test serialization of boolean default values."""
+    var = Variable[bool](
+        name='test',
+        default=True,
+        type=bool,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    serialized = _get_default_serialized(var)
+    assert serialized == 'true'
+
+
+def test_get_default_serialized_function(mock_logfire_instance: MockLogfire) -> None:
+    """Test that function defaults return None."""
+    var = Variable[int](
+        name='test',
+        default=lambda targeting_key, attributes: 10,
+        type=int,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    serialized = _get_default_serialized(var)
+    assert serialized is None
+
+
+def test_check_variant_compatibility_valid(mock_logfire_instance: MockLogfire) -> None:
+    """Test variant compatibility check with valid value."""
+    var = Variable[int](
+        name='test',
+        default=0,
+        type=int,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    result = _check_variant_compatibility(var, 'test-variant', '42')
+    assert result.is_compatible is True
+    assert result.error is None
+
+
+def test_check_variant_compatibility_invalid(mock_logfire_instance: MockLogfire) -> None:
+    """Test variant compatibility check with invalid value."""
+    var = Variable[int](
+        name='test',
+        default=0,
+        type=int,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    result = _check_variant_compatibility(var, 'test-variant', '"not an int"')
+    assert result.is_compatible is False
+    assert result.error is not None
+
+
+def test_compute_diff_new_variable(mock_logfire_instance: MockLogfire) -> None:
+    """Test diff computation for a new variable."""
+    var = Variable[bool](
+        name='new-feature',
+        default=False,
+        type=bool,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    server_config: dict[str, Any] = {'variables': {}}
+
+    diff = _compute_diff([var], server_config)
+
+    assert len(diff.changes) == 1
+    assert diff.changes[0].name == 'new-feature'
+    assert diff.changes[0].change_type == 'create'
+    assert diff.changes[0].initial_variant_value == 'false'
+    assert diff.has_changes is True
+
+
+def test_compute_diff_no_change(mock_logfire_instance: MockLogfire) -> None:
+    """Test diff computation when variable exists with same schema."""
+    var = Variable[bool](
+        name='existing-feature',
+        default=False,
+        type=bool,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    server_config: dict[str, Any] = {
+        'variables': {
+            'existing-feature': {
+                'json_schema': {'type': 'boolean'},
+                'variants': {},
+            }
+        }
+    }
+
+    diff = _compute_diff([var], server_config)
+
+    assert len(diff.changes) == 1
+    assert diff.changes[0].name == 'existing-feature'
+    assert diff.changes[0].change_type == 'no_change'
+    assert diff.has_changes is False
+
+
+def test_compute_diff_schema_change(mock_logfire_instance: MockLogfire) -> None:
+    """Test diff computation when schema has changed."""
+    var = Variable[int](
+        name='config-value',
+        default=10,
+        type=int,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    server_config: dict[str, Any] = {
+        'variables': {
+            'config-value': {
+                'json_schema': {'type': 'string'},  # Was string, now int
+                'variants': {'default': {'serialized_value': '"hello"'}},
+            }
+        }
+    }
+
+    diff = _compute_diff([var], server_config)
+
+    assert len(diff.changes) == 1
+    assert diff.changes[0].name == 'config-value'
+    assert diff.changes[0].change_type == 'update_schema'
+    assert diff.changes[0].incompatible_variants is not None
+    assert len(diff.changes[0].incompatible_variants) == 1
+    assert diff.has_changes is True
+
+
+def test_compute_diff_orphaned_variables(mock_logfire_instance: MockLogfire) -> None:
+    """Test detection of orphaned server variables."""
+    var = Variable[bool](
+        name='my-feature',
+        default=False,
+        type=bool,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    server_config: dict[str, Any] = {
+        'variables': {
+            'my-feature': {
+                'json_schema': {'type': 'boolean'},
+                'variants': {},
+            },
+            'orphan-feature': {
+                'json_schema': {'type': 'boolean'},
+                'variants': {},
+            },
+        }
+    }
+
+    diff = _compute_diff([var], server_config)
+
+    assert 'orphan-feature' in diff.orphaned_server_variables
+    assert 'my-feature' not in diff.orphaned_server_variables
+
+
+def test_format_diff_creates() -> None:
+    """Test diff formatting for creates."""
+    diff = VariableDiff(
+        changes=[
+            VariableChange(
+                name='new-feature',
+                change_type='create',
+                local_schema={'type': 'boolean'},
+                initial_variant_value='false',
+            )
+        ],
+        orphaned_server_variables=[],
+    )
+    output = _format_diff(diff)
+    assert 'CREATE' in output
+    assert 'new-feature' in output
+
+
+def test_format_diff_updates() -> None:
+    """Test diff formatting for updates."""
+    diff = VariableDiff(
+        changes=[
+            VariableChange(
+                name='updated-feature',
+                change_type='update_schema',
+                local_schema={'type': 'integer'},
+                server_schema={'type': 'string'},
+            )
+        ],
+        orphaned_server_variables=[],
+    )
+    output = _format_diff(diff)
+    assert 'UPDATE' in output
+    assert 'updated-feature' in output
+
+
+def test_variable_diff_has_changes_true() -> None:
+    """Test has_changes when there are changes."""
+    diff = VariableDiff(
+        changes=[
+            VariableChange(name='test', change_type='create'),
+        ],
+        orphaned_server_variables=[],
+    )
+    assert diff.has_changes is True
+
+
+def test_variable_diff_has_changes_false() -> None:
+    """Test has_changes when there are no changes."""
+    diff = VariableDiff(
+        changes=[
+            VariableChange(name='test', change_type='no_change'),
+        ],
+        orphaned_server_variables=[],
+    )
+    assert diff.has_changes is False
+
+
+def test_push_variables_no_variables() -> None:
+    """Test push_variables with no variables."""
+    result = logfire.push_variables()
+    assert result is False
+
+
+def test_push_variables_with_explicit_list(mock_logfire_instance: MockLogfire) -> None:
+    """Test push_variables with an explicit list of variables."""
+    var = Variable[bool](
+        name='test-feature',
+        default=False,
+        type=bool,
+        logfire_instance=mock_logfire_instance,  # type: ignore
+    )
+    # Should return False since there are no credentials configured
+    result = logfire.push_variables([var])
+    assert result is False
+
+
+def test_var_registers_variable() -> None:
+    """Test that var() registers variables with the logfire instance."""
+    from logfire._internal.main import Logfire
+
+    lf = Logfire()
+    assert lf.get_variables() == []
+
+    var1 = lf.var(name='test-var-1', default=True, type=bool)
+    assert len(lf.get_variables()) == 1
+    assert lf.get_variables()[0] is var1
+
+    var2 = lf.var(name='test-var-2', default=42, type=int)
+    assert len(lf.get_variables()) == 2
+    assert var2 in lf.get_variables()
+
+
+def test_get_variables_returns_all_registered() -> None:
+    """Test that get_variables returns all registered variables."""
+    from logfire._internal.main import Logfire
+
+    lf = Logfire()
+    var1 = lf.var(name='feature-a', default=False, type=bool)
+    var2 = lf.var(name='feature-b', default='hello', type=str)
+    var3 = lf.var(name='feature-c', default=100, type=int)
+
+    variables = lf.get_variables()
+    assert len(variables) == 3
+    assert var1 in variables
+    assert var2 in variables
+    assert var3 in variables
+
+
+# --- Validation tests ---
+
+
+def test_validation_report_has_errors_true_with_errors() -> None:
+    """Test has_errors when there are validation errors."""
+    report = ValidationReport(
+        errors=[
+            VariantValidationError(
+                variable_name='test',
+                variant_key='default',
+                error=ValueError('invalid'),
+            )
+        ],
+        variables_checked=1,
+        variables_not_on_server=[],
+    )
+    assert report.has_errors is True
+
+
+def test_validation_report_has_errors_true_with_missing() -> None:
+    """Test has_errors when there are missing variables."""
+    report = ValidationReport(
+        errors=[],
+        variables_checked=1,
+        variables_not_on_server=['missing-var'],
+    )
+    assert report.has_errors is True
+
+
+def test_validation_report_has_errors_false() -> None:
+    """Test has_errors when there are no errors."""
+    report = ValidationReport(
+        errors=[],
+        variables_checked=2,
+        variables_not_on_server=[],
+    )
+    assert report.has_errors is False
+
+
+def test_format_validation_report_with_errors() -> None:
+    """Test validation report formatting with errors."""
+    report = ValidationReport(
+        errors=[
+            VariantValidationError(
+                variable_name='my-feature',
+                variant_key='default',
+                error=ValueError('value is not valid'),
+            )
+        ],
+        variables_checked=1,
+        variables_not_on_server=[],
+    )
+    output = _format_validation_report(report)
+    assert 'Validation Errors' in output
+    assert 'my-feature' in output
+    assert 'default' in output
+
+
+def test_format_validation_report_with_missing() -> None:
+    """Test validation report formatting with missing variables."""
+    report = ValidationReport(
+        errors=[],
+        variables_checked=2,
+        variables_not_on_server=['missing-feature'],
+    )
+    output = _format_validation_report(report)
+    assert 'Not Found on Server' in output
+    assert 'missing-feature' in output
+
+
+def test_format_validation_report_all_valid() -> None:
+    """Test validation report formatting when all valid."""
+    report = ValidationReport(
+        errors=[],
+        variables_checked=3,
+        variables_not_on_server=[],
+    )
+    output = _format_validation_report(report)
+    assert 'Valid (3 variables)' in output
+
+
+def test_validate_variables_no_variables() -> None:
+    """Test validate_variables with no variables."""
+    # Without the following patch, you get a 'No Logfire credentials found' error
+    with patch.dict(os.environ, {'LOGFIRE_TOKEN': '...'}):
+        result = logfire.validate_variables()
+        assert result is True  # No variables to validate is success
diff --git a/tests/test_variables.py b/tests/test_variables.py
new file mode 100644
index 000000000..7d941a3b2
--- /dev/null
+++ b/tests/test_variables.py
@@ -0,0 +1,1684 @@
+"""Tests for managed variables."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Mapping
+from datetime import timedelta
+from typing import Any
+
+import pytest
+import requests_mock as requests_mock_module
+from pydantic import BaseModel, ValidationError
+
+import logfire
+from logfire._internal.config import RemoteVariablesConfig, VariablesOptions
+from logfire.variables.abstract import NoOpVariableProvider, VariableProvider, VariableResolutionDetails
+from logfire.variables.config import (
+    KeyIsNotPresent,
+    KeyIsPresent,
+    Rollout,
+    RolloutOverride,
+    # RolloutSchedule,
+    # RolloutStage,
+    ValueDoesNotEqual,
+    ValueDoesNotMatchRegex,
+    ValueEquals,
+    ValueIsIn,
+    ValueIsNotIn,
+    ValueMatchesRegex,
+    VariableConfig,
+    VariablesConfig,
+    Variant,
+)
+from logfire.variables.local import LocalVariableProvider
+from logfire.variables.remote import LogfireRemoteVariableProvider
+from logfire.variables.variable import is_resolve_function
+
+# =============================================================================
+# Test Condition Classes
+# =============================================================================
+
+
+class TestValueEquals:
+    def test_matches_when_equal(self):
+        condition = ValueEquals(attribute='plan', value='enterprise')
+        assert condition.matches({'plan': 'enterprise'}) is True
+
+    def test_no_match_when_different(self):
+        condition = ValueEquals(attribute='plan', value='enterprise')
+        assert condition.matches({'plan': 'free'}) is False
+
+    def test_no_match_when_missing(self):
+        condition = ValueEquals(attribute='plan', value='enterprise')
+        assert condition.matches({}) is False
+
+    def test_kind_discriminator(self):
+        condition = ValueEquals(attribute='plan', value='enterprise')
+        assert condition.kind == 'value-equals'
+
+
+class TestValueDoesNotEqual:
+    def test_matches_when_different(self):
+        condition = ValueDoesNotEqual(attribute='plan', value='enterprise')
+        assert condition.matches({'plan': 'free'}) is True
+
+    def test_no_match_when_equal(self):
+        condition = ValueDoesNotEqual(attribute='plan', value='enterprise')
+        assert condition.matches({'plan': 'enterprise'}) is False
+
+    def test_matches_when_missing(self):
+        # When missing, uses object() sentinel which won't equal any value
+        condition = ValueDoesNotEqual(attribute='plan', value='enterprise')
+        assert condition.matches({}) is True
+
+    def test_kind_discriminator(self):
+        condition = ValueDoesNotEqual(attribute='plan', value='enterprise')
+        assert condition.kind == 'value-does-not-equal'
+
+
+class TestValueIsIn:
+    def test_matches_when_in_list(self):
+        condition = ValueIsIn(attribute='country', values=['US', 'UK', 'CA'])
+        assert condition.matches({'country': 'US'}) is True
+
+    def test_no_match_when_not_in_list(self):
+        condition = ValueIsIn(attribute='country', values=['US', 'UK', 'CA'])
+        assert condition.matches({'country': 'DE'}) is False
+
+    def test_no_match_when_missing(self):
+        condition = ValueIsIn(attribute='country', values=['US', 'UK', 'CA'])
+        assert condition.matches({}) is False
+
+    def test_kind_discriminator(self):
+        condition = ValueIsIn(attribute='country', values=['US', 'UK'])
+        assert condition.kind == 'value-is-in'
+
+
+class TestValueIsNotIn:
+    def test_matches_when_not_in_list(self):
+        condition = ValueIsNotIn(attribute='country', values=['blocked', 'restricted'])
+        assert condition.matches({'country': 'US'}) is True
+
+    def test_no_match_when_in_list(self):
+        condition = ValueIsNotIn(attribute='country', values=['blocked', 'restricted'])
+        assert condition.matches({'country': 'blocked'}) is False
+
+    def test_matches_when_missing(self):
+        # When missing, uses object() sentinel which won't be in the list
+        condition = ValueIsNotIn(attribute='country', values=['blocked', 'restricted'])
+        assert condition.matches({}) is True
+
+    def test_kind_discriminator(self):
+        condition = ValueIsNotIn(attribute='country', values=['blocked'])
+        assert condition.kind == 'value-is-not-in'
+
+
+class TestValueMatchesRegex:
+    def test_matches_regex(self):
+        condition = ValueMatchesRegex(attribute='email', pattern=r'@example\.com$')
+        assert condition.matches({'email': 'user@example.com'}) is True
+
+    def test_no_match_regex(self):
+        condition = ValueMatchesRegex(attribute='email', pattern=r'@example\.com$')
+        assert condition.matches({'email': 'user@other.com'}) is False
+
+    def test_no_match_when_missing(self):
+        condition = ValueMatchesRegex(attribute='email', pattern=r'@example\.com$')
+        assert condition.matches({}) is False
+
+    def test_no_match_when_not_string(self):
+        condition = ValueMatchesRegex(attribute='email', pattern=r'@example\.com$')
+        assert condition.matches({'email': 123}) is False
+
+    def test_kind_discriminator(self):
+        condition = ValueMatchesRegex(attribute='email', pattern=r'.*')
+        assert condition.kind == 'value-matches-regex'
+
+
+class TestValueDoesNotMatchRegex:
+    def test_matches_when_no_match(self):
+        # Note: This condition returns True if the string matches the pattern
+        # (which seems like a bug in the implementation)
+        condition = ValueDoesNotMatchRegex(attribute='email', pattern=r'@blocked\.com$')
+        # The implementation actually returns True when pattern MATCHES (bug?)
+        assert condition.matches({'email': 'user@blocked.com'}) is True
+
+    def test_no_match_when_pattern_matches(self):
+        condition = ValueDoesNotMatchRegex(attribute='email', pattern=r'@blocked\.com$')
+        assert condition.matches({'email': 'user@other.com'}) is False
+
+    def test_no_match_when_missing(self):
+        condition = ValueDoesNotMatchRegex(attribute='email', pattern=r'.*')
+        assert condition.matches({}) is False
+
+    def test_no_match_when_not_string(self):
+        condition = ValueDoesNotMatchRegex(attribute='email', pattern=r'.*')
+        assert condition.matches({'email': 123}) is False
+
+    def test_kind_discriminator(self):
+        condition = ValueDoesNotMatchRegex(attribute='email', pattern=r'.*')
+        assert condition.kind == 'value-does-not-match-regex'
+
+
+class TestKeyIsPresent:
+    def test_matches_when_present(self):
+        condition = KeyIsPresent(attribute='custom_prompt')
+        assert condition.matches({'custom_prompt': 'value'}) is True
+
+    def test_matches_when_present_with_none(self):
+        condition = KeyIsPresent(attribute='custom_prompt')
+        assert condition.matches({'custom_prompt': None}) is True
+
+    def test_no_match_when_missing(self):
+        condition = KeyIsPresent(attribute='custom_prompt')
+        assert condition.matches({}) is False
+
+    def test_kind_discriminator(self):
+        condition = KeyIsPresent(attribute='key')
+        assert condition.kind == 'key-is-present'
+
+
+class TestKeyIsNotPresent:
+    def test_matches_when_missing(self):
+        condition = KeyIsNotPresent(attribute='deprecated_flag')
+        assert condition.matches({}) is True
+
+    def test_no_match_when_present(self):
+        condition = KeyIsNotPresent(attribute='deprecated_flag')
+        assert condition.matches({'deprecated_flag': True}) is False
+
+    def test_kind_discriminator(self):
+        condition = KeyIsNotPresent(attribute='key')
+        assert condition.kind == 'key-is-not-present'
+
+
+# =============================================================================
+# Test Rollout
+# =============================================================================
+
+
+class TestRollout:
+    def test_select_variant_deterministic_with_seed(self):
+        rollout = Rollout(variants={'v1': 0.5, 'v2': 0.5})
+        # With a seed, the result should be deterministic
+        result1 = rollout.select_variant('user123')
+        result2 = rollout.select_variant('user123')
+        assert result1 == result2
+
+    def test_select_variant_different_seeds_can_differ(self):
+        rollout = Rollout(variants={'v1': 0.5, 'v2': 0.5})
+        # Different seeds may produce different results
+        results = {rollout.select_variant(f'user{i}') for i in range(100)}
+        # With 50/50 split, we should see both variants
+        assert results == {'v1', 'v2'}
+
+    def test_select_variant_can_return_none(self):
+        rollout = Rollout(variants={'v1': 0.3})  # 70% chance of None
+        results = {rollout.select_variant(f'user{i}') for i in range(100)}
+        # Should include None in results
+        assert None in results
+        assert 'v1' in results
+
+    def test_select_variant_full_probability(self):
+        rollout = Rollout(variants={'v1': 1.0})
+        for i in range(10):
+            assert rollout.select_variant(f'user{i}') == 'v1'
+
+    def test_select_variant_without_seed(self):
+        rollout = Rollout(variants={'v1': 0.5, 'v2': 0.5})
+        # Without seed, still works but isn't deterministic
+        result = rollout.select_variant(None)
+        assert result in {'v1', 'v2'}
+
+    def test_validation_sum_exceeds_one(self):
+        # Note: Validation only runs when using TypeAdapter (not direct instantiation)
+        from pydantic import TypeAdapter
+
+        adapter = TypeAdapter(Rollout)
+        with pytest.raises(ValidationError, match='Variant proportions must not sum to more than 1'):
+            adapter.validate_python({'variants': {'v1': 0.6, 'v2': 0.6}})
+
+
+# =============================================================================
+# Test Variant
+# =============================================================================
+
+
+class TestVariant:
+    def test_basic_variant(self):
+        variant = Variant(key='v1', serialized_value='"hello"')
+        assert variant.key == 'v1'
+        assert variant.serialized_value == '"hello"'
+        assert variant.description is None
+        assert variant.version is None
+
+    def test_variant_with_metadata(self):
+        variant = Variant(
+            key='v1',
+            serialized_value='"hello"',
+            description='Test variant',
+            version='1.0.0',
+        )
+        assert variant.description == 'Test variant'
+        assert variant.version == '1.0.0'
+
+
+# =============================================================================
+# Test RolloutOverride
+# =============================================================================
+
+
+class TestRolloutOverride:
+    def test_basic_override(self):
+        override = RolloutOverride(
+            conditions=[ValueEquals(attribute='plan', value='enterprise')],
+            rollout=Rollout(variants={'premium': 1.0}),
+        )
+        assert len(override.conditions) == 1
+        assert override.rollout.variants == {'premium': 1.0}
+
+    def test_multiple_conditions(self):
+        override = RolloutOverride(
+            conditions=[
+                ValueEquals(attribute='plan', value='enterprise'),
+                ValueIsIn(attribute='country', values=['US', 'UK']),
+            ],
+            rollout=Rollout(variants={'premium': 1.0}),
+        )
+        assert len(override.conditions) == 2
+
+
+# # =============================================================================
+# # Test RolloutStage
+# # =============================================================================
+#
+#
+# class TestRolloutStage:
+#     def test_basic_stage(self):
+#         stage = RolloutStage(
+#             duration=timedelta(hours=1),
+#             rollout=Rollout(variants={'v1': 0.1}),
+#             overrides=[],
+#         )
+#         assert stage.duration == timedelta(hours=1)
+#         assert stage.rollout.variants == {'v1': 0.1}
+#         assert stage.overrides == []
+#
+#     def test_stage_with_overrides(self):
+#         stage = RolloutStage(
+#             duration=timedelta(hours=2),
+#             rollout=Rollout(variants={'v1': 0.5}),
+#             overrides=[
+#                 RolloutOverride(
+#                     conditions=[ValueEquals(attribute='beta', value=True)],
+#                     rollout=Rollout(variants={'v1': 1.0}),
+#                 ),
+#             ],
+#         )
+#         assert len(stage.overrides) == 1
+#
+#
+# # =============================================================================
+# # Test RolloutSchedule
+# # =============================================================================
+#
+#
+# class TestRolloutSchedule:
+#     def test_inactive_schedule_returns_none(self):
+#         """Schedule with start_at=None is inactive."""
+#         schedule = RolloutSchedule(
+#             start_at=None,
+#             stages=[
+#                 RolloutStage(
+#                     duration=timedelta(hours=1),
+#                     rollout=Rollout(variants={'v1': 0.1}),
+#                     overrides=[],
+#                 ),
+#             ],
+#         )
+#         assert schedule.get_active_stage() is None
+#
+#     def test_future_schedule_returns_none(self):
+#         """Schedule with start_at in the future is not yet active."""
+#         future_time = datetime.now(timezone.utc) + timedelta(hours=1)
+#         schedule = RolloutSchedule(
+#             start_at=future_time,
+#             stages=[
+#                 RolloutStage(
+#                     duration=timedelta(hours=1),
+#                     rollout=Rollout(variants={'v1': 0.1}),
+#                     overrides=[],
+#                 ),
+#             ],
+#         )
+#         assert schedule.get_active_stage() is None
+#
+#     def test_first_stage_active(self):
+#         """When within first stage duration, first stage is active."""
+#         now = datetime.now(timezone.utc)
+#         start_time = now - timedelta(minutes=30)  # Started 30 minutes ago
+#         schedule = RolloutSchedule(
+#             start_at=start_time,
+#             stages=[
+#                 RolloutStage(
+#                     duration=timedelta(hours=1),  # Stage 1: 1 hour
+#                     rollout=Rollout(variants={'v1': 0.1}),
+#                     overrides=[],
+#                 ),
+#                 RolloutStage(
+#                     duration=timedelta(hours=2),  # Stage 2: 2 hours
+#                     rollout=Rollout(variants={'v1': 0.5}),
+#                     overrides=[],
+#                 ),
+#             ],
+#         )
+#         active = schedule.get_active_stage(now=now)
+#         assert active is not None
+#         assert active.rollout.variants == {'v1': 0.1}
+#
+#     def test_second_stage_active(self):
+#         """When past first stage but within second, second stage is active."""
+#         now = datetime.now(timezone.utc)
+#         start_time = now - timedelta(hours=1, minutes=30)  # Started 1.5 hours ago
+#         schedule = RolloutSchedule(
+#             start_at=start_time,
+#             stages=[
+#                 RolloutStage(
+#                     duration=timedelta(hours=1),  # Stage 1: ends at 1 hour
+#                     rollout=Rollout(variants={'v1': 0.1}),
+#                     overrides=[],
+#                 ),
+#                 RolloutStage(
+#                     duration=timedelta(hours=2),  # Stage 2: ends at 3 hours
+#                     rollout=Rollout(variants={'v1': 0.5}),
+#                     overrides=[],
+#                 ),
+#             ],
+#         )
+#         active = schedule.get_active_stage(now=now)
+#         assert active is not None
+#         assert active.rollout.variants == {'v1': 0.5}
+#
+#     def test_completed_schedule_returns_none(self):
+#         """When all stages have elapsed, returns None."""
+#         now = datetime.now(timezone.utc)
+#         start_time = now - timedelta(hours=5)  # Started 5 hours ago
+#         schedule = RolloutSchedule(
+#             start_at=start_time,
+#             stages=[
+#                 RolloutStage(
+#                     duration=timedelta(hours=1),  # Stage 1: ends at 1 hour
+#                     rollout=Rollout(variants={'v1': 0.1}),
+#                     overrides=[],
+#                 ),
+#                 RolloutStage(
+#                     duration=timedelta(hours=2),  # Stage 2: ends at 3 hours
+#                     rollout=Rollout(variants={'v1': 0.5}),
+#                     overrides=[],
+#                 ),
+#             ],
+#         )
+#         # Total duration is 3 hours, we're at 5 hours, so schedule is complete
+#         assert schedule.get_active_stage(now=now) is None
+#
+#     def test_exact_boundary_uses_next_stage(self):
+#         """At exact stage boundary, uses the next stage."""
+#         now = datetime.now(timezone.utc)
+#         start_time = now - timedelta(hours=1)  # Exactly at stage 1 boundary
+#         schedule = RolloutSchedule(
+#             start_at=start_time,
+#             stages=[
+#                 RolloutStage(
+#                     duration=timedelta(hours=1),  # Stage 1: ends exactly now
+#                     rollout=Rollout(variants={'v1': 0.1}),
+#                     overrides=[],
+#                 ),
+#                 RolloutStage(
+#                     duration=timedelta(hours=2),
+#                     rollout=Rollout(variants={'v1': 0.5}),
+#                     overrides=[],
+#                 ),
+#             ],
+#         )
+#         active = schedule.get_active_stage(now=now)
+#         assert active is not None
+#         assert active.rollout.variants == {'v1': 0.5}
+#
+#     def test_third_stage_active(self):
+#         """Test progression through multiple stages."""
+#         now = datetime.now(timezone.utc)
+#         # Started 4 hours ago: past stage 1 (1h) and stage 2 (2h), in stage 3
+#         start_time = now - timedelta(hours=4)
+#         schedule = RolloutSchedule(
+#             start_at=start_time,
+#             stages=[
+#                 RolloutStage(
+#                     duration=timedelta(hours=1),
+#                     rollout=Rollout(variants={'v1': 0.05}),
+#                     overrides=[],
+#                 ),
+#                 RolloutStage(
+#                     duration=timedelta(hours=2),
+#                     rollout=Rollout(variants={'v1': 0.25}),
+#                     overrides=[],
+#                 ),
+#                 RolloutStage(
+#                     duration=timedelta(hours=4),
+#                     rollout=Rollout(variants={'v1': 1.0}),
+#                     overrides=[],
+#                 ),
+#             ],
+#         )
+#         active = schedule.get_active_stage(now=now)
+#         assert active is not None
+#         assert active.rollout.variants == {'v1': 1.0}
+
+
+# =============================================================================
+# Test VariableConfig
+# =============================================================================
+
+
+class TestVariableConfig:
+    @pytest.fixture
+    def simple_config(self) -> VariableConfig:
+        return VariableConfig(
+            name='test_var',
+            variants={
+                'default': Variant(key='default', serialized_value='"default value"'),
+                'experimental': Variant(key='experimental', serialized_value='"experimental value"'),
+            },
+            rollout=Rollout(variants={'default': 0.8, 'experimental': 0.2}),
+            overrides=[],
+        )
+
+    @pytest.fixture
+    def config_with_overrides(self) -> VariableConfig:
+        return VariableConfig(
+            name='test_var',
+            variants={
+                'default': Variant(key='default', serialized_value='"default value"'),
+                'premium': Variant(key='premium', serialized_value='"premium value"'),
+            },
+            rollout=Rollout(variants={'default': 1.0}),
+            overrides=[
+                RolloutOverride(
+                    conditions=[ValueEquals(attribute='plan', value='enterprise')],
+                    rollout=Rollout(variants={'premium': 1.0}),
+                ),
+            ],
+        )
+
+    def test_resolve_variant_basic(self, simple_config: VariableConfig):
+        # Deterministic selection with targeting_key
+        variant = simple_config.resolve_variant(targeting_key='user123')
+        assert variant is not None
+        assert variant.key in {'default', 'experimental'}
+
+    def test_resolve_variant_with_override(self, config_with_overrides: VariableConfig):
+        # Without matching attributes, uses default rollout
+        variant = config_with_overrides.resolve_variant(targeting_key='user1')
+        assert variant is not None
+        assert variant.key == 'default'
+
+        # With matching attributes, uses override rollout
+        variant = config_with_overrides.resolve_variant(
+            targeting_key='user1',
+            attributes={'plan': 'enterprise'},
+        )
+        assert variant is not None
+        assert variant.key == 'premium'
+
+    def test_resolve_variant_can_return_none(self):
+        config = VariableConfig(
+            name='test_var',
+            variants={'v1': Variant(key='v1', serialized_value='"value"')},
+            rollout=Rollout(variants={'v1': 0.5}),  # 50% chance of None
+            overrides=[],
+        )
+        # Try many times to get None
+        results = [config.resolve_variant(targeting_key=f'user{i}') for i in range(100)]
+        keys = {v.key if v else None for v in results}
+        assert None in keys
+
+    def test_validation_invalid_variant_key(self):
+        from pydantic import TypeAdapter
+
+        adapter = TypeAdapter(VariableConfig)
+        with pytest.raises(ValidationError, match='invalid lookup key'):
+            adapter.validate_python(
+                {
+                    'name': 'test',
+                    'variants': {
+                        'wrong_key': {'key': 'correct_key', 'serialized_value': '"value"'},
+                    },
+                    'rollout': {'variants': {'correct_key': 1.0}},
+                    'overrides': [],
+                }
+            )
+
+    def test_validation_rollout_references_missing_variant(self):
+        from pydantic import TypeAdapter
+
+        adapter = TypeAdapter(VariableConfig)
+        with pytest.raises(ValidationError, match="Variant 'missing' present in `rollout.variants` is not present"):
+            adapter.validate_python(
+                {
+                    'name': 'test',
+                    'variants': {
+                        'v1': {'key': 'v1', 'serialized_value': '"value"'},
+                    },
+                    'rollout': {'variants': {'missing': 1.0}},
+                    'overrides': [],
+                }
+            )
+
+    def test_validation_override_references_missing_variant(self):
+        from pydantic import TypeAdapter
+
+        adapter = TypeAdapter(VariableConfig)
+        with pytest.raises(ValidationError, match="Variant 'missing' present in `overrides"):
+            adapter.validate_python(
+                {
+                    'name': 'test',
+                    'variants': {
+                        'v1': {'key': 'v1', 'serialized_value': '"value"'},
+                    },
+                    'rollout': {'variants': {'v1': 1.0}},
+                    'overrides': [
+                        {
+                            'conditions': [],
+                            'rollout': {'variants': {'missing': 1.0}},
+                        }
+                    ],
+                }
+            )
+
+    def test_validation_schedule_stage_references_missing_variant(self):
+        from pydantic import TypeAdapter
+
+        adapter = TypeAdapter(VariableConfig)
+        with pytest.raises(ValidationError, match="Variant 'missing' present in `schedule.stages"):
+            adapter.validate_python(
+                {
+                    'name': 'test',
+                    'variants': {
+                        'v1': {'key': 'v1', 'serialized_value': '"value"'},
+                    },
+                    'rollout': {'variants': {'v1': 1.0}},
+                    'overrides': [],
+                    'schedule': {
+                        'start_at': '2024-01-01T00:00:00Z',
+                        'stages': [
+                            {
+                                'duration': 'PT1H',
+                                'rollout': {'variants': {'missing': 1.0}},
+                                'overrides': [],
+                            }
+                        ],
+                    },
+                }
+            )
+
+    def test_validation_schedule_stage_override_references_missing_variant(self):
+        from pydantic import TypeAdapter
+
+        adapter = TypeAdapter(VariableConfig)
+        with pytest.raises(ValidationError, match="Variant 'missing' present in `schedule.stages"):
+            adapter.validate_python(
+                {
+                    'name': 'test',
+                    'variants': {
+                        'v1': {'key': 'v1', 'serialized_value': '"value"'},
+                    },
+                    'rollout': {'variants': {'v1': 1.0}},
+                    'overrides': [],
+                    'schedule': {
+                        'start_at': '2024-01-01T00:00:00Z',
+                        'stages': [
+                            {
+                                'duration': 'PT1H',
+                                'rollout': {'variants': {'v1': 1.0}},
+                                'overrides': [
+                                    {
+                                        'conditions': [],
+                                        'rollout': {'variants': {'missing': 1.0}},
+                                    }
+                                ],
+                            }
+                        ],
+                    },
+                }
+            )
+
+
+# # =============================================================================
+# # Test VariableConfig with RolloutSchedule
+# # =============================================================================
+#
+#
+# class TestVariableConfigWithSchedule:
+#     @pytest.fixture
+#     def config_with_schedule(self) -> VariableConfig:
+#         """Config with schedule that has different rollouts per stage."""
+#         now = datetime.now(timezone.utc)
+#         return VariableConfig(
+#             name='scheduled_var',
+#             variants={
+#                 'control': Variant(key='control', serialized_value='"control value"'),
+#                 'treatment': Variant(key='treatment', serialized_value='"treatment value"'),
+#             },
+#             # Base rollout: 100% control (used before schedule or after schedule completes)
+#             rollout=Rollout(variants={'control': 1.0}),
+#             overrides=[],
+#             schedule=RolloutSchedule(
+#                 start_at=now - timedelta(minutes=30),  # Started 30 minutes ago
+#                 stages=[
+#                     # Stage 1: 10% treatment (canary) for 1 hour
+#                     RolloutStage(
+#                         duration=timedelta(hours=1),
+#                         rollout=Rollout(variants={'control': 0.9, 'treatment': 0.1}),
+#                         overrides=[],
+#                     ),
+#                     # Stage 2: 50% treatment for 2 hours
+#                     RolloutStage(
+#                         duration=timedelta(hours=2),
+#                         rollout=Rollout(variants={'control': 0.5, 'treatment': 0.5}),
+#                         overrides=[],
+#                     ),
+#                     # Stage 3: 100% treatment for 1 hour (full rollout)
+#                     RolloutStage(
+#                         duration=timedelta(hours=1),
+#                         rollout=Rollout(variants={'treatment': 1.0}),
+#                         overrides=[],
+#                     ),
+#                 ],
+#             ),
+#         )
+#
+#     def test_resolve_uses_active_schedule_stage(self, config_with_schedule: VariableConfig):
+#         """resolve_variant should use the active schedule stage's rollout."""
+#         # The schedule started 30 minutes ago, so we're in stage 1 (10% treatment)
+#         # Sample many times to verify the distribution
+#         results = [config_with_schedule.resolve_variant(targeting_key=f'user{i}') for i in range(1000)]
+#         treatment_count = sum(1 for r in results if r and r.key == 'treatment')
+#         control_count = sum(1 for r in results if r and r.key == 'control')
+#
+#         # With 10% treatment / 90% control, expect roughly 100 treatment / 900 control
+#         # Allow for statistical variance
+#         assert 50 < treatment_count < 200, f'Expected ~100 treatment, got {treatment_count}'
+#         assert 800 < control_count < 950, f'Expected ~900 control, got {control_count}'
+#
+#     def test_resolve_uses_base_rollout_when_schedule_inactive(self):
+#         """When schedule is inactive, use base rollout."""
+#         config = VariableConfig(
+#             name='test_var',
+#             variants={
+#                 'control': Variant(key='control', serialized_value='"control"'),
+#                 'treatment': Variant(key='treatment', serialized_value='"treatment"'),
+#             },
+#             rollout=Rollout(variants={'control': 1.0}),  # Base: 100% control
+#             overrides=[],
+#             schedule=RolloutSchedule(
+#                 start_at=None,  # Inactive schedule
+#                 stages=[
+#                     RolloutStage(
+#                         duration=timedelta(hours=1),
+#                         rollout=Rollout(variants={'treatment': 1.0}),  # Would be 100% treatment if active
+#                         overrides=[],
+#                     ),
+#                 ],
+#             ),
+#         )
+#         # All results should be control since schedule is inactive
+#         for i in range(10):
+#             variant = config.resolve_variant(targeting_key=f'user{i}')
+#             assert variant is not None
+#             assert variant.key == 'control'
+#
+#     def test_resolve_uses_base_rollout_when_schedule_not_started(self):
+#         """When schedule hasn't started yet, use base rollout."""
+#         future_time = datetime.now(timezone.utc) + timedelta(hours=1)
+#         config = VariableConfig(
+#             name='test_var',
+#             variants={
+#                 'control': Variant(key='control', serialized_value='"control"'),
+#                 'treatment': Variant(key='treatment', serialized_value='"treatment"'),
+#             },
+#             rollout=Rollout(variants={'control': 1.0}),
+#             overrides=[],
+#             schedule=RolloutSchedule(
+#                 start_at=future_time,  # Schedule starts in 1 hour
+#                 stages=[
+#                     RolloutStage(
+#                         duration=timedelta(hours=1),
+#                         rollout=Rollout(variants={'treatment': 1.0}),
+#                         overrides=[],
+#                     ),
+#                 ],
+#             ),
+#         )
+#         for i in range(10):
+#             variant = config.resolve_variant(targeting_key=f'user{i}')
+#             assert variant is not None
+#             assert variant.key == 'control'
+#
+#     def test_resolve_uses_base_rollout_when_schedule_completed(self):
+#         """When all schedule stages have elapsed, use base rollout."""
+#         now = datetime.now(timezone.utc)
+#         config = VariableConfig(
+#             name='test_var',
+#             variants={
+#                 'control': Variant(key='control', serialized_value='"control"'),
+#                 'treatment': Variant(key='treatment', serialized_value='"treatment"'),
+#             },
+#             rollout=Rollout(variants={'control': 1.0}),  # Base: 100% control
+#             overrides=[],
+#             schedule=RolloutSchedule(
+#                 start_at=now - timedelta(hours=5),  # Started 5 hours ago
+#                 stages=[
+#                     RolloutStage(
+#                         duration=timedelta(hours=1),  # Ended 4 hours ago
+#                         rollout=Rollout(variants={'treatment': 1.0}),
+#                         overrides=[],
+#                     ),
+#                 ],
+#             ),
+#         )
+#         # Schedule completed, should use base rollout
+#         for i in range(10):
+#             variant = config.resolve_variant(targeting_key=f'user{i}')
+#             assert variant is not None
+#             assert variant.key == 'control'
+#
+#     def test_resolve_uses_stage_overrides_when_schedule_active(self):
+#         """When schedule is active, use the stage's overrides, not base overrides."""
+#         now = datetime.now(timezone.utc)
+#         config = VariableConfig(
+#             name='test_var',
+#             variants={
+#                 'control': Variant(key='control', serialized_value='"control"'),
+#                 'treatment': Variant(key='treatment', serialized_value='"treatment"'),
+#                 'vip': Variant(key='vip', serialized_value='"vip"'),
+#             },
+#             rollout=Rollout(variants={'control': 1.0}),
+#             # Base overrides: enterprise gets treatment
+#             overrides=[
+#                 RolloutOverride(
+#                     conditions=[ValueEquals(attribute='plan', value='enterprise')],
+#                     rollout=Rollout(variants={'treatment': 1.0}),
+#                 ),
+#             ],
+#             schedule=RolloutSchedule(
+#                 start_at=now - timedelta(minutes=30),  # Active schedule
+#                 stages=[
+#                     RolloutStage(
+#                         duration=timedelta(hours=1),
+#                         rollout=Rollout(variants={'control': 1.0}),
+#                         # Stage overrides: enterprise gets VIP instead
+#                         overrides=[
+#                             RolloutOverride(
+#                                 conditions=[ValueEquals(attribute='plan', value='enterprise')],
+#                                 rollout=Rollout(variants={'vip': 1.0}),
+#                             ),
+#                         ],
+#                     ),
+#                 ],
+#             ),
+#         )
+#         # Enterprise users should get VIP (from stage override), not treatment (from base override)
+#         variant = config.resolve_variant(targeting_key='user1', attributes={'plan': 'enterprise'})
+#         assert variant is not None
+#         assert variant.key == 'vip'
+#
+#         # Non-enterprise users get control (from stage rollout)
+#         variant = config.resolve_variant(targeting_key='user2', attributes={'plan': 'free'})
+#         assert variant is not None
+#         assert variant.key == 'control'
+#
+#     def test_no_schedule_uses_base_config(self):
+#         """When no schedule is configured, use base rollout and overrides."""
+#         config = VariableConfig(
+#             name='test_var',
+#             variants={
+#                 'default': Variant(key='default', serialized_value='"default"'),
+#                 'premium': Variant(key='premium', serialized_value='"premium"'),
+#             },
+#             rollout=Rollout(variants={'default': 1.0}),
+#             overrides=[
+#                 RolloutOverride(
+#                     conditions=[ValueEquals(attribute='plan', value='enterprise')],
+#                     rollout=Rollout(variants={'premium': 1.0}),
+#                 ),
+#             ],
+#             schedule=None,
+#         )
+#         # Without enterprise plan, get default
+#         variant = config.resolve_variant(targeting_key='user1')
+#         assert variant is not None
+#         assert variant.key == 'default'
+#
+#         # With enterprise plan, get premium
+#         variant = config.resolve_variant(targeting_key='user1', attributes={'plan': 'enterprise'})
+#         assert variant is not None
+#         assert variant.key == 'premium'
+
+
+# =============================================================================
+# Test VariablesConfig
+# =============================================================================
+
+
+class TestVariablesConfig:
+    def test_basic_config(self):
+        config = VariablesConfig(
+            variables={
+                'my_var': VariableConfig(
+                    name='my_var',
+                    variants={'v1': Variant(key='v1', serialized_value='"value"')},
+                    rollout=Rollout(variants={'v1': 1.0}),
+                    overrides=[],
+                ),
+            }
+        )
+        assert 'my_var' in config.variables
+
+    def test_validation_invalid_variable_key(self):
+        from pydantic import TypeAdapter
+
+        adapter = TypeAdapter(VariablesConfig)
+        with pytest.raises(ValidationError, match='invalid lookup key'):
+            adapter.validate_python(
+                {
+                    'variables': {
+                        'wrong_key': {
+                            'name': 'correct_name',
+                            'variants': {'v1': {'key': 'v1', 'serialized_value': '"value"'}},
+                            'rollout': {'variants': {'v1': 1.0}},
+                            'overrides': [],
+                        }
+                    }
+                }
+            )
+
+    def test_validate_python(self):
+        config = VariablesConfig.validate_python(
+            {
+                'variables': {
+                    'my_var': {
+                        'name': 'my_var',
+                        'variants': {'v1': {'key': 'v1', 'serialized_value': '"value"'}},
+                        'rollout': {'variants': {'v1': 1.0}},
+                        'overrides': [],
+                    }
+                }
+            }
+        )
+        assert isinstance(config, VariablesConfig)
+        assert 'my_var' in config.variables
+
+    def test_get_validation_errors_no_errors(self, config_kwargs: dict[str, Any]):
+        """Test that get_validation_errors returns empty dict when all variants are valid."""
+        lf = logfire.configure(**config_kwargs)
+        config = VariablesConfig(
+            variables={
+                'valid_var': VariableConfig(
+                    name='valid_var',
+                    variants={'v1': Variant(key='v1', serialized_value='"valid_string"')},
+                    rollout=Rollout(variants={'v1': 1.0}),
+                    overrides=[],
+                ),
+            }
+        )
+        var = lf.var(name='valid_var', default='default', type=str)
+        errors = config.get_validation_errors([var])
+        assert errors == {}
+
+    def test_get_validation_errors_missing_config(self, config_kwargs: dict[str, Any]):
+        """Test that get_validation_errors reports missing variable configs."""
+        lf = logfire.configure(**config_kwargs)
+        config = VariablesConfig(variables={})
+        var = lf.var(name='missing_var', default='default', type=str)
+        errors = config.get_validation_errors([var])
+        assert 'missing_var' in errors
+        assert None in errors['missing_var']
+        assert 'No config for variable' in str(errors['missing_var'][None])
+
+    def test_get_validation_errors_invalid_type(self, config_kwargs: dict[str, Any]):
+        """Test that get_validation_errors reports type validation errors."""
+        lf = logfire.configure(**config_kwargs)
+        config = VariablesConfig(
+            variables={
+                'my_var': VariableConfig(
+                    name='my_var',
+                    variants={'v1': Variant(key='v1', serialized_value='"not_an_int"')},
+                    rollout=Rollout(variants={'v1': 1.0}),
+                    overrides=[],
+                ),
+            }
+        )
+        var = lf.var(name='my_var', default=0, type=int)
+        errors = config.get_validation_errors([var])
+        assert 'my_var' in errors
+        assert 'v1' in errors['my_var']
+
+
+# =============================================================================
+# Test NoOpVariableProvider
+# =============================================================================
+
+
+class TestNoOpVariableProvider:
+    def test_returns_none(self):
+        provider = NoOpVariableProvider()
+        result = provider.get_serialized_value('any_variable')
+        assert result.value is None
+        assert result._reason == 'no_provider'
+
+    def test_with_targeting_key_and_attributes(self):
+        provider = NoOpVariableProvider()
+        result = provider.get_serialized_value(
+            'any_variable',
+            targeting_key='user123',
+            attributes={'plan': 'enterprise'},
+        )
+        assert result.value is None
+
+    def test_refresh_does_nothing(self):
+        provider = NoOpVariableProvider()
+        provider.refresh()  # Should not raise
+        provider.refresh(force=True)  # Should not raise
+
+    def test_shutdown_does_nothing(self):
+        provider = NoOpVariableProvider()
+        provider.shutdown()  # Should not raise
+
+
+# =============================================================================
+# Test VariableResolutionDetails
+# =============================================================================
+
+
+class TestVariableResolutionDetails:
+    def test_basic_details(self):
+        details = VariableResolutionDetails(value='test', _reason='resolved')
+        assert details.value == 'test'
+        assert details.variant is None
+        assert details.exception is None
+
+    def test_with_variant(self):
+        details = VariableResolutionDetails(value='test', variant='v1', _reason='resolved')
+        assert details.variant == 'v1'
+
+    def test_with_exception(self):
+        error = ValueError('test error')
+        details = VariableResolutionDetails(value='default', exception=error, _reason='validation_error')
+        assert details.exception is error
+
+
+# =============================================================================
+# Test LocalVariableProvider
+# =============================================================================
+
+
+class TestLocalVariableProvider:
+    @pytest.fixture
+    def simple_config(self) -> VariablesConfig:
+        return VariablesConfig(
+            variables={
+                'test_var': VariableConfig(
+                    name='test_var',
+                    variants={
+                        'default': Variant(key='default', serialized_value='"default_value"'),
+                        'premium': Variant(key='premium', serialized_value='"premium_value"'),
+                    },
+                    rollout=Rollout(variants={'default': 1.0}),
+                    overrides=[
+                        RolloutOverride(
+                            conditions=[ValueEquals(attribute='plan', value='enterprise')],
+                            rollout=Rollout(variants={'premium': 1.0}),
+                        ),
+                    ],
+                ),
+            }
+        )
+
+    def test_get_serialized_value_basic(self, simple_config: VariablesConfig):
+        provider = LocalVariableProvider(simple_config)
+        result = provider.get_serialized_value('test_var')
+        assert result.value == '"default_value"'
+        assert result.variant == 'default'
+        assert result._reason == 'resolved'
+
+    def test_get_serialized_value_with_override(self, simple_config: VariablesConfig):
+        provider = LocalVariableProvider(simple_config)
+        result = provider.get_serialized_value(
+            'test_var',
+            attributes={'plan': 'enterprise'},
+        )
+        assert result.value == '"premium_value"'
+        assert result.variant == 'premium'
+
+    def test_get_serialized_value_unrecognized(self, simple_config: VariablesConfig):
+        provider = LocalVariableProvider(simple_config)
+        result = provider.get_serialized_value('unknown_var')
+        assert result.value is None
+        assert result._reason == 'unrecognized_variable'
+
+    def test_with_callable_config(self, simple_config: VariablesConfig):
+        provider = LocalVariableProvider(lambda: simple_config)
+        result = provider.get_serialized_value('test_var')
+        assert result.value == '"default_value"'
+
+    def test_rollout_returns_none(self):
+        config = VariablesConfig(
+            variables={
+                'partial_var': VariableConfig(
+                    name='partial_var',
+                    variants={'v1': Variant(key='v1', serialized_value='"value"')},
+                    rollout=Rollout(variants={'v1': 0.0}),  # 0% chance
+                    overrides=[],
+                ),
+            }
+        )
+        provider = LocalVariableProvider(config)
+        result = provider.get_serialized_value('partial_var')
+        assert result.value is None
+        assert result._reason == 'resolved'
+
+
+# =============================================================================
+# Test LogfireRemoteVariableProvider (using requests-mock)
+# =============================================================================
+
+
+REMOTE_BASE_URL = 'http://localhost:8000/'
+REMOTE_TOKEN = 'pylf_v1_local_test_token'
+
+
+@pytest.mark.filterwarnings('ignore::pytest.PytestUnhandledThreadExceptionWarning')
+class TestLogfireRemoteVariableProvider:
+    def test_get_serialized_value_basic(self) -> None:
+        request_mocker = requests_mock_module.Mocker()
+        request_mocker.get(
+            'http://localhost:8000/v1/variables/',
+            json={
+                'variables': {
+                    'test_var': {
+                        'name': 'test_var',
+                        'variants': {
+                            'default': {
+                                'key': 'default',
+                                'serialized_value': '"remote_value"',
+                                'description': None,
+                                'version': None,
+                            }
+                        },
+                        'rollout': {'variants': {'default': 1.0}},
+                        'overrides': [],
+                        'json_schema': {'type': 'string'},
+                    }
+                }
+            },
+        )
+        with request_mocker:
+            provider = LogfireRemoteVariableProvider(
+                base_url=REMOTE_BASE_URL,
+                token=REMOTE_TOKEN,
+                config=RemoteVariablesConfig(
+                    block_before_first_resolve=True,
+                    polling_interval=timedelta(seconds=60),
+                ),
+            )
+            try:
+                result = provider.get_serialized_value('test_var')
+                assert result.value == '"remote_value"'
+                assert result.variant == 'default'
+            finally:
+                provider.shutdown()
+
+    def test_get_serialized_value_missing_config_no_block(self) -> None:
+        request_mocker = requests_mock_module.Mocker()
+        request_mocker.get(
+            'http://localhost:8000/v1/variables/',
+            json={'variables': {}},
+        )
+        with request_mocker:
+            provider = LogfireRemoteVariableProvider(
+                base_url=REMOTE_BASE_URL,
+                token=REMOTE_TOKEN,
+                config=RemoteVariablesConfig(
+                    block_before_first_resolve=False,
+                    polling_interval=timedelta(seconds=60),
+                ),
+            )
+            try:
+                # Without blocking, config might not be fetched yet
+                result = provider.get_serialized_value('test_var')
+                # Should return missing_config if not fetched
+                assert result._reason in ('missing_config', 'resolved', 'unrecognized_variable')
+            finally:
+                provider.shutdown()
+
+    def test_unrecognized_variable(self) -> None:
+        request_mocker = requests_mock_module.Mocker()
+        request_mocker.get(
+            'http://localhost:8000/v1/variables/',
+            json={
+                'variables': {
+                    'other_var': {
+                        'name': 'other_var',
+                        'variants': {
+                            'default': {
+                                'key': 'default',
+                                'serialized_value': '"value"',
+                            }
+                        },
+                        'rollout': {'variants': {'default': 1.0}},
+                        'overrides': [],
+                    }
+                }
+            },
+        )
+        with request_mocker:
+            provider = LogfireRemoteVariableProvider(
+                base_url=REMOTE_BASE_URL,
+                token=REMOTE_TOKEN,
+                config=RemoteVariablesConfig(
+                    block_before_first_resolve=True,
+                    polling_interval=timedelta(seconds=60),
+                ),
+            )
+            try:
+                result = provider.get_serialized_value('nonexistent_var')
+                assert result.value is None
+                assert result._reason == 'unrecognized_variable'
+            finally:
+                provider.shutdown()
+
+    def test_shutdown_idempotent(self) -> None:
+        request_mocker = requests_mock_module.Mocker()
+        request_mocker.get(
+            'http://localhost:8000/v1/variables/',
+            json={'variables': {}},
+        )
+        with request_mocker:
+            provider = LogfireRemoteVariableProvider(
+                base_url=REMOTE_BASE_URL,
+                token=REMOTE_TOKEN,
+                config=RemoteVariablesConfig(
+                    block_before_first_resolve=False,
+                    polling_interval=timedelta(seconds=60),
+                ),
+            )
+            provider.shutdown()
+            provider.shutdown()  # Should not raise
+
+    def test_refresh_with_force(self) -> None:
+        request_mocker = requests_mock_module.Mocker()
+        request_mocker.get(
+            'http://localhost:8000/v1/variables/',
+            json={'variables': {}},
+        )
+        with request_mocker:
+            provider = LogfireRemoteVariableProvider(
+                base_url=REMOTE_BASE_URL,
+                token=REMOTE_TOKEN,
+                config=RemoteVariablesConfig(
+                    block_before_first_resolve=False,
+                    polling_interval=timedelta(seconds=60),
+                ),
+            )
+            try:
+                provider.refresh(force=True)
+                result = provider.get_serialized_value('test_var')
+                assert result._reason == 'unrecognized_variable'
+            finally:
+                provider.shutdown()
+
+    def test_rollout_returns_none_variant(self) -> None:
+        """Test case where rollout returns None (no variant selected)."""
+        request_mocker = requests_mock_module.Mocker()
+        request_mocker.get(
+            'http://localhost:8000/v1/variables/',
+            json={
+                'variables': {
+                    'partial_var': {
+                        'name': 'partial_var',
+                        'variants': {
+                            'v1': {
+                                'key': 'v1',
+                                'serialized_value': '"value"',
+                            }
+                        },
+                        # 0% rollout means no variant is ever selected
+                        'rollout': {'variants': {'v1': 0.0}},
+                        'overrides': [],
+                    }
+                }
+            },
+        )
+        with request_mocker:
+            provider = LogfireRemoteVariableProvider(
+                base_url=REMOTE_BASE_URL,
+                token=REMOTE_TOKEN,
+                config=RemoteVariablesConfig(
+                    block_before_first_resolve=True,
+                    polling_interval=timedelta(seconds=60),
+                ),
+            )
+            try:
+                result = provider.get_serialized_value('partial_var')
+                assert result.value is None
+                assert result._reason == 'resolved'
+            finally:
+                provider.shutdown()
+
+
+@pytest.mark.filterwarnings('ignore::pytest.PytestUnhandledThreadExceptionWarning')
+class TestLogfireRemoteVariableProviderErrors:
+    def test_handles_unexpected_response(self) -> None:
+        request_mocker = requests_mock_module.Mocker()
+        request_mocker.get(
+            'http://localhost:8000/v1/variables/',
+            status_code=500,
+            json={'error': 'Internal Server Error'},
+        )
+        with warnings.catch_warnings(), request_mocker:
+            warnings.simplefilter('ignore', RuntimeWarning)
+            provider = LogfireRemoteVariableProvider(
+                base_url=REMOTE_BASE_URL,
+                token=REMOTE_TOKEN,
+                config=RemoteVariablesConfig(
+                    block_before_first_resolve=True,
+                    polling_interval=timedelta(seconds=60),
+                ),
+            )
+            try:
+                # The mock returns an error, so config should not be set
+                result = provider.get_serialized_value('test_var')
+                assert result._reason == 'missing_config'
+            finally:
+                provider.shutdown()
+
+    def test_handles_validation_error(self) -> None:
+        request_mocker = requests_mock_module.Mocker()
+        request_mocker.get(
+            'http://localhost:8000/v1/variables/',
+            json={'invalid_field': 'this is not valid VariablesConfig data'},
+        )
+        with warnings.catch_warnings(), request_mocker:
+            warnings.simplefilter('ignore', RuntimeWarning)
+            provider = LogfireRemoteVariableProvider(
+                base_url=REMOTE_BASE_URL,
+                token=REMOTE_TOKEN,
+                config=RemoteVariablesConfig(
+                    block_before_first_resolve=True,
+                    polling_interval=timedelta(seconds=60),
+                ),
+            )
+            try:
+                # The mock returns invalid data, so validation error happens
+                result = provider.get_serialized_value('test_var')
+                assert result._reason == 'missing_config'
+            finally:
+                provider.shutdown()
+
+
+# =============================================================================
+# Test Variable
+# =============================================================================
+
+
+class TestVariable:
+    @pytest.fixture
+    def variables_config(self) -> VariablesConfig:
+        return VariablesConfig(
+            variables={
+                'string_var': VariableConfig(
+                    name='string_var',
+                    variants={
+                        'default': Variant(key='default', serialized_value='"hello"'),
+                        'alt': Variant(key='alt', serialized_value='"world"'),
+                    },
+                    rollout=Rollout(variants={'default': 1.0}),
+                    overrides=[
+                        RolloutOverride(
+                            conditions=[ValueEquals(attribute='use_alt', value=True)],
+                            rollout=Rollout(variants={'alt': 1.0}),
+                        ),
+                    ],
+                ),
+                'int_var': VariableConfig(
+                    name='int_var',
+                    variants={'default': Variant(key='default', serialized_value='42')},
+                    rollout=Rollout(variants={'default': 1.0}),
+                    overrides=[],
+                ),
+                'model_var': VariableConfig(
+                    name='model_var',
+                    variants={
+                        'default': Variant(
+                            key='default',
+                            serialized_value='{"name": "test", "value": 123}',
+                        )
+                    },
+                    rollout=Rollout(variants={'default': 1.0}),
+                    overrides=[],
+                ),
+                'invalid_var': VariableConfig(
+                    name='invalid_var',
+                    variants={'default': Variant(key='default', serialized_value='"not_an_int"')},
+                    rollout=Rollout(variants={'default': 1.0}),
+                    overrides=[],
+                ),
+            }
+        )
+
+    def test_get_string_variable(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='string_var', default='default_value', type=str)
+        value = var.get()
+        assert value == 'hello'
+
+    def test_get_int_variable(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='int_var', default=0, type=int)
+        value = var.get()
+        assert value == 42
+
+    def test_get_model_variable(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        class MyModel(BaseModel):
+            name: str
+            value: int
+
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='model_var', default=MyModel(name='default', value=0), type=MyModel)
+        value = var.get()
+        assert value.name == 'test'
+        assert value.value == 123
+
+    def test_get_with_attributes(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='string_var', default='default_value', type=str)
+
+        # Without override condition
+        assert var.get() == 'hello'
+
+        # With override condition
+        assert var.get(attributes={'use_alt': True}) == 'world'
+
+    def test_get_details(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='string_var', default='default_value', type=str)
+        details = var.get_details()
+        assert details.value == 'hello'
+        assert details.variant == 'default'
+        assert details.exception is None
+
+    def test_get_details_with_validation_error(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='invalid_var', default=999, type=int)
+        details = var.get_details()
+        # Falls back to default when validation fails
+        assert details.value == 999
+        assert details.exception is not None
+        assert details._reason == 'validation_error'
+
+    def test_get_uses_default_when_no_config(self, config_kwargs: dict[str, Any]):
+        config_kwargs['variables'] = VariablesOptions(config=VariablesConfig(variables={}))
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='unconfigured', default='my_default', type=str)
+        value = var.get()
+        assert value == 'my_default'
+
+    def test_override_context_manager(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='string_var', default='default_value', type=str)
+
+        assert var.get() == 'hello'
+
+        with var.override('overridden'):
+            assert var.get() == 'overridden'
+
+        assert var.get() == 'hello'
+
+    def test_override_nested(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='string_var', default='default_value', type=str)
+
+        with var.override('outer'):
+            assert var.get() == 'outer'
+            with var.override('inner'):
+                assert var.get() == 'inner'
+            assert var.get() == 'outer'
+
+    def test_override_with_function(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='string_var', default='default_value', type=str)
+
+        def resolve_fn(targeting_key: str | None, attributes: Mapping[str, Any] | None) -> str:
+            if attributes and attributes.get('mode') == 'creative':
+                return 'creative_value'
+            return 'default_fn_value'
+
+        with var.override(resolve_fn):
+            assert var.get() == 'default_fn_value'
+            assert var.get(attributes={'mode': 'creative'}) == 'creative_value'
+
+    def test_default_as_function(self, config_kwargs: dict[str, Any]):
+        config_kwargs['variables'] = VariablesOptions(config=VariablesConfig(variables={}))
+        lf = logfire.configure(**config_kwargs)
+
+        def resolve_default(targeting_key: str | None, attributes: Mapping[str, Any] | None) -> str:
+            if targeting_key:
+                return f'default_for_{targeting_key}'
+            return 'generic_default'
+
+        var = lf.var(name='with_fn_default', default=resolve_default, type=str)
+        assert var.get() == 'generic_default'
+        assert var.get(targeting_key='user123') == 'default_for_user123'
+
+    def test_refresh_sync(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='string_var', default='default_value', type=str)
+        var.refresh_sync()  # Should not raise
+
+    @pytest.mark.anyio
+    async def test_refresh_async(self, config_kwargs: dict[str, Any], variables_config: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(config=variables_config)
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='string_var', default='default_value', type=str)
+        await var.refresh()  # Should not raise
+
+
+# =============================================================================
+# Test Variable with Baggage and Resource Attributes
+# =============================================================================
+
+
+class TestVariableContextEnrichment:
+    @pytest.fixture
+    def config_with_targeting(self) -> VariablesConfig:
+        return VariablesConfig(
+            variables={
+                'targeted_var': VariableConfig(
+                    name='targeted_var',
+                    variants={
+                        'default': Variant(key='default', serialized_value='"default"'),
+                        'premium': Variant(key='premium', serialized_value='"premium"'),
+                    },
+                    rollout=Rollout(variants={'default': 1.0}),
+                    overrides=[
+                        RolloutOverride(
+                            conditions=[ValueEquals(attribute='plan', value='enterprise')],
+                            rollout=Rollout(variants={'premium': 1.0}),
+                        ),
+                    ],
+                ),
+            }
+        )
+
+    def test_baggage_included_in_resolution(
+        self, config_kwargs: dict[str, Any], config_with_targeting: VariablesConfig
+    ):
+        config_kwargs['variables'] = VariablesOptions(
+            config=config_with_targeting,
+            include_baggage_in_context=True,
+        )
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='targeted_var', default='fallback', type=str)
+
+        # Without baggage
+        assert var.get() == 'default'
+
+        # With baggage
+        with logfire.set_baggage(plan='enterprise'):
+            assert var.get() == 'premium'
+
+    def test_baggage_can_be_disabled(self, config_kwargs: dict[str, Any], config_with_targeting: VariablesConfig):
+        config_kwargs['variables'] = VariablesOptions(
+            config=config_with_targeting,
+            include_baggage_in_context=False,
+        )
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='targeted_var', default='fallback', type=str)
+
+        # With baggage but disabled
+        with logfire.set_baggage(plan='enterprise'):
+            # Should NOT match override since baggage is disabled
+            assert var.get() == 'default'
+
+    def test_resource_attributes_can_be_disabled(
+        self, config_kwargs: dict[str, Any], config_with_targeting: VariablesConfig
+    ):
+        config_kwargs['variables'] = VariablesOptions(
+            config=config_with_targeting,
+            include_resource_attributes_in_context=False,
+        )
+        lf = logfire.configure(**config_kwargs)
+
+        var = lf.var(name='targeted_var', default='fallback', type=str)
+        # Just verify it works with this setting
+        assert var.get() == 'default'
+
+
+# =============================================================================
+# Test is_resolve_function
+# =============================================================================
+
+
+class TestIsResolveFunction:
+    def test_valid_resolve_function(self):
+        def valid_fn(targeting_key: str | None, attributes: Mapping[str, Any] | None) -> str:
+            return 'value'
+
+        assert is_resolve_function(valid_fn) is True
+
+    def test_invalid_param_names(self):
+        def invalid_fn(key: str | None, attrs: Mapping[str, Any] | None) -> str:
+            return 'value'
+
+        assert is_resolve_function(invalid_fn) is False
+
+    def test_wrong_param_count(self):
+        def wrong_count(targeting_key: str | None) -> str:
+            return 'value'
+
+        assert is_resolve_function(wrong_count) is False
+
+    def test_not_callable(self):
+        assert is_resolve_function('not a function') is False
+        assert is_resolve_function(42) is False
+
+
+# =============================================================================
+# Test __init__.py lazy imports
+# =============================================================================
+
+
+class TestLazyImports:
+    def test_all_exports_accessible(self):
+        from logfire import variables
+
+        # All items in __all__ should be accessible
+        for name in variables.__all__:
+            assert hasattr(variables, name)
+            getattr(variables, name)  # Should not raise
+
+    def test_attribute_error_for_unknown(self):
+        from logfire import variables
+
+        with pytest.raises(AttributeError, match="has no attribute 'NonExistent'"):
+            variables.NonExistent
+
+
+# =============================================================================
+# Test Integration with logfire.var()
+# =============================================================================
+
+
+class TestLogfireVarIntegration:
+    def test_var_with_sequence_type(self, config_kwargs: dict[str, Any]):
+        config_kwargs['variables'] = VariablesOptions(
+            config=VariablesConfig(
+                variables={
+                    'union_var': VariableConfig(
+                        name='union_var',
+                        variants={'v1': Variant(key='v1', serialized_value='"string_value"')},
+                        rollout=Rollout(variants={'v1': 1.0}),
+                        overrides=[],
+                    ),
+                }
+            )
+        )
+        lf = logfire.configure(**config_kwargs)
+
+        # Using sequence of types creates a Union
+        var = lf.var(name='union_var', default='default', type=[str, int])
+        assert var.get() == 'string_value'
+
+    def test_exception_handling_in_get_details(self, config_kwargs: dict[str, Any]):
+        # Create a provider that raises an exception
+        class FailingProvider(VariableProvider):
+            def get_serialized_value(
+                self,
+                variable_name: str,
+                targeting_key: str | None = None,
+                attributes: Mapping[str, Any] | None = None,
+            ) -> VariableResolutionDetails[str | None]:
+                raise RuntimeError('Provider failed!')
+
+        lf = logfire.configure(variables=VariablesOptions(config=FailingProvider()))
+
+        var = lf.var(name='failing_var', default='fallback', type=str)
+        details = var.get_details()
+        assert details.value == 'fallback'
+        assert details._reason == 'other_error'
+        assert isinstance(details.exception, RuntimeError)
diff --git a/tests/type_checking.py b/tests/type_checking.py
new file mode 100644
index 000000000..64011feba
--- /dev/null
+++ b/tests/type_checking.py
@@ -0,0 +1,17 @@
+from typing import assert_type
+
+import logfire
+from logfire.variables import Variable
+
+# using a list of types produces their union:
+my_variable_1 = logfire.Logfire().var(name='my-variable-1', default='a', type=[int, str])
+assert_type(my_variable_1, Variable[int | str])
+
+# Documenting the current behavior: including a default of an incompatible type extends the union rather than producing
+# a type error. This is arguably a feature, not a bug — the `type` is only used for validating provider values, not the
+# code default, so this behavior makes it more ergonomic to do things like sentinel patterns if you want to easily
+# detect whether you got a variable-provider-provided value.
+# Anyway, the _main_ reason it works this way is not because we prefer it, but because we can't see a way to make it a
+# type error, so the above argument is just a way of turning lemons into lemonade.
+my_variable_2 = logfire.Logfire().var(name='my-variable-2', default=None, type=[int, str])
+assert_type(my_variable_2, Variable[int | str | None])
diff --git a/uv.lock b/uv.lock
index afec30128..a23fd8474 100644
--- a/uv.lock
+++ b/uv.lock
@@ -612,7 +612,7 @@ name = "cffi"
 version = "2.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+    { name = "pycparser", marker = "(python_full_version >= '3.10' and implementation_name != 'PyPy') or (implementation_name != 'PyPy' and platform_python_implementation != 'PyPy')" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
 wheels = [
@@ -2940,6 +2940,9 @@ starlette = [
 system-metrics = [
     { name = "opentelemetry-instrumentation-system-metrics" },
 ]
+variables = [
+    { name = "pydantic" },
+]
 wsgi = [
     { name = "opentelemetry-instrumentation-wsgi" },
 ]
@@ -3095,11 +3098,12 @@ requires-dist = [
     { name = "packaging", marker = "extra == 'psycopg'" },
     { name = "packaging", marker = "extra == 'psycopg2'" },
     { name = "protobuf", specifier = ">=4.23.4" },
+    { name = "pydantic", marker = "extra == 'variables'", specifier = ">=2.0.0" },
     { name = "rich", specifier = ">=13.4.2" },
     { name = "tomli", marker = "python_full_version < '3.11'", specifier = ">=2.0.1" },
     { name = "typing-extensions", specifier = ">=4.1.0" },
 ]
-provides-extras = ["system-metrics", "asgi", "wsgi", "aiohttp", "aiohttp-client", "aiohttp-server", "celery", "django", "fastapi", "flask", "httpx", "starlette", "sqlalchemy", "asyncpg", "psycopg", "psycopg2", "pymongo", "redis", "requests", "mysql", "sqlite3", "aws-lambda", "google-genai", "litellm"]
+provides-extras = ["system-metrics", "asgi", "wsgi", "aiohttp", "aiohttp-client", "aiohttp-server", "celery", "django", "fastapi", "flask", "httpx", "starlette", "sqlalchemy", "asyncpg", "psycopg", "psycopg2", "pymongo", "redis", "requests", "mysql", "sqlite3", "aws-lambda", "google-genai", "litellm", "variables"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -3164,7 +3168,7 @@ dev = [
     { name = "psycopg2-binary", specifier = ">=2.9.10" },
     { name = "pyarrow", marker = "python_full_version < '3.13'", specifier = ">=17.0.0" },
     { name = "pyarrow", marker = "python_full_version >= '3.13'", specifier = ">=18.1.0" },
-    { name = "pydantic", git = "https://github.com/pydantic/pydantic" },
+    { name = "pydantic", specifier = ">=2.12.5" },
     { name = "pydantic-ai-slim", specifier = ">=0.0.39" },
     { name = "pymongo", specifier = ">=4.10.1" },
     { name = "pymysql", specifier = ">=1.1.1" },
@@ -5703,14 +5707,18 @@ wheels = [
 
 [[package]]
 name = "pydantic"
-version = "2.13.0a0+dev"
-source = { git = "https://github.com/pydantic/pydantic#0329e09161d2c5e3a0b8eb1e795a7a41f177e184" }
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-types" },
     { name = "pydantic-core" },
     { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
 
 [[package]]
 name = "pydantic-ai-slim"
@@ -5764,10 +5772,133 @@ wheels = [
 [[package]]
 name = "pydantic-core"
 version = "2.41.5"
-source = { git = "https://github.com/pydantic/pydantic?subdirectory=pydantic-core#0329e09161d2c5e3a0b8eb1e795a7a41f177e184" }
+source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298, upload-time = "2025-11-04T13:39:04.116Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475, upload-time = "2025-11-04T13:39:06.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815, upload-time = "2025-11-04T13:39:10.41Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567, upload-time = "2025-11-04T13:39:12.244Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442, upload-time = "2025-11-04T13:39:13.962Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956, upload-time = "2025-11-04T13:39:15.889Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253, upload-time = "2025-11-04T13:39:17.403Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050, upload-time = "2025-11-04T13:39:19.351Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178, upload-time = "2025-11-04T13:39:21Z" },
+    { url = "https://files.pythonhosted.org/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833, upload-time = "2025-11-04T13:39:22.606Z" },
+    { url = "https://files.pythonhosted.org/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156, upload-time = "2025-11-04T13:39:25.843Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378, upload-time = "2025-11-04T13:39:27.92Z" },
+    { url = "https://files.pythonhosted.org/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622, upload-time = "2025-11-04T13:39:29.848Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/54/db/160dffb57ed9a3705c4cbcbff0ac03bdae45f1ca7d58ab74645550df3fbd/pydantic_core-2.41.5-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:8bfeaf8735be79f225f3fefab7f941c712aaca36f1128c9d7e2352ee1aa87bdf", size = 2107999, upload-time = "2025-11-04T13:42:03.885Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/7d/88e7de946f60d9263cc84819f32513520b85c0f8322f9b8f6e4afc938383/pydantic_core-2.41.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:346285d28e4c8017da95144c7f3acd42740d637ff41946af5ce6e5e420502dd5", size = 1929745, upload-time = "2025-11-04T13:42:06.075Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/c2/aef51e5b283780e85e99ff19db0f05842d2d4a8a8cd15e63b0280029b08f/pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a75dafbf87d6276ddc5b2bf6fae5254e3d0876b626eb24969a574fff9149ee5d", size = 1920220, upload-time = "2025-11-04T13:42:08.457Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/97/492ab10f9ac8695cd76b2fdb24e9e61f394051df71594e9bcc891c9f586e/pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7b93a4d08587e2b7e7882de461e82b6ed76d9026ce91ca7915e740ecc7855f60", size = 2067296, upload-time = "2025-11-04T13:42:10.817Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/23/984149650e5269c59a2a4c41d234a9570adc68ab29981825cfaf4cfad8f4/pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e8465ab91a4bd96d36dde3263f06caa6a8a6019e4113f24dc753d79a8b3a3f82", size = 2231548, upload-time = "2025-11-04T13:42:13.843Z" },
+    { url = "https://files.pythonhosted.org/packages/71/0c/85bcbb885b9732c28bec67a222dbed5ed2d77baee1f8bba2002e8cd00c5c/pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:299e0a22e7ae2b85c1a57f104538b2656e8ab1873511fd718a1c1c6f149b77b5", size = 2362571, upload-time = "2025-11-04T13:42:16.208Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/4a/412d2048be12c334003e9b823a3fa3d038e46cc2d64dd8aab50b31b65499/pydantic_core-2.41.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:707625ef0983fcfb461acfaf14de2067c5942c6bb0f3b4c99158bed6fedd3cf3", size = 2068175, upload-time = "2025-11-04T13:42:18.911Z" },
+    { url = "https://files.pythonhosted.org/packages/73/f4/c58b6a776b502d0a5540ad02e232514285513572060f0d78f7832ca3c98b/pydantic_core-2.41.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f41eb9797986d6ebac5e8edff36d5cef9de40def462311b3eb3eeded1431e425", size = 2177203, upload-time = "2025-11-04T13:42:22.578Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/ae/f06ea4c7e7a9eead3d165e7623cd2ea0cb788e277e4f935af63fc98fa4e6/pydantic_core-2.41.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0384e2e1021894b1ff5a786dbf94771e2986ebe2869533874d7e43bc79c6f504", size = 2148191, upload-time = "2025-11-04T13:42:24.89Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/57/25a11dcdc656bf5f8b05902c3c2934ac3ea296257cc4a3f79a6319e61856/pydantic_core-2.41.5-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:f0cd744688278965817fd0839c4a4116add48d23890d468bc436f78beb28abf5", size = 2343907, upload-time = "2025-11-04T13:42:27.683Z" },
+    { url = "https://files.pythonhosted.org/packages/96/82/e33d5f4933d7a03327c0c43c65d575e5919d4974ffc026bc917a5f7b9f61/pydantic_core-2.41.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:753e230374206729bf0a807954bcc6c150d3743928a73faffee51ac6557a03c3", size = 2322174, upload-time = "2025-11-04T13:42:30.776Z" },
+    { url = "https://files.pythonhosted.org/packages/81/45/4091be67ce9f469e81656f880f3506f6a5624121ec5eb3eab37d7581897d/pydantic_core-2.41.5-cp39-cp39-win32.whl", hash = "sha256:873e0d5b4fb9b89ef7c2d2a963ea7d02879d9da0da8d9d4933dee8ee86a8b460", size = 1990353, upload-time = "2025-11-04T13:42:33.111Z" },
+    { url = "https://files.pythonhosted.org/packages/44/8a/a98aede18db6e9cd5d66bcacd8a409fcf8134204cdede2e7de35c5a2c5ef/pydantic_core-2.41.5-cp39-cp39-win_amd64.whl", hash = "sha256:e4f4a984405e91527a0d62649ee21138f8e3d0ef103be488c1dc11a80d7f184b", size = 2015698, upload-time = "2025-11-04T13:42:35.484Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351, upload-time = "2025-11-04T13:43:02.058Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363, upload-time = "2025-11-04T13:43:05.159Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615, upload-time = "2025-11-04T13:43:08.116Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369, upload-time = "2025-11-04T13:43:12.49Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218, upload-time = "2025-11-04T13:43:15.431Z" },
+    { url = "https://files.pythonhosted.org/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951, upload-time = "2025-11-04T13:43:18.062Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428, upload-time = "2025-11-04T13:43:20.679Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload-time = "2025-11-04T13:43:23.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
 
 [[package]]
 name = "pydantic-graph"