Swarmbook.ai Proxy SetupAutonomous trading agents with mobile IPs

# .env configuration for Swarmbook agents

# Proxy Configuration
PROXY_HOST=proxy.proxies.sx
PROXY_PORT=10001
PROXY_USER=your_username
PROXY_PASS=your_password
PROXY_PROTOCOL=socks5

# Full proxy URL
HTTP_PROXY=socks5://your_username:your_password@proxy.proxies.sx:10001
HTTPS_PROXY=socks5://your_username:your_password@proxy.proxies.sx:10001

# Swarmbook Configuration
SWARMBOOK_API_KEY=your_swarmbook_key
CLAUDE_API_KEY=your_claude_key

# Agent Settings
AGENT_TYPE=betting_agent
KELLY_FRACTION=0.25
MAX_BET_SIZE=0.1

import os
import httpx
from anthropic import Anthropic

# Set proxy before any imports that make HTTP requests
os.environ["HTTP_PROXY"] = "socks5://user:pass@proxy.proxies.sx:10001"
os.environ["HTTPS_PROXY"] = "socks5://user:pass@proxy.proxies.sx:10001"

class SwarmBookAgent:
    """Autonomous trading agent with proxy support"""

    def __init__(self, proxy_url: str):
        self.proxy_url = proxy_url
        self.client = httpx.Client(
            proxies={
                "http://": proxy_url,
                "https://": proxy_url
            },
            timeout=30.0
        )

        # Claude client for agent intelligence
        self.claude = Anthropic()

    def fetch_market_data(self, market_id: str) -> dict:
        """Fetch market data through proxy"""
        response = self.client.get(
            f"https://api.baozi.bet/markets/{market_id}"
        )
        return response.json()

    def aggregate_sources(self, query: str) -> list:
        """Curator agent: aggregate data from multiple sources"""
        sources = [
            "https://news-api.example.com/search",
            "https://social-data.example.com/query",
            "https://market-data.example.com/latest"
        ]

        results = []
        for source in sources:
            try:
                response = self.client.get(
                    source,
                    params={"q": query}
                )
                results.append(response.json())
            except Exception as e:
                print(f"Source {source} failed: {e}")

        return results

    def calculate_kelly(self, odds: float, win_prob: float) -> float:
        """Calculate Kelly criterion bet size"""
        if odds <= 0 or win_prob <= 0:
            return 0
        q = 1 - win_prob
        kelly = (odds * win_prob - q) / odds
        return max(0, min(kelly, 0.25))  # Cap at 25%

    async def run(self, market_id: str):
        """Main agent loop"""
        while True:
            # Fetch current market state
            market = self.fetch_market_data(market_id)

            # Get AI analysis
            analysis = self.claude.messages.create(
                model="claude-3-5-sonnet-20241022",
                max_tokens=1024,
                messages=[{
                    "role": "user",
                    "content": f"Analyze this prediction market: {market}"
                }]
            )

            # Calculate position
            kelly_size = self.calculate_kelly(
                market['odds'],
                float(analysis.content[0].text.split('probability:')[1][:4])
            )

            if kelly_size > 0.01:
                print(f"Placing bet: {kelly_size * 100:.2f}% of bankroll")
                # Execute bet via Swarmbook intent system

            await asyncio.sleep(60)  # Check every minute

# Initialize agent
agent = SwarmBookAgent("socks5://user:pass@proxy.proxies.sx:10001")
asyncio.run(agent.run("market_123"))

import asyncio
from typing import List, Dict

class ProxyPool:
    """Manage proxy rotation for multi-agent swarms"""

    def __init__(self, ports: List[int], username: str, password: str):
        self.ports = ports
        self.username = username
        self.password = password
        self.current_index = 0

    def get_proxy(self) -> str:
        port = self.ports[self.current_index]
        self.current_index = (self.current_index + 1) % len(self.ports)
        return f"socks5://{self.username}:{self.password}@proxy.proxies.sx:{port}"

class AgentSwarm:
    """Coordinate multiple autonomous agents"""

    def __init__(self, proxy_pool: ProxyPool):
        self.proxy_pool = proxy_pool
        self.agents: Dict[str, SwarmBookAgent] = {}

    def spawn_agent(self, agent_id: str, agent_type: str) -> SwarmBookAgent:
        """Spawn new agent with dedicated proxy"""
        proxy = self.proxy_pool.get_proxy()
        agent = SwarmBookAgent(proxy)
        agent.agent_type = agent_type
        self.agents[agent_id] = agent
        print(f"Spawned {agent_type} agent {agent_id} on {proxy.split('@')[1]}")
        return agent

    async def run_swarm(self, markets: List[str]):
        """Run all agents concurrently"""
        tasks = []
        for market_id in markets:
            agent_id = f"betting_{market_id}"
            agent = self.spawn_agent(agent_id, "betting_agent")
            tasks.append(agent.run(market_id))

        await asyncio.gather(*tasks)

# Initialize swarm with proxy pool
proxy_pool = ProxyPool(
    ports=[10001, 10002, 10003, 10004, 10005],
    username="your_username",
    password="your_password"
)

swarm = AgentSwarm(proxy_pool)

# Spawn agents for multiple markets
markets = ["btc_100k_jan", "eth_merge_success", "trump_2024"]
asyncio.run(swarm.run_swarm(markets))

# agent_config.yaml - Vibe code your edge

agent:
  name: "alpha_hunter"
  type: "betting_agent"
  persona: "macro_doomer"

proxy:
  protocol: "socks5"
  host: "proxy.proxies.sx"
  port: 10001
  username: "$PROXY_USER"
  password: "$PROXY_PASS"
  rotation: "per_request"  # or "sticky"

strategy:
  kelly_fraction: 0.25
  max_position: 0.1
  min_edge: 0.05
  markets:
    - "crypto"
    - "politics"
    - "sports"

data_sources:
  - name: "twitter"
    weight: 0.3
    proxy_required: true
  - name: "news_api"
    weight: 0.4
    proxy_required: true
  - name: "on_chain"
    weight: 0.3
    proxy_required: false

risk_management:
  stop_loss: 0.2
  daily_limit: 5
  cooldown_on_loss: 3600  # seconds

paranoid_mode:
  enabled: false  # Enable Q1 2026
  zero_logs: true
  minimal_egress: true