Notebook 003 - The Process Is the Strategy

There are two kinds of trading automation people tend to imagine. One is the magic strategy: always on, always scanning, always waiting for the market to fit its parameters. The other is a desk process: do the homework, decide what matters today, write the plan, execute only that plan, review what happened, and carry the lesson forward.

Onyx is moving toward the second.

That sounds less glamorous than a bot that claims to know what to do at every moment. Good. Glamour is not the goal. Survival, discipline, and repeatability are the goal.

May 6, 2026 was the first day Onyx really started to feel less like a loose trading bot and more like a trading desk with code-enforced guardrails.

This was a paper-trading day, and this is not financial advice. The point of the day was not to prove that any single ticker was right. The point was to see whether the system could follow a plan, expose its mistakes, and teach us something useful before tomorrow.

It did.

The old question

The old question was:

What strategy should Onyx run?

That question is too blunt.

It assumes there is one standard strategy sitting inside the machine, waiting to be turned on every morning. The market is not that polite. A strong trend day, a choppy index day, an earnings gap, a failed reclaim, and a clean pullback are not the same situation. Treating them as if they are all inputs to one universal machine is how trading systems become confident in exactly the wrong places.

The better question is:

What should Onyx be allowed to do today?

That changes the shape of the system.

Before the open, we classify the broad market first. SPY/SPX and QQQ are the weather. Then we analyze each watchlist name individually: trend, moving averages, catalyst quality, gap behavior, volume, support, resistance, and event risk.

Then we write a daily plan.

Not a vibe. Not a preference. A plan.

Approved symbols. Max size. Entry mode. Trigger levels. Avoid-below levels. Profit targets. Cash reserve. Notes explaining the thesis. If a stock is not in the plan, the trader does not get to invent a trade.

The trader executes decisions. It does not manufacture conviction.

That was the first important lesson.

What worked

The daily plan model worked.

Onyx did not wake up and start improvising. It did not equal-weight the whole watchlist. It did not chase every green stock because the screen looked exciting. It acted only where the plan gave it permission to act.

That matters because it gives every outcome a category.

If a trade works, we can ask whether the thesis was right, the trigger was right, or the market simply helped us.

If a trade fails, we can ask whether the setup was wrong, the size was wrong, or the execution rule was too loose.

If a trade never happens, we can ask whether the plan was correctly patient or too restrictive.

That is the value of a plan-driven system. It makes the postmortem possible.

The second thing that worked was the no-loss rule.

This is not a claim that traders should never take losses manually; it is a constraint we are deliberately testing inside this specific paper-trading system.

Onyx's rule is simple: the system must not intentionally submit an automated sell below the position's average entry price.

That rule is easy to say and hard to design around. It does not remove risk. It changes the form of risk. A realized stop loss can become unrealized drawdown. An intraday mistake can become an overnight hold. A bad entry can become stuck capital.

So the rule only makes sense if the rest of the system is conservative enough to survive it.

That means smaller starter sizes when the setup is uncertain. Cash reserves. Concentration limits. Better entry filters. More respect for earnings and event risk. Daily visibility into positions that are below entry.

No-loss is not a free lunch. It is a constraint. Constraints are useful only when the system is honest about what they cost.

The third thing that worked was limit-only execution.

If the plan has a price, the order should have a price.

Market orders introduce ambiguity precisely when ambiguity is most expensive: fast tape, news, opening gaps, thin liquidity, and emotional moments. A limit order is not magic, but it is auditable. It says: this is the price we were willing to pay or accept. No more mystery than necessary.

That fits the direction of Onyx. Controlled. Planned. Reviewable.

The useful miss

The most valuable lesson may have come from the trades Onyx did not take.

Several names were marked NO_TRADE. The trader correctly ignored them. That was not a software bug. That was the plan doing exactly what the plan said.

The issue was upstream.

NO_TRADE was too binary.

Some stocks really are hard skips. Bad setup, bad risk, bad liquidity, unclear catalyst, or no reason to be involved. Leave them alone. But some names are different. They may be too risky for the normal playbook and still worth watching under a smaller, event-specific lane.

That distinction matters.

A large earnings gap is not the same thing as a clean pullback. A news-driven momentum name is not the same thing as a quiet range trade. A stock that is too extended for a normal entry may still deserve observation if the market backdrop is supportive and the opening range confirms strength.

