Building Autonomous Trading Agents with Real-World Intelligence

T+0s     News event occurs (breaking headline published)
T+3s     Ingest pipeline captures article
T+6s     Embedding generated from article text
T+8s     Vector similarity search returns historical analogs
T+10s    Signal generated (direction, magnitude, confidence)
T+12s    Risk manager evaluates and approves trade
T+14s    Execution engine submits order to Hyperliquid
T+16s    Order confirmed on-chain
T+30s    Position monitored, stop-loss and take-profit set

┌──────────────────────────────────────────┐
│           NEWS CATEGORIES                 │
├──────────────────────────────────────────┤
│ 1.  Crypto & Blockchain                  │
│ 2.  Macroeconomics (Fed, CPI, jobs)      │
│ 3.  Regulation & Policy                   │
│ 4.  DeFi & Lending                        │
│ 5.  NFTs & Digital Assets                 │
│ 6.  Gaming & Metaverse                    │
│ 7.  AI & Technology                       │
│ 8.  Geopolitics                           │
│ 9.  Energy & Commodities                  │
│ 10. Traditional Finance (TradFi)          │
│ 11. Corporate Events (earnings, M&A)      │
│ 12. Social Media Sentiment (Twitter/X)    │
└──────────────────────────────────────────┘

class IngestPipeline {
  private sources: NewsSource[];
  private dedupCache: Map<string, number>;
  
  async poll(): Promise<Article[]> {
    const results = await Promise.allSettled(
      this.sources.map(s => s.fetch())
    );
    
    const articles = results
      .filter((r): r is FulfilledResult<Article[]> => r.status === 'fulfilled')
      .flatMap(r => r.value)
      .filter(a => !this.isDuplicate(a))
      .map(a => this.normalize(a));
    
    return articles;
  }
  
  private isDuplicate(article: Article): boolean {
    // Fingerprint: first 8 words of headline + source
    const fingerprint = this.fingerprint(article);
    if (this.dedupCache.has(fingerprint)) return true;
    this.dedupCache.set(fingerprint, Date.now());
    
    // Evict old entries (24h TTL)
    for (const [key, ts] of this.dedupCache) {
      if (Date.now() - ts > 24 * 60 * 60 * 1000) {
        this.dedupCache.delete(key);
      }
    }
    return false;
  }
}

import { embed } from './embedding-model';

async function processArticle(article: Article): Promise<Signal> {
  // 1. Create rich text representation
  const richText = [
    article.headline,
    article.summary,
    `Category: ${article.category}`,
    `Source: ${article.source}`,
    `Entities: ${article.entities.join(', ')}`,
  ].join('\n');
  
  // 2. Generate embedding
  const embedding = await embed(richText);
  // → 768-dimensional float vector
  
  // 3. Find historical analogs
  const analogs = await vectorStore.search(embedding, {
    k: 25,
    filters: {
      category: article.category,
      minSimilarity: 0.7,
    },
    includeMetadata: ['market_outcome', 'time_delta'],
  });
  
  // 4. Compute expected market impact
  const expectedImpact = analogs.reduce((acc, a, i) => {
    const weight = a.similarity * Math.exp(-a.age_days / 120);
    return acc + a.market_outcome.price_change_1h * weight;
  }, 0) / analogs.reduce((acc, a) => {
    const weight = a.similarity * Math.exp(-a.age_days / 120);
    return acc + weight;
  }, 0);
  
  // 5. Generate signal
  const confidence = Math.min(0.95, analogs.reduce((acc, a) => 
    acc + a.similarity, 0) / analogs.length * 1.5);
  
  return {
    direction: expectedImpact > 0 ? 'LONG' : 'SHORT',
    magnitude: Math.abs(expectedImpact),
    confidence,
    asset: inferTargetAsset(article),
    historicalAnalogs: analogs.slice(0, 5),
    sourceArticle: article,
  };
}

class RiskManager {
  private state: RiskState;
  
