Home/Agentic AI/Simulation Environments/Implementation

Simulation Environments

Create simulation environments for safe agent training

Your Progress

0 / 5 completed
1
2
3
4
5

Building Your Simulation

A production simulation needs four components: environment (state management), mock services (external dependencies), scenario generator (test cases), and test runner (orchestration). Here's production-ready code.

Interactive: Code Explorer

Explore each simulation component:

🌍
Environment Base
Core simulation environment with reset and state management
class SimulationEnvironment:
    """Base class for agent simulation environments"""
    
    def __init__(self, config: Dict):
        self.config = config
        self.state = {}
        self.history = []
        self.seed = config.get('seed', 42)
        self.reset()
        
    def reset(self) -> Dict:
        """Reset environment to initial state"""
        random.seed(self.seed)
        self.state = self._initialize_state()
        self.history = []
        self.step_count = 0
        return self.get_observation()
    
    def step(self, action: Action) -> Tuple[Dict, float, bool]:
        """Execute action, return (observation, reward, done)"""
        self.step_count += 1
        
        # Record action for replay
        self.history.append({
            'step': self.step_count,
            'action': action,
            'state_before': copy.deepcopy(self.state)
        })
        
        # Execute action
        self.state = self._apply_action(action, self.state)
        
        # Calculate reward and check if done
        reward = self._calculate_reward()
        done = self._check_done()
        
        return self.get_observation(), reward, done
    
    def get_observation(self) -> Dict:
        """Get current observable state"""
        return {
            'state': self.state,
            'step': self.step_count,
            'metadata': self._get_metadata()
        }

Complete Usage Example

# Setup simulation
config = {'seed': 42, 'max_steps': 100}
env = SimulationEnvironment(config)

# Mock external services
mock_api = MockAPIService({
    'get_customer': {'id': 123, 'tier': 'premium'},
    'send_email': {'status': 'sent'}
})

# Generate test scenarios
generator = ScenarioGenerator(seed=42)
scenarios = generator.generate_customer_service_scenarios(count=1000)
edge_cases = generator.generate_edge_cases()

# Initialize agent
agent = CustomerServiceAgent(api=mock_api)

# Run simulations
runner = SimulationRunner(env, agent)

print("Running 1000 normal scenarios...")
normal_results = runner.run_batch(scenarios, parallel=True)
print(f"Success rate: {normal_results['successful']/normal_results['total_scenarios']:.1%}")
print(f"Avg reward: {normal_results['avg_reward']:.2f}")

print("\nTesting edge cases...")
edge_results = runner.run_batch(edge_cases, parallel=False)
print(f"Edge cases passed: {edge_results['successful']}/{edge_results['total_scenarios']}")

# Analyze failures
failed = [r for r in normal_results['detailed_results'] if not r['success']]
print(f"\nFound {len(failed)} failures to investigate")

# Export for debugging
with open('simulation_results.json', 'w') as f:
    json.dump(normal_results, f, indent=2)
💡
Deployment Workflow

Day 1-2: Build environment base with reset. Test with simple scenarios.
Day 3-4: Add mock services for external APIs. Verify isolation.
Day 5-7: Generate 1000+ diverse scenarios. Run continuously.
Day 8+: Deploy test runner in CI/CD. Block production deploys if simulation fails.

Success metric: Agent survives 10,000 simulated scenarios with 95%+ success rate before production deploy.

← Design Principles