The portfolio manager

The PM (shown as Analyst on screen) decides what your book should hold and writes proposals with a thesis attached. It never places an order: the Executor checks every proposal against your limits and, above your approval line, hands it to you. Every session is a fresh context with a fixed budget; nothing carries over except what earlier sessions wrote down.

Owns

Trade proposals, position theses, watch items, the journal, lessons

Reads

Its state card: last outcomes, Critic findings, your steering, risk headroom, the brief, signals, its memory

Tools

Market data, news, filings, signals, prior decisions, the proposal preview, memory; no broker tool, shell, file or network

Model

Fable 5.1 premarket and postmarket; Sonnet 5 intraday and react

Cadence

08:00, every 60 minutes 09:00–⁠14:30, 15:15 CT; react sessions on events, at most 12 a day

Change it at

Portfolio Manager › Configure: model per session type, fallback, effort, turns and budget per session (raising a cap asks for your code), intraday on/off, the interval and the intraday model

Hands off to

The Executor (proposals); the Critic reviews every session that proposed; the next session inherits its memory

Judged by

Your rejections and their reasons, the Critic's findings, and the postmarket review of every thesis

What it owns and reads

The PM owns the book's intent: every proposal, thesis, watch item, journal entry and lesson. It reads only what the state card and its tools give it; memory is an input, tool data is truth.

Tools

One allowlist: market data, the calendar, news, filings, fundamentals, movers, the research feed, screen_universe (the nightly universe screens: top or bottom names by momentum, RSI(2), gap, volume surge and more, over what this book could actually trade), factor scores, the regime, algorithm signals, prior decisions, earlier briefs, its own transcripts, the proposal preview, watch_level and memory. Nothing on it touches the broker. A react session is served a narrower row of the same list (no memory_write, for one), and the list a session is served, the list the model is allowed and the list the recorder accepts are kept identical by a test, so a tool named in the role's spec but not served cannot exist.

Sessions

