Investment management

Investment Management

Full-stack investment management: from philosophy to execution. Research, analyze, decide, execute, track, and optimize across traditional and alternative asset classes.

Financial Management Stack

finance-substrate (Layer 1: Accounting & Tax)
  ├── Bank transaction import, certificate parsing
  ├── Form 210 tax projection, DIAN integration
  ├── Parafiscales, patrimonio, retenciones
  └── Gmail document collector
        ↓
wealth-management (Layer 2: Planning & Projections)
  ├── Compound growth projections
  ├── Goal-based planning, Monte Carlo
  ├── Portfolio summary & asset allocation
  └── Budget planning with tax savings
        ↓
investment-management (Layer 3: Analysis & Execution)  ← THIS SKILL
  ├── RESEARCH:   Market data, fundamentals, screening
  ├── ANALYZE:    Factor models, backtests, risk metrics
  ├── DECIDE:     Philosophy-driven frameworks, scoring
  ├── EXECUTE:    Trade via APIs (Alpaca, Coinbase, Polymarket)
  ├── TRACK:      Multi-platform position aggregation
  └── OPTIMIZE:   Rebalancing, tax-loss harvesting, lot management

Investment Philosophies (Built-in Frameworks)

The skill embeds decision frameworks from legendary investors. Each philosophy is a scoring lens that can be applied to any investment.

Value (Buffett/Graham/Munger)

Principle	Implementation
Economic moat analysis	Score competitive advantage: brand, network, switching cost, scale
Margin of safety	Require 25%+ discount to intrinsic value (DCF, owner earnings)
Circle of competence	Flag unfamiliar sectors; require deeper research threshold
Owner earnings	Net income + depreciation - capex (not GAAP earnings)
Quality over price	ROIC > WACC, consistent ROE > 15%, low debt/equity

Systematic (Dalio/AQR)

Principle	Implementation
All-Weather allocation	Risk-parity: equal risk contribution from growth, inflation, deflation
Factor exposure	Decompose returns into market, value, momentum, quality, size
Risk parity	Weight by inverse volatility, target equal risk contribution
Regime awareness	Detect growth/inflation quadrant, adjust allocation
Correlation regime	Monitor rolling correlations; diversification fails in crises

Passive/Index (Bogle)

Principle	Implementation
Three-fund portfolio	Total market + international + bonds; rebalance annually
Minimize costs	Flag any fund with expense ratio > 0.20%
Tax efficiency	Index funds in taxable, bonds in tax-deferred
Stay the course	Reject market timing; dollar-cost average
Simple beats complex	Baseline comparison for every active strategy

Second-Level Thinking (Marks)

Principle	Implementation
Consensus vs reality	Flag positions where market consensus is priced in
Risk is not volatility	Focus on permanent capital loss, not price fluctuation
Market cycles	Track Shiller CAPE, yield spreads, sentiment indicators
Asymmetric outcomes	Seek situations where upside >> downside
Know what you don't know	Confidence-weighted recommendations

Barbell (Taleb)

Principle	Implementation
85% ultra-safe + 15% high-convexity	Split portfolio into safe (CDTs, treasuries) + optionality (crypto, VC, prediction markets)
Antifragile positions	Identify investments that benefit from volatility
Avoid the middle	Skip mediocre risk-return profiles
Small bets, big payoffs	Position size by max loss tolerance, not expected return

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 — (Planned — not yet implemented)

In-depth analysis of a specific security or market.

Status: Planned — scripts/research.py is not yet shipped. Do not invoke; this mode is a roadmap stub.

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 — (Planned — not yet implemented)

Decompose portfolio returns into systematic factor exposures.

Status: Planned — scripts/factor_analysis.py is not yet shipped. Do not invoke; this mode is a roadmap stub.

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 — (Planned — not yet implemented)

Find optimal portfolio weights given constraints.

