Building a Trading Journal and Performance Review System With AI Makler and User Lists

Every trader needs a journal. It's the only way to know what works, what doesn't, and how to improve. AI Makler remembers its own decisions in memory, but a persistent journal in User Lists gives you something more: queryable history, sorting, filtering, trend analysis, and the ability to track outcomes against decisions.

This article shows how to build a complete journaling and performance review system around AI Makler.

Why Journal AI Makler's Decisions?

Benefit	What it enables
Track accuracy	Compare decisions to actual outcomes
Identify patterns	When does the agent perform best? Worst?
Build confidence	See historical certainty vs. actual results
Optimize parameters	Which investorType + instrumentTypes combo works best?
Audit trail	Full record of every decision made

Architecture Overview

AI Makler Output ──→ User List "Trading Journal"
                        ├── Every decision logged here
                        ├── Results updated retrospectively
                        └── Queryable for performance reports
    
[Weekly Report Workflow] ──→ Query Journal → Analyze → Report

Step 1: Create the Journal User List

In the Profile → Lists tab, create a new list called "Trading Journal" with these columns:

Column Name	Data Type	Description
timestamp	text	ISO timestamp of the decision
symbol	text	Instrument symbol
action	text	buy, sell, close, hold
entry_price	text	Price at decision time
target_price	text	Price target (if set)
stop_loss	text	Stop loss level (if set)
certainty	text	Confidence percentage
investor_mode	text	aggressive/moderate/conservative
market_state	text	Market conditions at decision time
reason_summary	text	Short summary of the reasoning
actual_outcome	text	pending, won, lost, breakeven
actual_pnl	text	Final P&L (filled after outcome)
notes	text	User notes for manual review

Step 2: Log Decisions After Each AI Makler Run

After AI Makler executes, connect a User Lists → add_row worker to log each order:

[Schedule: every 4h]
  → [Fetch Data + News]
  → [AI Makler: decision]
  → [For each order in AI Makler output:]
    → [User Lists: add_row to "Trading Journal"]
  → [Continue with execution...]

graph LR
    S[Schedule 4h] --> FD[Fetch Data + News]
    FD --> AM[AI Makler]
    AM --> F{For each order}
    F --> UL[User Lists<br/>add row to Journal]
    UL --> EXEC[Execute Order]

Each row in the journal captures:

timestamp	symbol	action	entry_price	certainty	market_state
2026-06-21T08:00	BTCUSD	buy	$86,520	75%	Bullish breakout
2026-06-21T08:00	ETHUSD	hold	—	70%	Neutral
2026-06-20T12:00	SOLUSD	sell	$148.20	65%	Bearish momentum

Step 3: Update Outcomes Retrospectively

After a trade plays out, update the journal row with actual results. This can be done manually or through a second workflow:

[Schedule: daily cleanup]
  → [Query Trading Journal: actual_outcome = "pending"]
  → [For each pending row:]
    → [Fetch current price for symbol]
    → [Calculate: did price reach target? hit stop? still open?]
    → [Update row: actual_outcome + actual_pnl]

# Logic for outcome calculation
if current_price >= target_price:
    outcome = "won"
elif current_price <= stop_loss:
    outcome = "lost"
elif abs(pnl_percent) < 0.5:
    outcome = "breakeven"
else:
    outcome = "open"  # still in position

After a few weeks, your journal will show which decisions were profitable:

symbol	action	certainty	entry	target	stop	outcome	pnl
BTCUSD	buy	75%	$86,520	$89,000	$84,000	won	+2.9%
ETHUSD	hold	70%	—	—	—	won	+1.2%
SOLUSD	sell	65%	$148.20	$140.00	$155.00	won	+5.5%
BTCUSD	buy	60%	$84,500	$88,000	$82,000	lost	-2.9%

Step 4: Performance Review Workflow

Create a weekly review workflow that queries the journal and generates a performance report:

