Notebook 017 - The Plan Stopped Being The Brain

Hermes can read the tape and make the call. The trade still has to become a ticket before it can touch money.

For the first month of Onyx, the plan carried too much weight.

That sentence sounds strange, because the whole project began with the opposite problem. The early danger was a trader that could improvise. A green screen could become a trade. A model score could feel like permission. A dashboard alert could look too much like an instruction. So the first operating rule was simple: the plan is the strategy. The trader executes the plan. Nothing outside the plan gets invented at runtime.

That boundary was necessary. It still is.

But this week exposed a more mature version of the problem. Once the plan had become the center of the desk, it started inheriting jobs that did not really belong to a static file. The plan was being asked to remember the morning thesis, rank the watchlist, encode authority, define target management, handle intraday amendments, represent market judgment, and carry the executable contract. It was not just the plan anymore. It was becoming the brain.

That was too much.

The next version of Onyx separates those jobs. Hermes is the adaptive desk brain. Onyx is the deterministic guard, broker gateway, dashboard, and audit trail. The plan still matters, but it is no longer where judgment lives.

This is a build note from a paper-trading system, not trading advice. The useful lesson is architectural: an AI desk can think in language, but capital should move only through strict, typed, validated artifacts.

The Old Shape Worked Until It Didn't

A good boundary can become the wrong abstraction when the system grows around it.

The old workflow had a clean idea inside it. Do the homework, write the daily plan, approve the plan, then let the trader execute only what the plan allows. If a symbol was not in the plan, it was not executable. If a lane did not have size, trigger, target, and safety rules, it was not executable. If the book or feed was unsafe, nothing should fire.

That design solved the first class of failures. It stopped the trader from freelancing. It made watch-only names stay watch-only. It gave the no-loss rule somewhere to live. It forced the desk to say what it meant before money moved.

But the live desk kept producing a sharper lesson. Some days, the system did not lack awareness. It saw leaders. It saw fragile tape. It saw watchlist names become more interesting. It saw that some candidates were clean enough to review and others were already too extended to chase. The journal could explain the difference.

The problem was that the active plan was too blunt a surface for all of that adaptation.

A static plan is excellent at saying what was approved before the session started. It is not naturally excellent at expressing a fast intraday decision without either rewriting too much of the plan or leaving the decision trapped in prose. The desk needed a smaller unit of authority than "the whole plan is live" and a more precise unit of action than "the model thinks this looks good."

It needed the trade to become a ticket.

Hermes Became The Desk Brain

The system got simpler when one agent owned judgment and every other surface became evidence.

On June 3, the desk simplified the human and agent side of the stack. Hermes became the single accountable desk manager. Other agents, scanners, boards, dashboards, and reports became inputs. They can surface evidence. They can disagree. They can say a name is worth attention. They cannot approve a trade by themselves.

That sounds like an organizational detail, but it matters technically. Multiple semi-authoritative readers create a fog. One agent says the market is bullish. Another says a leader is packet-ready. A dashboard says a decision is needed. A journal says the tape is fragile. If all of those surfaces feel like authority, the system becomes noisy at exactly the moment it needs to be precise.

The cleaner shape is:

Evidence -> Hermes judgment -> structured intent -> deterministic guard -> broker gateway -> receipt -> journal

Hermes owns the hard human-like parts: reading the tape, judging whether the market backdrop is broad enough or only narrow-leader friendly, deciding whether a watchlist name deserves promotion, recognizing when a move is already a chase, and explaining the call in plain English after the fact.

Onyx owns the machine-like parts: whether authority is current, whether Auto is on, whether the feed and account are fresh, whether the order is a limit order, whether cash and exposure caps pass, whether the sell side respects the no-loss rule, and whether this exact action has already been handled.

That split is the whole point. Judgment can live in Hermes because judgment is contextual. Enforcement should live in Onyx because enforcement should be boring.

The Trade Is A Ticket

The bridge between judgment and execution is not a paragraph. It is a contract.

The new unit of broker-mutating work is a TradeIntent.

That is intentionally less glamorous than "signal" or "strategy." A signal can be vague. An intent has to say exactly what it wants. It has to name the symbol, side, order type, quantity or sizing basis, limit price, expiration, authority basis, risk snapshot, evidence references, target policy, and idempotency key. It has to be specific enough that deterministic code can decide whether it is allowed.

This is the important shift: Hermes can decide, but Hermes' decision is not the thing that trades. The ticket is.

If Hermes thinks a leader deserves a fresh entry, that belief must become a valid intent. If Hermes wants to repair a target, that repair must become a target-plan update or a valid intent. If Hermes thinks the right call is to do nothing, the journal records the blocker. In all three cases, the system avoids the mushy middle where an opinion floats around the desk and everyone half-remembers it as permission.

The ticket makes the decision inspectable. It can be reviewed before execution. It can be blocked with a stable reason. It can be moved to a processed folder. It can be tied to a receipt. It can be reconstructed later when the desk asks what actually happened.

That last part matters. A trading process that cannot remember why it acted cannot improve. A ticket is not just an execution object. It is memory with a shape.

Guard Before Gateway

The money-affecting checks live in the part of the system that cannot be talked into skipping them.

The most important part of the new workflow is not that Hermes can write intents. It is that Onyx Guard can refuse them.

