"The Painting" — A progressive, layered approach to finding 10x investments with downside protection. Last updated: 2026-03-11.
Companies where we can buy at a price that gives us (a) very little chance of losing money AND (b) potential for 10x in 5 years if AGI plays out.
This means finding the intersection of two things:
The output is a small watchlist (5-15 companies) with specific entry prices. We monitor prices and act when they hit our targets.
| Asset | Status | Location | Coverage |
|---|---|---|---|
| Company Universe | DONE | awb/data/universe/universe.db | 8,049 companies (CIK, ticker, name, exchange) |
| 10-K Extracts | DONE | awb/data/exports/10k_all/ | 3,648 companies (10-K text extracts, up to 20K chars each) |
| AGI Impact Scores | DONE | agi_scores/results/{TICKER}.json agi_scores/agi_scores_all.json |
3,648 companies scored (5 dimensions + holistic score 1-10 + category + reasoning) |
| Returns Backtest | DONE | agi_scores/returns_data.json | 59 of 68 score 9-10 companies (1yr, 2yr, 3yr returns vs SPY) |
| Leopold Portfolio | DONE | /tmp/salp_13f/ | 5 quarterly 13F filings parsed. Full position analysis with P&L. |
| Investor Tracker | DONE | outputs/investor-tracker-*.html | 5 investors profiled (Li Lu, Weschler, Combs, Pabrai, Leopold) |
| META Deep Dive | DONE | awb/data/exports/META_analysis/ | Full 6-agent analysis + 3 price targets. Template for future deep dives. |
| Floor Price Pilot | DONE | outputs/floor-price-analysis-10-companies.html | 10 random companies. Proof of concept only. |
| AWB SQLite DB | EMPTY | awb/data/awb.db | Schema exists (companies, financials, facts, analyses) but only 7 companies, 0 financials. Not being used. |
| Structured Financials | NOT STARTED | — | No structured balance sheet / income statement data at scale |
Results are spread across JSON files, SQLite databases (2 of them, both underused), HTML reports, markdown files, and /tmp. There is no single place where "everything we know about Company X" lives. This means:
awb.db as the master databaseEvery piece of analysis we produce gets stored in the SQLite database at awb/data/awb.db. One database. One source of truth. Every session reads from and writes to this database.
The existing schema is close to what we need but requires these changes:
-- 1. COMPANIES TABLE (exists, needs population)
-- Import all 8,049 companies from universe.db
-- Add columns for quick filtering
-- 2. NEW: company_metrics — the "painting" table
-- Each row = one metric for one company
-- This is where ALL layers of analysis accumulate
CREATE TABLE company_metrics (
id INTEGER PRIMARY KEY AUTOINCREMENT,
ticker TEXT NOT NULL,
cik TEXT,
metric_name TEXT NOT NULL, -- e.g. 'agi_score', 'tangible_book_value', 'floor_price'
metric_value REAL, -- numeric value (NULL if text-only)
metric_text TEXT, -- text value (for reasoning, category, etc.)
metric_json TEXT, -- JSON for complex data (timelines, breakdowns)
source TEXT, -- 'agi_scoring_v1', 'yfinance', 'sec_xbrl', 'deep_dive_v1'
confidence TEXT, -- 'high', 'medium', 'low'
computed_at TIMESTAMP,
cost_usd REAL, -- what it cost to compute this
UNIQUE(ticker, metric_name, source) -- no duplicates
);
-- 3. NEW: watchlist — the final output
CREATE TABLE watchlist (
ticker TEXT PRIMARY KEY,
entry_price REAL, -- our target buy price
current_price REAL,
floor_price REAL,
bull_case_5yr REAL, -- 5-year bull case price
agi_score INTEGER,
conviction TEXT, -- 'high', 'medium', 'low'
thesis TEXT, -- 1-2 sentence investment thesis
last_updated TIMESTAMP
);
| Data Type | Storage | Why |
|---|---|---|
| All metrics (scores, financials, valuations) | company_metrics table | Queryable, deduplicated, versionable |
| Deep-dive analyses (long text) | analyses table (existing) | Already designed for this |
| Key facts/signals | facts table (existing) | Structured findings from analyses |
| Final watchlist | watchlist table | The output — what we actually monitor |
| Raw data files (10-K text, XML) | Flat files on disk | Too large for SQLite, used as inputs |
| HTML reports | outputs/ directory | Human-readable outputs, synced to Google Drive |
Before computing any metric, check if it already exists:
SELECT * FROM company_metrics
WHERE ticker = ? AND metric_name = ?
AND computed_at > datetime('now', '-30 days')
If a result exists and is less than 30 days old, skip. If older than 30 days, recompute (prices change, filings update). Each metric has a source field so we can track which version of the analysis produced it.
universe.db into awb.db companies tableagi_scores_all.json into company_metricscompany_metrics (as a "smart_money_signal" metric)Each layer adds more detail to our picture of each company. Earlier layers are cheap and broad; later layers are expensive and narrow. We paint the most important parts first.
| # | Layer | Coverage | Cost | Metrics Produced | Status |
|---|---|---|---|---|---|
| 0 | Universe Who exists? |
8,049 | Free | ticker, name, CIK, exchange, SIC code | DONE |
| 1 | AGI Score Does AGI help or hurt? |
3,648 | $355 | agi_score (1-10), 5 dimension scores, category, confidence, reasoning | DONE |
| 2 | Financial Snapshot What do the numbers say? |
~350 (score 7+) |
~$0 yfinance API |
market_cap, revenue, net_income, total_assets, total_liabilities, total_debt, cash, book_value, tangible_book_value, fcf, pe_ratio, pb_ratio, ev_ebitda, dividend_yield, shares_outstanding | NEXT |
| 3 | Asset-Based Floor What's the downside? |
~350 | ~$35 Haiku batch |
floor_price, floor_confidence, floor_methodology, tangible_book_per_share, net_current_asset_value, liquidation_value_estimate | NEXT |
| 4 | Smart Money Signal Who else owns this? |
~350 | ~$0 SEC EDGAR 13F |
leopold_holds, leopold_shares, leopold_avg_cost, top_13f_holders, insider_buying_ratio, institutional_ownership_pct | NEXT |
| 5 | Quick Valuation What's cheap vs expensive? |
~100 (passed filters) |
~$10 Haiku |
price_to_tangible_book, ev_to_fcf, price_vs_floor, margin_of_safety_pct, cheapness_rank | LATER |
| 6 | 5-Year Cash Flow Model What's the upside? |
~30 | ~$30 Sonnet |
bull_revenue_2031, bull_fcf_2031, bull_price_2031, base_price_2031, bear_price_2031, entry_price_for_10x, current_price_vs_10x_entry | LATER |
| 7 | Deep Dive Full 6-agent analysis |
~10 | ~$50 Opus |
Full META-style analysis: business moat, management, risks, 3 price targets, AGI impact deep-dive | LATER |
| 8 | Watchlist Monitor and act |
5-15 | ~$0 | entry_price, current_price, alert_threshold, thesis, conviction | LATER |
Layer 0-1 already done ($355 spent). Layers 2-8 cost approximately $75-125 more. The funnel narrows aggressively, so expensive analysis is only done on a handful of companies.
Within each layer, we prioritize companies using a composite score:
| Signal | Weight | Why |
|---|---|---|
| AGI Score (1-10) | 30% | Higher score = more AGI tailwind = more upside potential |
| Proximity to Floor (current price / floor price) | 25% | Closer to floor = more downside protection = safer entry |
| Smart Money Signal (held by tracked investors) | 20% | Leopold, Li Lu, etc. holding = validation of thesis |
| Asset Density (tangible book / market cap) | 15% | Higher = more asset backing per dollar of market cap |
| Simplicity (can we understand the business?) | 10% | Simpler businesses = more reliable floor estimates |
One-time setup. Consolidate all existing data into awb.db.
company_metrics and watchlist tablesuniverse.dbcompany_metricsCost: $0 Time: ~30 minutes
Pull structured financial data for all ~350 score-7+ companies via yfinance.
company_metricsCost: $0 Time: ~15 minutes (yfinance API calls)
For each of the ~350 companies, compute a rough floor price. Two approaches in parallel:
Cross-reference both approaches. Where they disagree, flag for manual review.
Cost: ~$35 Time: ~1 hour
For the ~350 companies, check if any tracked investors hold them.
Cost: $0 Time: ~30 minutes (SEC EDGAR API)
Apply the priority score. Keep companies that meet ANY of:
Cost: $0 Time: 5 minutes (SQL query)
For the ~20-30 highest priority candidates, build bull/base/bear scenarios.
Cost: ~$30 Time: ~2-3 hours
Full META-style 6-agent analysis for the final ~10 companies.
Cost: ~$50 Time: ~4-6 hours
Compile the final watchlist with entry prices. Set up monitoring.
Cost: $0 Time: 1 hour
| Phase | What | Model | Companies | Est. Cost |
|---|---|---|---|---|
| Already spent | AGI scoring (Layer 1) | Sonnet | 3,648 | $355 |
| Step 0 | DB migration | — | — | $0 |
| Step 1 | Financial snapshot | yfinance | ~350 | $0 |
| Step 2 | Floor screening | Haiku batch | ~350 | $35 |
| Step 3 | Smart money overlay | SEC API | ~350 | $0 |
| Step 4 | Filter / prioritize | SQL query | — | $0 |
| Step 5 | 5-year cash flow models | Sonnet | ~30 | $30 |
| Step 6 | Deep dives | Opus | ~10 | $50 |
| Step 7 | Watchlist setup | — | 5-15 | $0 |
| Total remaining | ~$115 | |||
| Grand total (including Layer 1) | ~$470 | |||
| Ticker | Entry Price | Current | Floor | Bull 5yr | Upside | Conviction | Thesis |
|---|---|---|---|---|---|---|---|
| EXAMPLE | $12.50 | $18.40 | $10.00 | $125 | 10x | High | AGI infrastructure with $X/share in tangible assets... |
| Populated after Steps 5-7 complete | |||||||
When we do buy, position sizing follows the floor price confidence:
Every analysis result goes into awb.db. Every metric has a source tag, timestamp, and cost. If we redo an analysis with a better model, the old result stays (different source tag). We can always compare versions.
Before computing anything, check if it exists in the database. If it's less than 30 days old, skip. If it's older, we can choose to recompute or keep. The UNIQUE(ticker, metric_name, source) constraint prevents accidental duplicates.
Free data (yfinance, SEC EDGAR) before paid data (API calls). Haiku ($0.01/company) before Sonnet ($0.10/company) before Opus ($5/company). Only escalate model quality when the cheaper model's output is the bottleneck.
Score 3,648 companies at low depth before deep-diving 10 companies. The funnel ensures we don't waste expensive analysis on companies that fail basic screens. Each layer narrows the funnel by 3-5x.
Pull numbers first (financials, ratios, prices). Then apply judgment (floor estimates, thesis evaluation). Numbers are fast to compute and easy to filter. Judgment is expensive and should only be applied to the survivors.
AI-generated floor prices are estimates. Before putting real money in, we manually verify the deep dive: read the 10-K ourselves, check the balance sheet line by line, validate the thesis. The AI does the screening; we do the final diligence.
Considered and rejected for now. The core problem: RL needs a reward signal, and for investments, the reward is whether the investment makes money — which we only know years later. Any proxy reward would just encode our existing beliefs, gaining nothing over good prompting.
The real bottleneck is not model capability (Claude is already excellent at reading 10-Ks and reasoning about businesses). The bottleneck is having the right data in the right structure and applying disciplined screening. That's what this strategy addresses.
If we wanted to revisit later, the most promising angle would be fine-tuning on historical 10-K → 5-year-return pairs (supervised learning, not RL). But we'd need ~20 years of 10-K data mapped to outcomes, and the resulting model would still be backward-looking. Better to invest the time in fundamental analysis.
The next Claude Code session should:
awb.db (30 min)By end of that session, we'll have the first filtered list of candidates. Total cost: ~$0 (no API calls needed for Steps 0-2 quantitative part).