Premarket and postmarket run on Fable 5.1 ($5.00 and 40 turns per session), intraday on Sonnet 5, react on Sonnet 5 with $0.40 and 8 turns (a deployment can set the react budget anywhere up to $0.75; the 12-a-day cap and the book's daily model budget bound the total). The model per session type, fallback, effort, turns and budget per session, intraday on or off, the interval (15, 30 or 60 minutes) and the intraday model are yours to set on Portfolio Manager › Configure; lowering a cap is one click, raising it again asks for your code. On a quiet tape an intraday slot after the first may be skipped. See Model policy.

The state card

Each session opens with a state card, assembled so what needs a response comes first: what became of its last decisions (accepted, rejected and why, filled, expired, awaiting you); open Critic findings; your steering notes, verbatim; the wake reason or your question; book and risk headroom; today's brief, flagged when stale; the algorithms' votes; and its memory index.

What a proposal contains

A proposal is a ticket: symbol, side and quantity; a limit price (premarket, a peg to the open with a cap it will not pay past); a thesis with an explicit invalidation and a stop suggestion; confidence and horizon; the tool outputs it relied on. The PM previews the draft with propose_orders, which runs the Executor's risk checks, and is told not to argue with a failed check. Proposals also carry an action (tighten a stop, move a target, re-price or cancel a resting order, scale out or close), and a stop only ever tightens. A cancel may also name an order that has not reached the broker yet (parked for tomorrow by the 14:48 pass, queued for the window, or waiting for you): the Executor then withdraws it, the proposal closes as rejected with a "withdrawn by analyst" note, and nothing is sent. That is how the premarket session drops a parked order whose thesis broke overnight. On scheduled macro days (CPI, FOMC) the PM halves a starter rather than standing aside; a blanket "no new longs this week" is your call through a steering note, not something it imposes on itself. When it does state a short-dated rule of its own, that rule is recorded in its handoff with an end date (at most five trading days out) and shown as "Constraints in play (self-imposed)" so the next session and you can see it.

Structured memory

Continuity is typed state, not a transcript: theses with invalidation and review dates, watch items with machine-checkable triggers, open threads, a handoff to the next session, lessons and the journal, plus scratch notes written with memory_write into the database, never to a file system. See reading the mind card.

What the PM remembers, and what it never learns from

Memory is lived experience, not imported evidence. The PM's lessons, theses, journal and handoffs record only this book's own operation: its decisions and what became of them, your steering and rejections, and the Critic findings it answered. Two rules follow, both enforced in code rather than asked for in a prompt.

• Lessons are per-agent and self-curated. The PM writes and retires only its own lessons; the Researcher keeps its own notes on sourcing and calibration under its research namespace and cannot write a PM lesson, thesis, watch item or regime note; anything PM-owned that another role hands back is dropped with a warning, never stored. No screen, script or other role inserts a lesson for the PM either. Others influence it only through channels it must acknowledge: Critic findings, your rejections and steering notes, and (when the Quant lands) accepted Quant findings. What to encode as a lesson is the PM's call, and a lesson that tool results contradict is retired in the same session, not carried silently.
• Evidence stays evidence. Backtests, Lab and simulation runs, the evidence pack's numbers and Quant findings are for you and for the Quant; they are never written into PM memory. A language model has read the years a backtest replays, so "learning" from simulated outcomes would teach it its own hindsight. When the Quant role lands, its findings reach the PM as a labelled, read-only "Quant desk" section of the state card and as Inbox cards you accept (accepted ones become configuration, not lessons), and a durable finding may be offered to you as a Playbook line, which you write and the PM must acknowledge. That state-card section and the offer are decided and not in this build yet; the rule that nothing imports into lessons already holds.

To read what the PM currently holds as standing lessons, press State card on Strategy › Guidance: it renders the card the next session will read, lessons included. Consult remembers only your stated preferences, and the Critic writes findings, never memory.

Steering is never optional

Every note on Strategy › Guidance appears in the card, and the PM must acknowledge each one: applied, not applicable, or disagree with a reason while still complying. A hard-constraint note is also compiled into an Executor rule. See playbook vs steering.

What it cannot do

Place, modify or cancel an order at the broker, move money, run a command, write a file or fetch a URL. A tool off the allowlist is denied and recorded. It cannot change a limit, your posture or your autonomy.

How it hands off

A proposal is a row the Executor picks up on its next 5-second tick, no earlier than the proposal's window opens; a premarket idea stays valid until 14:30 CT, an intraday one for at least 90 minutes and never into the last 15 minutes. The PM learns the verdict, fill or expiry at its next session. The Critic reviews each session that proposed, right after it ends, and gives a new-position buy or a $250 add a fast look before the Executor sees it. The journal, theses and handoff note are what the next session wakes up to.

How it is judged

By outcomes and by review: your rejections with reasons, the Critic's findings it must answer, the postmarket review of every thesis and the day report's anomalies. Lessons that prove out are promoted; the rest are retired.

Why a trade happened

Open Agent and pick the session from the day's timeline. While a session is still running its page opens on Live: the session narrating itself in plain words, newest line first, the same stream the Overview's mind card shows (what it is reading, which names it is checking, when it drafts, what it decided). Reasoning is the session's own account, with the thinking interleaved with the tool calls; Proposals shows each order with the Executor's verdict (Agent › proposal checks opens the per-check result; the first failure wins); Tool calls is exactly what it looked at, in order. Critic shows the findings and the PM's answers. The order and fill are on Activity; anything waiting for you is in the Inbox.

Failure modes you might see

• Nothing proposed: normal on a quiet day; the reasoning says why.
• Rejected · policy: a check failed when the Executor ran it for real; the card names the check.
• Not placed: price moved. On approval the Executor re-quotes; if the price has run more than 2% past the proposal's limit (or past its own cap) nothing is placed and the next session is told to re-propose.
• Sent back once: a response that skipped a steering note or a Critic finding is asked for again in the same session. A note still unacknowledged fails the session; a finding still unanswered is counted as ignored and reported. React sessions must acknowledge steering like any other but are not sent back over Critic findings; the next scheduled session answers those.
• Stopped at its cap: a session that hits its dollar or turn cap ends there; the next one picks up the handoff.