  async evaluate(signal: Signal): Promise<RiskDecision> {
    const checks = {
      positionSize: this.checkPositionSize(signal),
      portfolioRisk: this.checkPortfolioRisk(signal),
      drawdownLimit: this.checkDrawdownLimit(),
      correlationLimit: this.checkCorrelation(signal),
      liquidityCheck: this.checkLiquidity(signal),
      volatilityRegime: this.checkVolatilityRegime(),
      newsFreshness: this.checkNewsFreshness(signal),
      executionFeasibility: this.checkExecutionFeasibility(signal),
    };
    
    const failed = Object.entries(checks)
      .filter(([_, passed]) => !passed);
    
    if (failed.length > 0) {
      return {
        approved: false,
        reasons: failed.map(([check]) => check),
      };
    }
    
    return {
      approved: true,
      adjustedSize: this.computePositionSize(signal),
      stopLoss: this.computeStopLoss(signal),
      takeProfit: this.computeTakeProfit(signal),
      maxHoldingTime: this.computeMaxHoldingTime(signal),
    };
  }
  
  private computePositionSize(signal: Signal): number {
    const baseSize = this.config.maxPositionSize;
    const confidenceScale = signal.confidence;  // 0-1
    const drawdownScale = 1 - (this.state.currentDrawdown / this.config.maxDailyDrawdown);
    const volatilityScale = this.getVolatilityScale(signal.asset);
    
    return baseSize * confidenceScale * drawdownScale * volatilityScale;
  }
}

class CircuitBreaker {
  private consecutiveLosses = 0;
  private dailyPnL = 0;
  private lastTradeTime = 0;
  
  async check(): Promise<boolean> {
    // Hard stop: daily drawdown exceeded
    if (this.dailyPnL < -this.config.maxDailyDrawdown) {
      this.halt('DAILY_DRAWDOWN_EXCEEDED');
      return false;
    }
    
    // Soft stop: consecutive losses
    if (this.consecutiveLosses >= 5) {
      this.cooldown(24 * 60 * 60 * 1000); // 24 hours
      return false;
    }
    
    // Rate limit: no more than 1 trade per 5 minutes
    if (Date.now() - this.lastTradeTime < 5 * 60 * 1000) {
      return false;
    }
    
    return true;
  }
}

class ExecutionEngine {
  async execute(decision: RiskDecision, signal: Signal): Promise<TradeResult> {
    const order = this.buildOrder(decision, signal);
    
    // 1. Check current market depth
    const depth = await this.getMarketDepth(signal.asset);
    const maxSlippage = this.computeMaxSlippage(order, depth);
    
    if (maxSlippage > this.config.maxSlippage) {
      return { status: 'REJECTED', reason: 'EXCESSIVE_SLIPPAGE' };
    }
    
    // 2. Submit limit order (not market order)
    const limitPrice = this.computeLimitPrice(signal.direction, depth);
    const orderResult = await this.submitOrder({
      asset: signal.asset,
      side: signal.direction === 'LONG' ? 'BUY' : 'SELL',
      size: decision.adjustedSize,
      price: limitPrice,
      type: 'LIMIT',
      tif: 'IOC',  // Immediate or Cancel
    });
    
    if (!orderResult.filled) {
      // Retry with market order if slippage is still acceptable
      return this.fallbackToMarket(order, depth);
    }
    
    // 3. Set stop-loss and take-profit
    await this.setRiskOrders(orderResult, {
      stopLoss: decision.stopLoss,
      takeProfit: decision.takeProfit,
    });
    
    // 4. Record trade for portfolio tracking
    this.recordTrade(orderResult, signal, decision);
    
    return { status: 'FILLED', order: orderResult };
  }
}

┌─────────────────────────────────────────────┐
│            AGENT COORDINATOR                 │
│                                             │
│  ┌───────────┐  ┌───────────┐  ┌──────────┐ │
│  │  Macro    │  │  Crypto   │  │  DeFi    │ │
│  │  Agent    │  │  Agent    │  │  Agent   │ │
│  └─────┬─────┘  └─────┬─────┘  └────┬─────┘ │
│        │              │             │        │
│  ┌─────┴──────────────┴─────────────┴─────┐  │
│  │         PORTFOLIO COORDINATOR          │  │
│  │  (Cross-agent risk management)          │  │
│  └────────────────────────────────────────┘  │
└─────────────────────────────────────────────┘