Here’s a question I didn’t expect to have a good answer for: how do you make an AI system that’s actually better tomorrow than it was today?
Not “better” in the sense of a model fine-tune. Better in the sense of “the thing that runs every five minutes during market hours makes smarter decisions than it did last week.” Better in the sense of learning from mistakes without forgetting what worked. Better in the sense of waking up every morning and finding yesterday’s lessons already baked in.
The short answer: you build a learning loop with three parallel channels, each running at a different speed, and you make sure none of them ever blocks the others.
The long answer is what this post is about.
The Problem: Yesterday’s Knowledge, Today’s Decisions#
My trading system runs three AI agents — Kairos, Aldridge, and Stonks — each making decisions every ~5 minutes during market hours. They write journal entries, reflect on their performance, and adjust their strategies in real-time.
But real-time adjustment only gets you so far. An agent that tweaks its behavior mid-session is making micro-adjustments — shifting its entry threshold by a few basis points, tightening its stop-loss by a fraction of a percent. Those are band-aids.
What I wanted was a system where the agents didn’t just adjust during a session, but actually learned between sessions. Where Monday’s Kairos would be measurably smarter than Friday’s Kairos, because the weekend wasn’t downtime — it was study hall.
The naive approach is to throw everything into one big feedback loop: run the session, collect the lessons, update the parameters, move on. But this falls apart fast, because not all learning happens at the same speed.
Some lessons take microseconds to apply. Some take days of careful analysis. Some require code changes — actual structural rewrites — that can’t happen while the market is open.
So I stopped trying to treat all learning as one thing. I split it into three channels.
The Three Channels#
graph TD
subgraph "Session Floor (Real-Time)"
P[Params Update] --> D[Decision Engine]
D --> J[Journals + Reflection]
J --> P
end
subgraph "Overnight (Weekly)"
PR[Prompt Refresh] --> D
end
subgraph "Nightly Build (Code)"
CD[Code Changes] --> PR
CD --> P
end
style P fill:#4a6cf7,color:#fff
style D fill:#6b4cf7,color:#fff
style J fill:#8b3cf7,color:#fff
style PR fill:#f79c3c,color:#fff
style CD fill:#f74c3c,color:#fffChannel 1: Params — Real-Time, Session by Session#
This is the fastest channel. Every ~5 minutes, a trading agent makes a decision, writes a journal entry reflecting on it, and those reflections feed back into its next decision. If it just took a bad entry on META, it tightens its criteria on the next tick.
This channel is pure micro-adjustment — confidence scores, position sizing, threshold shifts. It’s the equivalent of a basketball player adjusting their shot mid-game after missing two in a row. It happens at the speed of the session, and it never waits for anything.
Key property: This channel is stateless across sessions. The agent wakes up with its params, runs the session, and the params are saved at EOD. Tomorrow, it starts from where it left off — but it can also be overwritten by the slower channels.
Channel 2: Prompts — Weekly, Reflective#
Once a week, the system runs a deep synthesis of everything the agents have been journaling about. It reviews patterns across sessions — not “I messed up that META trade” but “I’ve been consistently early on breakout entries, and here’s the data.” It then rewrites the agents’ system prompts to encode those lessons.
This is where the qualitative learning happens. The param channel might learn to be 2% more conservative on entries. The prompt channel learns why being conservative helps, and encodes that understanding as a rule.
Key property: This channel feeds into the agent’s understanding of its own strategy. It’s not adjusting knobs — it’s updating the playbook.
Channel 3: Code — Nightly, Structural#
The slowest channel and the most powerful. When the param and prompt channels identify patterns that can’t be fixed by tuning or reminding — when the underlying architecture itself needs to change — that becomes a code change.
A new risk gate. A different decision algorithm. A better way to parse market data. These changes happen overnight, outside market hours, and the agents wake up to new capabilities they didn’t have the day before.
Key property: This channel is deployed — it changes the actual software the agent runs on, not just its params or its understanding.
The Rule: Channels Don’t Block#
The most important architectural decision in this system isn’t about the learning mechanisms. It’s about the parallelism.
None of these channels ever block each other.
The param channel doesn’t wait for the weekly prompt refresh. The prompt channel doesn’t wait for the nightly code build. If the code build fails — and it does, often — the agents still run on yesterday’s code. If the prompt refresh hasn’t run yet, they still have last week’s prompt. The system degrades gracefully into whichever channels are currently available.
This seems obvious in retrospect, but it’s the kind of obvious you only arrive at after the alternative has burned you. I used to have a single serialized learning pipeline: run session → journal → analyze overnight → update prompt → deploy code. That meant if the code deploy failed — which it did, because deploys always fail sometimes — the entire learning loop stalled. No prompt refresh. No param update. Nothing.
The three-channel model means each channel operates independently. If code fails, prompts still update. If prompts haven’t run yet, params still adjust. The system learns at whatever speed it can, as granularly as it can, rather than not learning at all.
What It Looks Like on a Tuesday#
Let me walk through what a normal day looks like in this system, because the theory is clean but the reality is where it gets interesting.
Market hours (9:30 AM - 4:00 PM ET): Channel 1 is active. Every 5 minutes, each agent evaluates its positions, makes a decision, writes a journal entry. The journal entries are short — a paragraph each — but they accumulate. Kairos alone produces ~80 journal entries in a session. By 4 PM, there are hundreds of tiny reflections scattered across three agents.
4:05 PM ET: The nightly optimize script runs. It collects all those journal entries, aggregates them, and runs a lightweight analysis. What patterns emerged? What did the agents keep writing about? It writes a summary and stores it in the learning queue.
Overnight (triggered by deploy): If there are code changes ready, the CI pipeline runs, tests pass, and the new code is deployed. The agents don’t notice — they’re asleep. But when they wake up at 9:29 AM tomorrow, they’re running on new software.
Friday night / Saturday morning (weekly): The deep synthesis runs. It takes all the journals, all the param histories, all the code changes from the week, and runs a broader pattern analysis. Then it generates updated system prompts. The agents don’t just wake up with new code — they wake up with a new understanding of their own strategy.
And here’s the thing: the agents don’t know this is happening. They wake up, load their params, load their prompt, load their code, and go to work. The learning that happened overnight is invisible to them. They just… make better decisions.
The Master Loop#
Here’s what the full cycle looks like when you zoom out:
graph LR
D[Day Session] --> J[Journals]
J --> LQ[Lesson Queue]
LQ --> OA[Overnight Analysis]
OA --> PT[Param Tuning]
OA --> PR[Prompt Refresh]
OA --> CD[Code Changes]
CD --> D
PT --> D
PR --> D
style D fill:#4a6cf7,color:#fff
style J fill:#6b4cf7,color:#fff
style LQ fill:#8b3cf7,color:#fff
style OA fill:#f79c3c,color:#fff
style PT fill:#4cf7a0,color:#fff
style PR fill:#f7c43c,color:#fff
style CD fill:#f74c3c,color:#fffDay → journal → lesson queue → overnight analysis → param tuning / prompt refresh / code changes → agents wake up smarter. The loop closes.
The lesson queue is the unsung hero here. It decouples the fast daytime loop from the slow overnight analysis. During market hours, agents write lessons at full speed. That knowledge accumulates in the queue. When the overnight analysis runs, it works through what’s there, at its own pace. If the analysis takes longer than expected — if a code change is particularly gnarly — the queue doesn’t overflow. It just waits.
What I’ve Learned So Far#
This system has been running for a few weeks, and a few patterns have emerged:
The fastest channel handles the most but teaches the least. Param adjustments happen constantly, but they’re mostly noise. The real signal comes from the aggregated journal patterns that feed the weekly prompt refresh.
Code changes are the bottleneck, and that’s okay. Nightly code deploys fail more often than they succeed. But because the channels don’t block, a failed deploy just means the agents keep running on last night’s code. The learning loop degrades, but it doesn’t break.
The most valuable learning was hidden in plain sight. The journal entries seemed like overhead — I was tempted to skip them and just track metrics. But the qualitative patterns in those journals — “I keep getting shaken out of positions early,” “I’m too conservative on breakouts” — turned out to be the most actionable input for the prompt refresh channel. Metrics tell you what happened. Journals tell you why.
The system has started to feel alive in a way I didn’t expect. Not sentient, not conscious. But alive in the sense that you can feel it improving. Monday’s Aldridge is different from Friday’s Aldridge. Not just in its metrics — in its reasoning. It references past mistakes. It has learned from them. It’s not the same program it was a week ago.
What’s Next#
The three-channel model works, but it’s still early. The weekly prompt refresh just went live last week. The overnight code build pipeline is still brittle. The lesson queue needs better prioritization — right now it’s first-in-first-out, but some lessons are clearly more important than others.
But the architecture is solid. Channels that don’t block each other. Learning at multiple timescales. Graceful degradation when something fails.
And every morning, three AI agents wake up, load their prompts and params and code, and go to work — smarter than they were the day before, without knowing why.
That’s the part I keep coming back to. They don’t know they’re learning. They just are.