[Schedule Trigger: every Monday 09:00]
  → [User Lists: query "Trading Journal"]
  → [DSL Filter: "timestamp gte last_monday"]
  → [Python Exec: Calculate Stats]
    → Total signals: 12
    → Won: 7 (58%)
    → Lost: 3 (25%)
    → Breakeven: 2 (17%)
    → Average certainty won: 72%
    → Average certainty lost: 62%
    → Best symbol: BTCUSD (4-1 record)
  → [Format Report as Markdown]
  → [Telegram Notify: Weekly Performance Summary]

Performance Metrics to Track

Metric	Formula	What it tells you
Win Rate	won / (won + lost)	Overall accuracy
Avg Certainty (Won)	Avg certainty of winning trades	How confident when correct
Avg Certainty (Lost)	Avg certainty of losing trades	Overconfidence on losers?
Best Symbol	win_rate by symbol	Where does agent perform best
Best Mode	win_rate by investor_mode	Which profile works best
Avg P&L	total_pnl / total_trades	Profitability per trade

Step 5: Let AI Makler Review Its Own Performance

The ultimate feedback loop — use the performance report as additional context for AI Makler's next run.

[Weekly Performance Report]
  → [Feed report as a "news" item to AI Makler]
  → [AI Makler considers its own track record]
  → [Adjusts decision-making accordingly]

In the news field, pass:

=== YOUR RECENT PERFORMANCE ===
Last 7 days: 7 won / 3 lost / 2 breakeven (58% win rate)
Best performing symbol: BTCUSD (4-1)
Average certainty on winners: 72%
Average certainty on losers: 62%

The agent can then adjust — e.g., if it notices it's been too aggressive on low-certainty trades, it can raise its threshold.

Complete Daily Workflow

Here's the full daily trading + journaling workflow:

1. Schedule Trigger: Every 6 hours (00:00, 06:00, 12:00, 18:00)
2. Fetch Price Data: BTCUSD, ETHUSD, SOLUSD (4h timeframe)
3. Fetch Technical Indicators: RSI, MACD, Volume
4. Fetch Latest News: Crypto RSS feed
5. AI Makler: Decision mode
   ├── Returns: results, orders, marketState
   └── Memory: auto-saves with timestamp
6. Condition: ordersCount > 0?
   ├── Yes → For each order:
   │   ├── User Lists: add_row to "Trading Journal"
   │   │   (timestamp, symbol, action, entry, target, stop, certainty, marketState, reason)
   │   └── Run Workflow "Execute Trade"
   └── No → Log "No signals this session"
7. Log session summary to "AI Makler Sessions" list

Weekly Review Workflow

1. Schedule Trigger: Every Monday 09:00
2. User Lists: query "Trading Journal"
3. DSL Filter: "timestamp gte last_monday AND action ne hold"
4. Python Exec: Calculate performance metrics
5. Format Results: Create markdown report
6. Telegram Notify: Send weekly summary
7. AI Makler: Analysis mode
   ├── Input: "news" contains the performance report
   └── Output: Recommendations for improvement

Memory + Journal = Complete System

AI Makler's built-in memory (MongoDB) and User Lists (the journal) work together:

Component	What it stores	Benefit
AI Makler Memory	Market state, analysis, decisions	Agent remembers context across runs
User Lists Journal	Structured, queryable trade records	You can filter, sort, and analyze
Both	Full audit trail	Review and improve over time

The memory gives the agent context for better decisions. The journal gives you the data to validate the agent's performance.

Dashboard Integration

Create a Dashboard widget that queries the Trading Journal and displays:

• Win rate gauge — visual bar showing win/loss ratio
• Performance by symbol — bar chart of P&L per symbol
• Certainty vs. Outcome — scatter plot showing if higher certainty correlates with wins
• Recent decisions — table of the last 10 signals

This turns your journal into a live performance dashboard.

Getting Started

1. Create the "Trading Journal" User List with the columns above
2. Add a User Lists worker after AI Makler in your workflow
3. Run for 1 week to collect data
4. Build the weekly review workflow
5. Review the first performance report
6. Iterate — adjust parameters based on results

Legal Disclaimer

Past performance does not guarantee future results. Trading involves substantial risk of financial loss. This journaling system is a tracking and analytics tool — it does not constitute financial advice.