Status: Planned — scripts/portfolio_optimizer.py is not yet shipped. Do not invoke; this mode is a roadmap stub.

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 — (Planned — not yet implemented)

Comprehensive risk assessment of current or proposed portfolio.

Status: Planned — scripts/risk_analysis.py is not yet shipped. Do not invoke; this mode is a roadmap stub.

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 — (Planned — not yet implemented)

Execute trades via supported platform APIs.

Status: Planned — scripts/trade.py is not yet shipped. Do not invoke; this mode is a roadmap stub. (For a working, paper-only execution loop today, use services/tradingview-bridge — see below.)

Supported platforms:

Platform	Assets	Auth	Library
Alpaca	US stocks, ETFs	API key pair	alpaca-trade-api
Coinbase	Crypto	CDP API key + JWT	coinbase-advanced-py
Polymarket	Prediction markets	Wallet signature	py-clob-client
Interactive Brokers	Everything	TWS API	ib_async

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 — (Planned — not yet implemented)

Aggregate positions across all investment platforms.

Status: Planned — scripts/tracker.py is not yet shipped. Do not invoke; this mode is a roadmap stub.

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 — (Planned — not yet implemented)

Generate and optionally execute rebalancing trades.

Status: Planned — scripts/rebalancer.py is not yet shipped. Do not invoke; this mode is a roadmap stub.

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:

Source	Data	Cost	Library
yfinance	US/intl stocks, fundamentals	Free	yfinance
Financial Modeling Prep	Financial statements, ratios	Free tier	fmpsdk
CoinGecko	Crypto prices, market data	Free tier	pycoingecko
FRED	Macro indicators (800K series)	Free	fredapi
datos.gov.co	TRM (USD/COP)	Free	requests
Banco de la República	CPI, interest rates	Free	requests
Alpha Vantage	Technical data, forex	Free tier	alpha_vantage
Polymarket	Prediction market odds	Free	py-clob-client

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

Class	Screening	Research	Trading	Tracking
US Stocks	yfinance, FMP	EDGAR, fundamentals	Alpaca, IBKR	API
International Stocks	yfinance	Limited fundamentals	IBKR	API
ETFs	yfinance	Holdings analysis	Alpaca, IBKR	API
Bonds/Fixed Income	FRED yield curves	Duration, credit	IBKR	Manual
CDTs (Colombia)	Superfinanciera rates	Yield comparison	Manual	Certificates

Alternative

Class	Screening	Research	Trading	Tracking
Crypto	CoinGecko, CMC	On-chain, sentiment	Coinbase, Binance	API
Prediction Markets	Polymarket API	Market analysis	Polymarket CLOB	API
Real Estate	Manual	Cap rate, appreciation	Manual	Exogena/manual
VC/Startups	Manual	Due diligence framework	Manual	Manual
Colombian Equities	Yahoo (BVC tickers)	Limited	Davivienda Corredores (browser)	Browser/manual

Tax-Advantaged (Colombia)

Vehicle	Max Benefit	Tracking
AFC (Davivienda)	1,340 UVT cap	finance-substrate certs
Pensión Voluntaria (Skandia)	Combined w/ AFC	finance-substrate certs
Cesantías	Forced savings	finance-substrate certs

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

Autonomous decision plane — services/tradingview-bridge

A self-contained, paper-only, human-gated trading control system: a webhook receiver + multi-broker executor, plus a closed self-improving loop — research (walk-forward + anti-overfit scoring), optimize (EGRI param search with a true train/test holdout), and roster (human-gated promotion of optimized params into the roster the orchestrator measures). Drives TradingView's Paper simulator via the Interceptor CLI (no inbound API), or runs the entire decision loop on synthetic/CSV bars with no browser or broker. It measures and recommends — it never moves live capital on its own.

→ services/tradingview-bridge/QUICKSTART.md (install + the loop in 60 seconds) · full reference

Quantitative Toolkit

Libraries Used