Guard sits between the decision and the broker gateway. It does not care how convincing the reasoning sounds if the required proofs are missing. A fresh buy without current authority blocks. Auto off blocks. Stale feed evidence blocks. An order outside exposure limits blocks. A duplicate idempotency key becomes a no-op. A sell that would violate the no-loss floor blocks. A market order shape blocks.

This is where agentic trading systems either become interesting or become dangerous. If the language model can both make the argument and waive the rule, the rule is not real. In Onyx, the argument and the rule live in different places.

Hermes can say, "This is the cleanest leader." Guard asks, "Is there authority? Is Auto on? Is the book safe? Is the order shape allowed? Are the caps respected? Is the sell side above entry? Is the evidence fresh? Have we already acted?" Only if those checks pass does the broker gateway get a chance to do anything.

That means the system does not have to pretend Hermes will never be wrong. It assumes Hermes will sometimes be early, late, overconfident, too cautious, or missing a piece of context. The design goal is not perfect judgment. The design goal is bounded judgment.

Hermes can be wrong. Guard should make wrong cheap.

The Day Proved The Boundary

The most useful trading lessons are often the ones where the system does almost nothing.

The June 3 session was not a clean victory lap. It was a good stress test.

The desk had one approved fresh action that became a real position because it had explicit authority and a paired above-entry target. That is the easy story: a plan-backed action moved through the workflow and became target management when price later faded.

The more useful story is what did not happen.

Several leaders surfaced during the day. Some had enough evidence to deserve attention. Some had already moved too far from the clean entry zone. Some were interesting only if they reset. Some needed a current target, avoid level, volume check, market confirmation, or no-chase cap before they could become executable. The desk could see them. The dashboard could surface them. The journal could explain them.

But awareness is not authority.

That line is becoming one of the central laws of Onyx. A watchlist leader is not a trade. A packet is not a trade. A dashboard alert is not a trade. A strong score is not a trade. Even Hermes thinking "this is the one" is not a trade until the decision becomes a valid ticket and Guard allows it.

That boundary prevented broad chasing into a tape that looked constructive in some places and fragile in others. It also exposed the next design gap: some opportunities still need faster ticket construction while the entry is clean. The answer is not to let the trader improvise. The answer is to make the ticket path fast enough that a valid idea does not expire in prose.

The Dashboard Is Not The Brain Either

The screen should make the next decision visible, not quietly become the decision-maker.

The dashboard changed with the architecture.

Its job is to show truth: account state, position state, target coverage, current mode, feed health, watchlist context, news, pending profit, and whether the desk posture is target management, live, blocked, or review-required. It should help Hermes see what matters. It should not imply that a button, badge, or alert has authority by itself.

This is a subtle but important user-interface lesson. A dashboard can accidentally become a source of permission if it looks too actionable. A bright label can feel like a recommendation. A workflow card can make a review prompt feel like an approval prompt. A candidate panel can make "interesting" look like "allowed."

The new architecture keeps the dashboard in its lane. It can show the packet. It can show that the packet is read-only. It can show the last intent verdict. It can show the blocker. It can make the system harder to misunderstand.

But it does not approve the trade.

The approving surface is the authority workflow. The executable surface is the intent. The enforcing surface is Guard. The dashboard is the window.

The Plan Still Matters

Removing the plan from the center does not make it optional.

It would be easy to misread this change as a move away from planning. It is not.

The plan still matters. Premarket homework still matters. The Investment Quality Board still matters. The watchlist still needs roles, contingencies, target management, and hard avoids. The book still comes first. The no-loss rule still governs exits. The desk still needs a morning thesis and an after-market review.

What changed is that the plan is no longer asked to be every layer at once.

The plan is context. It is constraint. It is the morning contract. It tells Hermes what the desk intended before the tape started changing. It can anchor target management and define what kind of risk is allowed. But when a live decision needs to mutate broker state, the decision should become a smaller, stricter object.

That is healthier. It lets the plan stay readable. It lets Hermes adapt without rewriting the whole desk. It lets Onyx validate one requested action at a time. It also makes misses cleaner to review. Was the candidate never in the plan? Did Hermes reject it? Did Hermes write an intent too late? Did Guard block it? Did the broker gateway submit it? Did the target get paired? Each question has a place to look.

That is how a desk learns.

The Lesson

An AI trading desk should not be a model with broker access. It should be a judgment layer surrounded by contracts.

The plan stopped being the brain because the desk outgrew that shortcut.

At first, making the plan central was the right move. It stopped freelancing. It made authority explicit. It forced the trader to wait for permission. It turned chaos into a daily process.

Now the system needs a sharper separation. Hermes reads the tape. Hermes judges the candidates. Hermes decides when cash is patience and when cash is drag. Hermes can say a leader deserves action, a move is already missed, a plan should stay target-management-only, or a blocker needs our attention.

But Hermes does not get to turn language directly into money.

The decision has to become a ticket. The ticket has to pass Guard. The broker gateway has to return a receipt. The journal has to remember what happened. If any part of that chain breaks, the safe action is no action.

That is the architecture we are moving toward: not a smarter bot, not a looser plan, and not a dashboard that trades because it sees something interesting.

An accountable desk brain. A strict intent contract. A boring guard. A narrow gateway. A journal that remembers.

The plan still matters.

It just stopped pretending to be the brain.