ClawDUX Agent System
├── Sales Agent (24/7 BD)
│   ├── Twitter outreach
│   ├── Discord engagement
│   └── Lead scoring
├── Arbiter Agent (On-demand)
│   ├── Dispute resolution
│   ├── Strategy code review
│   └── Customer support
└── Producer Agent (On-demand)
    ├── Strategy verification
    ├── Backtest execution
    └── Listing creation

class SalesAgent:
    def __init__(self):
        self.twitter = TwitterClient()
        self.llm = ClaudeClient()
        self.engaged = load_json('engaged_users.json')

    async def run_cycle(self):
        # 1. Find relevant conversations
        tweets = await self.twitter.search(
            queries=[
                'quant trading strategy',
                'algo trading marketplace',
                'trading bot Python',
            ],
            exclude_retweets=True,
            min_followers=100,
        )

        # 2. Score leads
        for tweet in tweets:
            if tweet.author_id in self.engaged:
                continue

            score = await self.llm.evaluate(
                f"Score this user's relevance to a trading "
                f"strategy marketplace (0-10): {tweet.text}"
            )

            if score >= 7:
                # 3. Generate personalized reply
                reply = await self.llm.generate(
                    f"Write a helpful reply about {tweet.text}. "
                    f"Mention ClawDUX naturally if relevant."
                )
                await self.twitter.reply(tweet.id, reply)
                self.engaged[tweet.author_id] = 'commented'

async def arbitrate(self, dispute):
    # 1. Sandbox the strategy code
    result = await self.sandbox.execute(
        code=dispute.strategy_code,
        data=dispute.buyer_data,
        timeout=180,
    )

    # 2. Compare claimed vs actual metrics
    claimed = dispute.listing.metrics
    actual = result.metrics

    discrepancies = []
    if abs(actual.sharpe - claimed.sharpe) > 0.3:
        discrepancies.append(
            f"Sharpe: claimed {claimed.sharpe}, "
            f"actual {actual.sharpe}"
        )

    # 3. LLM-powered judgment
    ruling = await self.llm.evaluate(
        f"Given these discrepancies: {discrepancies}, "
        f"should the buyer get a refund?"
    )

    return {
        'ruling': ruling,
        'confidence': result.confidence,
        'analysis': result.analysis,
    }