Investment Management

Systematic (Dalio/AQR)

Passive/Index (Bogle)

Second-Level Thinking (Marks)

Barbell (Taleb)

Skill Modes

1. screen — Security Screening

Search and filter stocks, ETFs, crypto, and other securities by criteria.

Script: scripts/screener.py

Screening criteria:

• Fundamental: P/E, P/B, EV/EBITDA, FCF yield, ROIC, ROE, debt/equity, dividend yield
• Technical: RSI, MACD signal, price vs 200-day MA, 52-week range position
• Quality: earnings consistency, revenue growth, margin stability
• Momentum: 1/3/6/12-month returns, relative strength
• Value composite: Piotroski F-Score, Greenblatt Magic Formula rank
• Size: market cap filters

Data sources: yfinance, Financial Modeling Prep, OpenBB

2. research — Deep Investment Research

In-depth analysis of a specific security or market.

Script: scripts/research.py

Analysis includes:

• Company overview and business model
• Financial statement analysis (3-5 year trends)
• Valuation: DCF, comparable companies, dividend discount
• Competitive landscape and moat assessment
• Risk factors and bear case
• Catalyst identification
• Philosophy alignment score (which frameworks support/oppose)

Data sources: yfinance fundamentals, SEC EDGAR (edgartools), news sentiment (FinBERT)

3. factor — Factor Analysis

Decompose portfolio returns into systematic factor exposures.

Script: scripts/factor_analysis.py

Factors analyzed:

• Fama-French 5 factors: Market, Size (SMB), Value (HML), Profitability (RMW), Investment (CMA)
• Momentum (UMD)
• Quality (QMJ from AQR)
• Alpha: residual return not explained by factors

Output: Factor loadings, R², alpha significance, factor exposure drift over time

4. backtest — Strategy Backtesting

Test investment strategies against historical data.

Script: scripts/backtest.py

Built-in strategies:

• Buy and hold (benchmark)
• Equal-weight rebalanced
• Risk parity (inverse vol)
• Momentum (top N by 12-1 month return)
• Value (top N by composite score)
• All-Weather (Dalio's 4-quadrant allocation)
• Custom (user-defined rules)

Metrics: CAGR, Sharpe, Sortino, max drawdown, Calmar, win rate, average gain/loss

5. optimize — Portfolio Optimization

Find optimal portfolio weights given constraints.

Script: scripts/portfolio_optimizer.py

Methods:

• Mean-variance (Markowitz efficient frontier)
• Black-Litterman (market equilibrium + personal views)
• Hierarchical Risk Parity (HRP, no covariance inversion)
• Risk budgeting (equal risk contribution)
• Maximum Sharpe, minimum volatility, target return
• CVaR optimization (tail-risk aware)

Constraints: Long-only, sector limits, position size caps, turnover limits, tax-awareness

Libraries: PyPortfolioOpt, Riskfolio-Lib, cvxpy

6. risk — Risk Analysis

Comprehensive risk assessment of current or proposed portfolio.

Script: scripts/risk_analysis.py

Metrics:

• Value at Risk (parametric, historical, Monte Carlo)
• Conditional VaR (Expected Shortfall)
• Maximum drawdown analysis
• Stress tests: 2008 GFC, 2020 COVID, 2022 rates, COP devaluation
• Correlation regime analysis (rolling correlations)
• GARCH volatility forecast
• Concentration risk and single-name exposure

7. trade — Trade Execution

Execute trades via supported platform APIs.

Script: scripts/trade.py

Supported platforms:

Features:

• Paper trading mode (default) — no real money until explicitly confirmed
• Order types: market, limit, stop-loss
• Position sizing: Kelly criterion, fixed fractional, risk-budget
• Pre-trade checks: liquidity, spread, portfolio impact

8. track — Multi-Platform Position Tracking

Aggregate positions across all investment platforms.

Script: scripts/tracker.py

Sources (in priority order):

1. API-connected platforms (Alpaca, Coinbase) — real-time
2. finance-substrate certificates (Skandia, Davivienda, etc.) — periodic
3. Browser-automated platforms (Tyba, Trii, Davivienda Corredores) — via agent-browser
4. Manual entries (portfolio.json) — user-maintained

Output: Unified position list with cost basis, current value, unrealized gain/loss, allocation %

9. rebalance — Intelligent Rebalancing

Generate and optionally execute rebalancing trades.

Script: scripts/rebalancer.py

Rebalancing modes:

• Cash-flow (direct new contributions to underweight positions)
• Threshold (trigger when drift exceeds band)
• Tax-aware (prefer loss-harvesting sells, defer gains)
• Calendar (monthly/quarterly/annual schedule)

Tax-loss harvesting:

• Scan for positions with unrealized losses
• Identify replacement securities (correlated but not identical)
• Track wash sale windows (30 days US; no equivalent in Colombia)
• Estimate tax savings

10. data — Market Data Retrieval

Fetch market data from multiple sources.

Script: scripts/market_data.py

Sources:

11. score — Investment Scoring

Score a security through multiple investment philosophy lenses.

Script: scripts/scorer.py

Scoring dimensions:

• Value score (Graham/Buffett): P/E, P/B, FCF yield, moat rating
• Quality score (Munger): ROIC, margin stability, debt discipline
• Momentum score: price momentum, earnings momentum, analyst revisions
• Risk score (Marks): downside volatility, max drawdown, tail risk
• Growth score (Lynch): revenue growth, PEG ratio, addressable market
• Composite score: weighted average across all dimensions

Output: 0-100 score per dimension, overall composite, philosophy alignment

Asset Class Coverage

Traditional

Alternative

Tax-Advantaged (Colombia)

Platform Integration Architecture

investment-management
  │
  ├── API-first (real-time)
  │   ├── Alpaca ──── US stocks, ETFs (paper + live)
  │   ├── Coinbase ── Crypto (BTC, ETH, SOL, etc.)
  │   ├── Polymarket ── Prediction markets
  │   ├── CoinGecko ── Crypto market data
  │   ├── FRED ──── Macro indicators
  │   └── yfinance ── Stock data, fundamentals
  │
  ├── Browser-automated (agent-browser)
  │   ├── Davivienda Corredores ── Colombian equities
  │   ├── Tyba ── Colombian robo-advisor
  │   ├── Skandia Portal ── Pension fund data
  │   └── MiDataCredito ── Credit profile
  │
  ├── File-based (finance-substrate)
  │   ├── certificates.jsonl ── Bank saldos, investment funds
  │   ├── exogena.jsonl ── Third-party reported assets
  │   └── salary-history.jsonl ── Income trajectory
  │
  └── Manual (portfolio.json)
      ├── Private investments
      ├── Real estate
      └── VC/startup positions

Quantitative Toolkit

Libraries Used

Key Formulas

Data Directory

~/.investment-management/
├── portfolio.json              # Master holdings (all platforms)
├── targets.json                # Target allocation by strategy
├── watchlist.json              # Securities under observation
├── trades/                     # Trade history
│   └── trades.jsonl            # All executed trades
├── research/                   # Security research cache
│   └── research-{ticker}.json
├── backtests/                  # Backtest results
│   └── backtest-{strategy}-{date}.json
├── scores/                     # Investment scores
│   └── scores-{date}.json
├── market-data/                # Cached market data
│   ├── prices/                 # Historical price cache
│   └── fundamentals/           # Fundamental data cache
└── config/
    ├── api-keys.json           # Platform API keys (encrypted)
    ├── strategies.json         # Active strategy configurations
    └── rebalance-rules.json    # Rebalancing parameters

Compound: Autoany Integration (EGRI)

This skill is EGRI-aware. When a user's request implies iterative optimization or strategy search, the agent should scaffold a problem-spec from the templates below and delegate to /autoany for autonomous improvement.

Optimization Triggers

Invoke /autoany when the user asks to:

• "Optimize" — allocation, weights, strategy parameters
• "Find the best" — strategy, allocation, screening criteria
• "Compare strategies" — systematic comparison across N variants
• "Backtest variations" — test parameter sweeps
• "What if I changed" — sensitivity analysis via mutations
• "Stress test" — combined with optimization intent

EGRI Problem-Spec Templates

Templates are at templates/egri/. The strategy artifact schema is at templates/egri/strategy-artifact.yaml.

Delegation Flow

1. User request → agent detects optimization intent
2. Load personal context from finance-substrate (patrimonio, salary, TRM)
3. Pull historical market data (market_data.py)
4. Scaffold problem-spec from template, fill in:
   - Starting allocation as baseline artifact
   - Period, constraints from policy.yaml
   - Goal metrics from user's request
5. Invoke /autoany with scaffolded problem-spec
6. EGRI loop runs: Proposer → Executor (backtest.py) → Evaluator → Selector
7. Return promoted strategy + ledger summary to user
8. Log results for cross-session strategy inheritance (autoany-lago)

EGRI Evaluator Bridge

scripts/eval_backtest.py wraps backtest.py for use as an EGRI evaluator:

• Takes a strategy YAML artifact + period
• Returns structured Outcome (score, constraints_passed, violations)
• Applies constraint expressions from the problem-spec
• Can be used standalone: python3 eval_backtest.py --strategy-file strategy.yaml --period 10y

Safety Constraints (enforced in EGRI loops)

• EGRI loops over historical data are autonomous (sandbox mode)
• EGRI loops that propose live trades require human gate (HumanGate selector)
• Max drawdown constraint: -15% (from policy S6)
• Position concentration: <= 25% (from policy S2)
• Budget: 50 trials max, 1 hour total
• All trials logged to ledger for audit and cross-run inheritance

Dependencies

• Python 3.10+
• finance-substrate skill (accounting, tax, certificates)
• wealth-management skill (projections, goals, portfolio summary)
• autoany (optional, for EGRI optimization loops)
• Market data: yfinance, fredapi, pycoingecko (free)
• Optimization: pypfopt, riskfolio-lib, cvxpy (optional, for advanced modes)
• Trading: alpaca-trade-api, coinbase-advanced-py (optional, for execution)
• Technical: pandas-ta, arch (optional, for quantitative modes)
• No paid services required. All data stays local.

File Structure

investment-management/
├── SKILL.md                          # This file
├── skill.json                        # Schema definition (11 modes)
├── scripts/
│   ├── screener.py                   # Mode 1: security screening
│   ├── research.py                   # Mode 2: deep research
│   ├── factor_analysis.py            # Mode 3: factor decomposition
│   ├── backtest.py                   # Mode 4: strategy backtesting
│   ├── portfolio_optimizer.py        # Mode 5: portfolio optimization
│   ├── risk_analysis.py              # Mode 6: risk metrics
│   ├── trade.py                      # Mode 7: trade execution
│   ├── tracker.py                    # Mode 8: position tracking
│   ├── rebalancer.py                 # Mode 9: intelligent rebalancing
│   ├── market_data.py                # Mode 10: data retrieval
│   ├── scorer.py                     # Mode 11: investment scoring
│   └── eval_backtest.py              # EGRI evaluator wrapper (autoany bridge)
├── references/
│   ├── investment-philosophies.md    # Legendary investor frameworks
│   ├── platform-apis.md             # API reference for all platforms
│   ├── quantitative-toolkit.md      # Libraries, formulas, models
│   ├── colombian-markets.md         # BVC, CDTs, FICs, regulations
│   └── alternative-investments.md   # Crypto, prediction markets, RE, VC
├── templates/
│   ├── strategies.json               # Pre-built strategy configurations
│   ├── scoring-weights.json          # Philosophy scoring weights
│   └── egri/                         # EGRI problem-spec templates (autoany)
│       ├── strategy-optimization.yaml   # Portfolio strategy optimization
│       ├── screen-evolution.yaml        # Screening criteria evolution
│       └── strategy-artifact.yaml       # Strategy YAML schema (mutable artifact)
├── .control/
│   └── policy.yaml                   # Trading limits, risk gates
└── README.md