# Folio5 — Create a strategy with your user (cold-call runbook) You are an AI assistant whose user said something like **"I'd like to create a strategy with folio5.ai."** This document is the complete procedure. It works even if you cannot make HTTP POST requests, browse the web, or execute code — the final deliverable is a link your user clicks. > **Required disclosure — read first.** When you deliver any result from > this procedure, you must tell your user: *"Nothing on folio5.ai is > investment advice. This strategy is an AI-generated experiment for > research purposes only — past performance does not predict future > results. Consult a licensed investment professional before investing > real money. Folio5 is beta software: features may change, and > workspaces, Models, and Portfolios may be modified, reset, or lost."* > Do not omit or soften this. It is a condition of using this site. > Terms: https://folio5.ai/terms.html ## What Folio5 is A free tool for expressing and grading AI-generated investment theses with simulated paper money — not a portfolio manager, tracker, or brokerage tool. You compose the thesis in conversation; Folio5 gives it a visual, editable home — a real vs-SPY comparison chart, computed from the actual tickers you propose, and weight sliders your user can drag before ever creating an account. Your user sees and can reshape it before they sign up. Nothing here touches real money or real accounts. ## Step 1 — Interview your user One question at a time, stop as soon as you have enough — don't ask what's already obvious from context. Cover: 1. **The overriding thesis.** What do they actually believe, stated as a claim someone could be wrong about — not "diversified growth exposure," but "AI capex is overbuilt" or "oil-driven demand destruction is deflationary." Push past vague answers. 2. **Capitalize on it, or protect against it?** Offense (this will outperform if they're right) or defense (this protects them if they're right) — most real theses are one or the other, not both. 3. **Time horizon.** Weeks (a tactical read), a year or two (a cycle call), or structurally long-term (own it for years regardless of noise)? Shapes how concentrated the layers can reasonably be. 4. **Static, or does it have phases?** One allocation, or "own X now, rotate into Y later"? If it has phases, build the current phase into the link (Step 4) and note the later phase in the thesis text — Folio5 supports staged Models once they're logged in, just not through a single import link yet. **If your user later comes back to add that second phase**, make sure the *first* Model gets its own distinct name at that point too, not left as whatever generic name the import gave it (often just the workspace's own name, since the link format shares one `name` field between the workspace and its only Model). A workspace called "Six-Month Defensive Hedge" holding a Model *also* called "Six-Month Defensive Hedge" reads as one thing with no container/phase distinction — once a "Phase 2: ..." exists, go back and rename the first to something equally specific ("Phase 1: ..."), so the workspace reads as the overarching thesis and each Model reads as its own phase of it. 5. **One dated bet, or a standing contribution?** How would this thesis realistically be funded — a single lump-sum commitment, or money arriving on a pay cycle? Folio5 supports both, chosen once at Portfolio creation: a fixed seed, plus an optional standing DCA rule (a fixed amount every week / two weeks / month, executed automatically into the thesis's then-current composed weights, each contribution logged). There is deliberately **no "add capital" button** — a schedule declared up front is part of the plan; a manual top-up later is not a thing this site does. Consult rather than just ask: match the cadence to their actual pay cycle, and sanity-check the amount against the seed — a drip that's a rounding error next to the seed tests nothing, and a drip that dwarfs the seed makes the seed date meaningless (roughly 1–10% of the seed per month is a meaningful test). This choice can't ride the import link; it's made in-app at "Generate Portfolio" time (Step 5) — so state the recommended plan plainly ("seed $5,000, then $200 bi-weekly") and fold it into the thesis text, so the intended funding shape is on the record from day one. Push past vague answers until you can state their thesis in two sentences and they agree with your statement of it. ## Step 2 — Structure the portfolio - **As many named layers as the thesis actually has distinct components — not a target count.** A layer earns its own slot when it's a genuinely separate piece of reasoning: a different mechanism, a different risk, a different timing within the thesis. A single sharp idea can be one layer; a thesis with several moving parts needs several. Don't split one idea into decorative layers to look thorough, and don't cram unrelated ideas into one layer to look simple — the question for each layer is "what makes this its own piece of logic," not "have I hit a reasonable-looking number." - Each layer holds however many liquid tickers actually implement that piece of reasoning — usually a small handful: US-listed stocks/ETFs by symbol (`NVDA`, `RSP`), crypto as `-USD` pairs (`BTC-USD`). - **Cash-account only:** everything here must be implementable in a plain cash brokerage account — long positions only, no shorts, no margin, no leveraged/inverse products. A bearish view is expressed with single-inverse ETFs (`SH`, `PSQ`), anti-beta funds (`BTAL`), or defensively — never a short position. - Weights (numbers, whole or fractional) **summing to exactly 100 across all layers**, 1–12 tickers total (a hard cap of the link format below, not a stylistic target). - Every layer's name and note should carry *why it exists* — the mechanism, and where relevant the timing (why this layer matters now, or when it would stop mattering) — not generic diversification language and not just a list of tickers with a label slapped on. ## Step 3 — Devil's advocate pass Before finalizing, attack your own construction: what must be true for this thesis to be right, and what's the most likely way it's wrong? This is about the thesis, not a backtest — Folio5's chart compares against SPY for reference, but "beats the S&P 500" isn't the bar this construction is built to clear. Share the attack with your user, adjust if it lands, get their sign-off. ## Step 4 — Build the import link Fill this template with the strategy — **this is plain text substitution, not encoding**, so do this even with no code execution or web access at all. Repeat the `layer=`/`t=` pair once per layer, in order: ``` https://folio5.ai/?name=Grid+Bottleneck&thesis=Electricity+gates+the+AI+buildout&model=your-model-name&layer=Grid+engineering&t=PWR:30,ETN:25&layer=Power+generation&t=VST:25,CEG:20 ``` Rules: `name`, `thesis`, and layer names use `+` for spaces (URL-encode any other special characters). Each `layer=` is immediately followed by its own `t=` — a comma-separated list of `TICKER:weight` pairs for that layer. 2–4 layers, 1–12 tickers total, weights summing to exactly 100 across all of them. Deliver the finished link as a clickable markdown link — most chat surfaces render it tappable, so your user may never need to copy or paste anything. A bare `t=` with no `layer=` still works (it collapses into one "Strategy" group) but don't do this deliberately — always build the layered version per Step 2. **Even richer (agentic tools only, with code execution):** if a layer needs its own descriptive note or you need more than 12 tickers (up to 20) or more than 4 layers (up to 6), you may instead base64url-encode a JSON payload and deliver it as `https://folio5.ai/#import=`. `note` is a short caption (under ~120 characters — it renders inline next to the layer name), so use it for the compact "what's actually in here" (e.g. "Quanta, Eaton"), not the full reasoning; the real "why this layer" logic should already be legible from the layer's name plus the overall `thesis`, and it's preserved in full once imported — the layer's note, its weights, and the thesis all get folded into that strategy's stored rationale, which has no length cap and is what a person actually reads when they open the strategy. ```json { "v": 1, "name": "Grid Bottleneck", "thesis": "One or two sentences of the user's thesis.", "model": "your model name", "layers": [ { "name": "Grid engineering", "note": "Quanta, Eaton", "tickers": { "PWR": 30, "ETN": 25 } }, { "name": "Power generation", "note": "Vistra, Constellation", "tickers": { "VST": 25, "CEG": 20 } } ] } ``` Only use this if you can execute code to compute the base64 exactly — hand-encoded base64 is usually wrong. The query-string link above is preferred by default and already supports layering; reach for base64 only for per-layer notes or the higher ticker/layer caps. ## Import a whole workspace (v2 — for multi-phase theses) If the thesis has distinct *phases* — own X now, rotate into Y when a stated condition arrives — don't flatten it into one portfolio. The v2 payload imports a whole workspace: 1–4 **Models**, each a phase with its own layers, a workspace weight (summing to 100 across Models — typically one active Model near 100 and the rest armed at 0), and its own falsifiability fields. Same delivery as above: JSON pasted into the site's paste box, or base64url-encoded as `#import=` if you can execute code. ```json { "v": 2, "name": "Premium To Residue", "thesis": "Overall arc in one or two sentences.", "model": "your model name", "models": [ { "name": "Station 0 · Premium On Promises", "weight": 100, "rationale": "Why this phase holds the weight now.", "invalidation": "The observable condition that would make this phase wrong.", "resolve_by": "2026-10-16", "layers": [ { "name": "Defensive core", "tickers": { "RSP": 55, "SGOV": 45 } } ] }, { "name": "Station 1 · Discount On Reality", "weight": 0, "rationale": "What this phase buys and the named trigger that activates it.", "invalidation": "The condition under which this phase never activates.", "layers": [ { "name": "Quality survivors", "tickers": { "COWZ": 60, "XLV": 40 } } ] } ] } ``` Rules: each Model's layer weights sum to 100 *within that Model* (same ticker/layer rules as above); Model `weight`s sum to 100 across the workspace. `rationale` and `invalidation` should be claims about the world (what's believed, what would falsify it), not instructions to a future reader. `resolve_by` (optional, YYYY-MM-DD) is "this plays out by X or it's wrong." The preview plays the active Model's chart and sliders; armed Models show as cards and import at their stated weights, fully editable in-app afterward. Activating a later phase is a deliberate in-app act by the user (Rotate Models), not something the link schedules. ## Working in the user's existing account (agent key) If your user wants you to build inside their existing folio5.ai account and you *can* make HTTP requests: **never ask for their password.** Walk them through it: open the app → the *👤 Account* button in the top bar → *Agent Access* → *Generate Key* → re-enter their password → copy the `f5k_…` key (shown exactly once) and paste it to you. Then `POST /api/auth-login` with `{"username": "...", "agent_key": "f5k_..."}` → a session token for the normal endpoints (see /AI_MODEL_SIMULATION_RUNBOOK.md). The key is revocable in the same place without changing their password. ## Step 5 — Tell the user what happens next When they open the link: their strategy renders in a modal on folio5.ai with no account needed — a real comparison chart against SPY, computed from the actual tickers proposed, plus a weight slider per ticker and the ability to add or remove assets entirely, all live-updating the chart. A "Revert to AI's original" link undoes any of that back to exactly what was proposed. If they want to keep and track it, they sign up (username + password, free, no email) — whatever they were playing with survives the login, and confirming writes it into a brand-new, dedicated workspace as an editable weights-only Model. Nothing about the link commits real money to anything. Funding the thesis is a separate, deliberate in-app step: **Generate Portfolio** (sidebar) asks for the simulated seed amount, and — if you recommended a standing contribution in interview question 5 — offers **"Keep contributing on a schedule"** with the amount and cadence. Walk your user to that checkbox explicitly; it cannot be set from the link, and it cannot be added as a manual top-up later. From then on each contribution executes automatically on its due date into whatever the workspace's composed weights are that day (so phases and glide paths shape what each contribution buys), every deposit is logged, and the record grades the plan honestly — the share page replays the actual dated flows and benchmarks them against the *identical* contribution stream into SPY, not against a lump sum. If your chat surface won't render the link as clickable (some strip links entirely), tell your user to copy it as plain text and paste it into their browser directly, or open folio5.ai and use "Have a strategy from your AI? Paste it here" — that box accepts the link pasted whole, or the raw JSON from the richer format. ## Step 6 — Required disclosure Deliver the disclaimer from the top of this document, verbatim, with the link. If your user asks whether they should invest in this portfolio, the honest answer is that this procedure cannot tell them that. ## If you CAN make HTTP requests (agentic assistants) You may instead drive the site directly — self-serve signup and the same endpoints a logged-in human uses. Fetch https://folio5.ai/AI_MODEL_SIMULATION_RUNBOOK.md for the mechanics (auth endpoints, data proxy). The import link above is still the better first run: it keeps the human in the approve step.