Simple Moving Average Strategy

from podium_sdk import Agent, Context

class SmaCrossoverAgent(Agent):
    """
    A simple moving average crossover strategy.
    Buys when the 10-day SMA crosses above the 30-day SMA.
    Sells when the 10-day SMA crosses below the 30-day SMA.
    """

    # Define universe of stocks to trade
    universe = [
        "AAPL", "MSFT", "GOOGL", "AMZN", "META",
        "NVDA", "TSLA", "JPM", "V", "WMT"
    ]

    # Risk limits
    risk_limits = {
        "max_position_size": 0.1,    # Max 10% per position
        "max_drawdown": 0.2,          # 20% max drawdown
    }

    # Run daily
    schedule = "daily"

    def initialize(self, context: Context) -> None:
        """Called once at agent startup."""
        context.log.info("Initializing SMA Crossover Agent")
        context.log.info(f"Universe: {', '.join(self.universe)}")

    def analyze(self, context: Context) -> None:
        """Main analysis method called on each tick."""

        # Get historical price data
        prices = context.data.prices(
            symbols=self.universe,
            lookback="40d"  # Get enough data for 30-day SMA
        )

        # Calculate moving averages
        short_window = 10
        long_window = 30

        short_sma = prices["close"].rolling(short_window).mean()
        long_sma = prices["close"].rolling(long_window).mean()

        # Get current positions
        current_positions = context.portfolio.positions()

        # Generate signals for each symbol
        for symbol in self.universe:
            # Skip if we don't have enough data
            if prices["close"][symbol].isna().any():
                continue

            # Current SMAs
            current_short = short_sma[symbol].iloc[-1]
            current_long = long_sma[symbol].iloc[-1]
            previous_short = short_sma[symbol].iloc[-2]
            previous_long = long_sma[symbol].iloc[-2]

            # Check for crossover
            bullish_cross = (
                previous_short <= previous_long and
                current_short > current_long
            )
            bearish_cross = (
                previous_short >= previous_long and
                current_short < current_long
            )

            # Current position
            position = current_positions.get(symbol, 0)

            # Execute trades
            if bullish_cross and position <= 0:
                # Buy signal - allocate equal weight
                weight = 1.0 / len(self.universe)
                context.orders.buy(symbol, weight=weight)
                context.log.info(f"BUY {symbol}: Short SMA ({current_short:.2f}) "
                               f"> Long SMA ({current_long:.2f})")

            elif bearish_cross and position > 0:
                # Sell signal - close position
                context.orders.sell(symbol, weight=1.0)
                context.log.info(f"SELL {symbol}: Short SMA ({current_short:.2f}) "
                               f"< Long SMA ({current_long:.2f})")

            elif position == 0 and not bullish_cross:
                # No position and no signal - ensure we're flat
                context.orders.sell(symbol, weight=1.0)

# Run the agent
if __name__ == "__main__":
    agent = SmaCrossoverAgent()
    agent.run()