Purpose	Library	Install
Portfolio optimization	PyPortfolioOpt	pip install pyportfolioopt
Advanced risk optimization	Riskfolio-Lib	pip install riskfolio-lib
Custom optimization	cvxpy	pip install cvxpy
Volatility modeling	arch	pip install arch
Technical indicators	pandas-ta	pip install pandas_ta
Factor data	pandas-datareader	pip install pandas-datareader
Backtesting	VectorBT	pip install vectorbt
Sentiment	transformers (FinBERT)	pip install transformers
Fundamental data	edgartools	pip install edgartools
Macro data	fredapi	pip install fredapi

Key Formulas

Formula	Expression	Use
Sharpe Ratio	(R_p - R_f) / σ_p	Risk-adjusted return
Sortino Ratio	(R_p - R_f) / σ_downside	Downside risk-adjusted
Kelly Fraction	(bp - q) / b	Optimal position size
Intrinsic Value (DCF)	Σ FCF_t / (1+r)^t + TV	Valuation
WACC	E/(E+D)×Re + D/(E+D)×Rd×(1-T)	Discount rate
Black-Scholes	C = S·N(d1) - K·e^(-rT)·N(d2)	Option pricing
VaR (parametric)	μ - z_α × σ	Tail risk
CVaR	E[L | L > VaR]	Expected tail loss
HHI (concentration)	Σ w_i²	Diversification

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

Template	Artifact	Evaluator	Score	Use When
strategy-optimization	strategy.yaml (weights, rules)	backtest.py --egri	Sharpe ratio	Optimizing portfolio allocation
screen-evolution (planned)	screen_criteria.yaml (thresholds)	screener.py + eval_screen.py (eval_screen.py not yet shipped)	Forward return	Evolving stock selection criteria

The strategy-optimization loop is live (backtest.py --egri ships). The screen-evolution loop is planned — its eval_screen.py evaluator is not yet implemented. 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

Shipped (live today):

investment-management/
├── SKILL.md                          # This file
├── skill.json                        # Schema definition (11 modes; 4 live, 7 planned)
├── scripts/
│   ├── screener.py                   # Mode 1 (screen): security screening
│   ├── backtest.py                   # Mode 4 (backtest): strategy backtesting (+ --egri)
│   ├── market_data.py                # Mode 10 (data): data retrieval
│   ├── scorer.py                     # Mode 11 (score): investment scoring
│   └── eval_backtest.py              # EGRI evaluator wrapper (autoany bridge)
├── references/
│   └── investment-philosophies.md    # Legendary investor frameworks
├── templates/
│   └── egri/                         # EGRI problem-spec templates (autoany)
│       ├── strategy-optimization.yaml   # Portfolio strategy optimization
│       ├── screen-evolution.yaml        # Screening criteria evolution (evaluator planned)
│       └── strategy-artifact.yaml       # Strategy YAML schema (mutable artifact)
├── services/
│   └── tradingview-bridge/           # Paper-only, human-gated trading decision plane
└── README.md

Planned — not yet shipped (roadmap; do not invoke):

scripts/research.py                # Mode 2 (research)
scripts/factor_analysis.py         # Mode 3 (factor)
scripts/portfolio_optimizer.py     # Mode 5 (optimize)
scripts/risk_analysis.py           # Mode 6 (risk)
scripts/trade.py                   # Mode 7 (trade)
scripts/tracker.py                 # Mode 8 (track)
scripts/rebalancer.py              # Mode 9 (rebalance)
scripts/eval_screen.py             # EGRI evaluator for screen-evolution
references/platform-apis.md        # API reference for all platforms
references/quantitative-toolkit.md # Libraries, formulas, models
references/colombian-markets.md    # BVC, CDTs, FICs, regulations
references/alternative-investments.md  # Crypto, prediction markets, RE, VC
templates/strategies.json          # Pre-built strategy configurations
templates/scoring-weights.json     # Philosophy scoring weights
.control/policy.yaml               # Trading limits, risk gates