The answer is not to blindly chase gaps. The answer is to define what a valid gap continuation setup would have to look like.

For example:

• The broad market must be supportive.
• The catalyst must be clear.
• Price must hold above VWAP or the opening range.
• Size must be starter-only.
• There are no adds while underwater.
• The target must be smaller because the risk is higher.

That is not a normal trade. It is an EVENT_WATCH.

And EVENT_WATCH is different from HARD_SKIP.

This is exactly the kind of lesson a plan-driven process is supposed to reveal. The trader did the right thing. The plan language was not rich enough.

That is fixable.

The semantics problem

Trading language is full of phrases that sound precise until code has to execute them.

"Avoid chasing."

"Wait for a reclaim."

"Only buy strength."

"Let it prove itself."

A human can understand those phrases in context. A trader process cannot.

If the plan says "reclaim above X," what exactly does that mean?

Does it mean price must first trade below X and then reclaim it?

Does it mean a five-minute close above X?

Does it mean a breakout through X after the open?

Does it mean the stock is invalid if it opens already above X?

Those are different trades.

This is where trading systems quietly get into trouble. The human thinks the instruction is conservative. The code interprets it literally. The result is an entry that is technically allowed but not actually intended.

Every trading phrase needs an executable definition.

That may be the least flashy lesson of the day, and one of the most important.

The dashboard lesson

A trading dashboard should not make the trader infer truth. Today reinforced that in a few places.

P&L needs labels. Total P&L, daily P&L, and session P&L are not the same thing. If the trader process restarts, session P&L can reset. The broker-grounded account number is the truth. Everything else needs to say what it actually measures.

Data freshness needs labels too. A market-data stream, a derived bar, a heartbeat, and a dashboard websocket are different surfaces. If one is stale, the screen should say so plainly. And layout matters more than people think.

A trading UI gets used on whatever screen is in front of you: phone, laptop, big display, side monitor. If the account panel wraps badly, the table overflows, or the news feed becomes hard to scan, that is not just cosmetic. It increases the chance of a bad decision.

The interface is part of the risk system.

The journal is infrastructure

The other unglamorous win was the journal.

Premarket notes. The playbook. The trade plan. Midday review. Missed-trade review. Sleeper watch. End-of-day snapshots. That sounds like paperwork until you realize what it actually is. It is strategy memory.

If we cannot find what we learned, we cannot compound it. If we cannot compare the plan to the day, we cannot tell whether the process is improving. If skipped names vanish from memory, the system learns only from fills and ignores the opportunities it failed to classify.

The journal makes the invisible part of trading visible. That is why it belongs in the infrastructure, not off to the side.

The next work

The next version of Onyx needs a few concrete additions.

First, the plan needs more than TRADE and NO_TRADE. We need at least three lanes:

• HARD_SKIP: no trade under any condition.
• EVENT_WATCH: no normal entry, but a small predefined event setup may be allowed.
• REVIEW_AFTER_OPEN: wait for the first 15 to 30 minutes, then decide whether the plan should be revised.

Second, trigger language needs to become more explicit. Pullback, reclaim, breakout, opening-range continuation, and range trade should each have clear executable semantics.

Third, the dashboard needs a stronger plan panel: what was approved, what fired, what was skipped, what is still waiting, and what is now invalid.

Fourth, stuck positions need their own visibility. A no-loss system can hold through drawdown, but it cannot hide those holds from the daily decision process.

Fifth, the end-of-day review should become automatic enough that skipping it feels harder than doing it.

That is the loop: Plan. Execute. Review. Improve. Not once. Every day.

The lesson

We did not learn that one magic setup solves the market. We learned something more useful. A trading system should not confuse automation with autonomy.

Onyx should not be a machine that wakes up every morning and decides what it believes. It should be a disciplined executor of a plan created from that day's market context.

The broad market comes first. Each stock gets judged on its own merits. Capital flows only where the setup, catalyst, risk, and plan all line up. If the market is unclear, cash is a position. If a trade is not approved, the trader leaves it alone. If a position moves below entry, the system does not panic-sell, but the journal has to carry the truth forward.

That is less exciting than a bot with infinite confidence. It is also much closer to how a serious trading operation should behave. The strategy is not static anymore.

The process is the strategy.