Paper — every trading figure here (positions, orders, P&L, equity, returns) is simulated on an Alpaca paper account. No real capital is at risk, and no order is ever placed with your money. Running costs shown under ops, such as LLM spend, are real.
Systematic paper-trading intelligence · UK operator today · Design-partner beta next
Read where the market is most likely to turn —
then trade the win rate.
A different question from most trading tools: not which stock to buy or which person to copy, but where in the market a recovery is most likely right now. We read the macro regime, the business cycle, and volatility together — long-only, sector-aware, self-stopping. The 6-layer funnel below decides what to trade and when to stop.
SentinelHub is a two-plane system. The engine is the only thing that places trades: it spots market dislocations, authors a Recovery Thesis for each beaten-down sector, waits for reversal confirmation, then enters bracket-protected positions under a fail-closed gate stack. The intelligence layer — a team of nine specialist AI agents, traced end-to-end — lets you observe, ask why, and configure. It never executes. The edge is not a smarter model: it is statistical persistence across many small wins, with every decision fully auditable.
Avg self-directed retail return vs S&P 500
Illustrative · cumulative gap under benchmark
The problem
500M retail traders.
Most lose money.
Discipline doesn't scale.
Nine specialist agents
Analyse · Validate · Execute · Reflect
Already running
Equity
—
Alpaca paper
Open positions
—
live · broker truth
Decisions logged
—
MongoDB Atlas
Tools traced
—
Phoenix OTel
Phase roadmap
01
Validation
Today
02
Social paper trading
Q3 2026
03
Live execution
2027+
Trading agents that
watch themselves trade
— and get better.
SentinelHub
The Problem
Retail traders lose money systematically
- →Trade emotionally — buy high on FOMO, sell low on panic.
- →Ignore risk — no stop-losses, no position sizing, no drawdown limits.
- →Can't access institutional tooling — quant tech costs millions.
- →Copy people, not strategies — eToro lets you mirror a personality with no logic visibility, no audit, no risk controls.
The Solution
A platform where AI does the discipline
- ✓Auditable AI strategies — every decision logged with confidence score, factor breakdown, and skip reason.
- ✓Institutional risk by default — bracket orders, heat caps, drawdown circuit breakers from the first trade.
- ✓Self-improving agents — they query their own Phoenix traces and propose parameter refinements.
- ✓Copy strategies, not personalities — verifiable rules, transparent risk parameters, statistical track record.
Architecture
Two planes — one executes, one explains
Keeping execution and intelligence separate is what makes the system both powerful and auditable. The split follows the Renaissance approach: non-deterministic judgment for universe selection; deterministic rules for money-touching mechanics.
The Engine · sentinel/
The only thing that places real orders
- →Unattended daemon — runs market hours, survives reboots.
- →Dislocation → Recovery Thesis pipeline: daily positioning scan + intraday entry evaluation (09:45 ET open, then every 30 min to 15:30 ET).
- →Deterministic execution only — entry price, stop, size are pure rules. AI never touches trade mechanics.
- →Writes a decision log (the audit trail) for every scan — the corpus SentinelHub reads.
SentinelHub · app/
Intelligence, observability & configuration — never execution
- ✓Nine Gemini agents read the engine's corpus and answer questions in natural language.
- ✓Arize Phoenix traces every agent call — every decision is auditable and replayable.
- ✓Reflection agent proposes gated parameter refinements; the operator approves, it doesn't auto-apply.
- ✓Hard guardrail: the intelligence layer never submits a live order. That boundary is the safety guarantee.
The trading philosophy
Many small wins, never one big bet
Most "AI trading" demos promise a big win on a few hero trades. SentinelHub does the opposite. The focus is not profitability on any one call — it is the win rate across hundreds of small, disciplined trades. Get the market opportunity right, size every position for survival, and let the odds compound.
Target trade size
$20 – $100
Per closed trade. Sized so the platform can carry many positions without any single one deciding the month. The math relies on win-rate persistence across 100+ trades, not on being right today.
Risk per trade
≤ 1% equity
Bracket orders submitted atomically with every entry — entry + stop-loss + take-profit, never a naked position. Heat-cap, drawdown breakers, and correlation guards layered on top.
Survival before returns
Process > Outcome
We accept many small losses to capture the statistical edge. Capital preservation outranks any single trade. If a strategy needs convincing to fire, the confidence score is too low — skip it.
How it works
Position once, execute on confirmation, reflect every day
Once each morning the engine reads the world and authors Recovery Theses. Six times per session it evaluates those theses and executes deterministically on confirmed reversals. End of day it reflects. The intelligence layer — nine Gemini agents traced in Arize Phoenix — lets you observe and ask why. Trading is automatic; observation is optional.
Position
Once daily (09:15 ET): the Dislocation Researcher reads macro, geopolitics, and sentiment — authors a Recovery Thesis per dislocated sector.
Track
Each thesis accumulates daily snapshots. Trajectory moves DETERIORATING → STABILIZING → REVERSING. No entry until reversal is confirmed.
Assess
On confirmation: the 8-factor confidence model scores the signal. Data freshness is gate ①; a HALT here cancels the scan.
Risk Check
~14 fail-closed gates: confidence threshold, heat cap, drawdown breakers, per-segment concentration, bracket atomicity.
Execute
Bracket order placed atomically: entry + stop-loss + take-profit. AI never sets the numbers — pure deterministic rules.
Reflect
End of day: outcomes attach to theses; the reflection agent attributes and proposes gated parameter refinements.
Multi-agent orchestration
Specialist agents, two model tiers
Reasoning-heavy agents — those that synthesise, judge, or create — run on gemini-flash-latest (FAST tier). High-volume, narrowly-scoped work runs on gemini-3.1-flash-lite-preview (LITE tier) for cost efficiency. The live tool counts and agent topology below come from the running system — not hardcoded numbers.
| Agent | Role | Model Tier | Tools |
|---|---|---|---|
| sentinel_hub | Orchestrator — routes work to specialists | FAST | — |
| — | — | — | — |
| — | — | — | — |
| — | — | — | — |
| — | — | — | — |
| — | — | — | — |
| — | — | — | — |
| — | — | — | — |
| — | — | — | — |
Active integration partners wired into the agent tree
Three core integrations + Firebase Auth
Google Gemini (reasoning), Arize Phoenix (observability), and MongoDB Atlas (persistent memory) are the three load-bearing integrations. Firebase handles authentication. The differentiation is the orchestration that connects them, not any single component in isolation. Fivetran was evaluated and de-focused; Elastic Cloud and Dynatrace were removed outright. The stack is intentionally narrow.
Google Cloud · Gemini
FoundationHow we use it
All nine specialist agents run on Gemini through the Agent Development Kit (ADK). A tiered model strategy routes reasoning-heavy work to a higher-capability tier and high-volume, narrowly-scoped work to a faster, lower-cost tier.
Why valuable
Tiered model strategy gives us institutional reasoning at consumer-tier latency and cost. ADK provides the orchestration foundations — tool routing, function calling, structured output — without building it from scratch.
— agents · — tools · ~42 LLM calls/day · all traced
Arize Phoenix
CoreHow we use it
Automatic instrumentation captures every agent call, tool invocation, and token used. Five native monitoring widgets are embedded directly in the monitoring page. The system queries its own traces to detect drift and propose parameter refinements — the self-improvement flywheel.
Why valuable
Every decision becomes auditable, queryable, and replayable. Without this layer the agents are opaque; with it they are introspectable — the prerequisite for getting smarter over time.
Live tracing · 5 monitoring widgets · evaluator harness designed
MongoDB Atlas
CoreHow we use it
Persistent agent memory across decisions, snapshots, outcomes, sentiment, briefings, and strategies. Powers historical context queries ("what happened the last 5 times in this regime?") and real-time roll-ups (win-rate by sector × regime).
Why valuable
Without persistent memory, agents are amnesiac — every session restarts cold. This turns ephemeral reasoning into a compounding knowledge asset that gets richer with every trade.
Live document corpus growing daily
Other building blocks
The rest of the stack
Outside the sponsor program, these third-party capabilities round out the platform — broker execution, macro data, sentiment ingestion, and the multi-tenant infrastructure scheduled for Phase 2.
Alpaca Markets
LivePaper trading execution — bracket orders with broker-side stops
yfinance + Alpaca VIXY
LiveMacro signal: VIXY proxy ETF for VIX, treasury yield curve via yfinance (5Y/10Y/30Y). Fallback when FRED is unreachable.
FRED API
LiveAuthoritative US macro — CPI, jobs, inflation, VIX — fetched on release and cached.
X / Reddit / FED RSS
LiveThree-tier sentiment summarisation — AI distils raw posts into a plain-English market-weather read
Firebase Authentication
LiveSecure sign-in and identity verification on every request; per-user data isolation lands in Phase 2
Stripe Billing
PlannedSaaS subscription billing and follower-access payments (Phase 2)
Phase roadmap
From validation today to a paper-trading platform at scale
A deliberately staged product: prove the engine first, then open paper trading to more users where mistakes cost nothing, then deepen the intelligence for each user. Paper-only and advisory throughout — the platform never touches real capital. The colour of each phase reflects its current state.
Foundation & Validation
A working trading engine: — Gemini agents, — tools, a full audit trail, and live paper trading on Alpaca.
Capabilities
- ·A team of specialist AI agents working together
- ·100-ETF universe across 14 asset-class buckets
- ·Dislocation → Recovery Thesis engine: sector dislocations detected, theses authored, trajectories tracked daily until reversal confirmed
- ·One autonomous engine originates Alpaca PAPER entries; advisory agents cannot trade, while audited operator actions may close PAPER positions
- ·Fail-closed gate stack: ~14 logic gates including data-freshness, regime, trajectory, confidence, and full risk-doctrine gates
- ·7-layer institutional risk stack (bracket orders, heat caps, drawdown circuit breakers, per-segment concentration control)
- ·A persisted, queryable record of every decision the system makes
- ·Real-time tracing of every agent step for full observability
- ·An AI judge scores every decision against a 6-criterion quality rubric (live)
- ·Self-improvement engine: it learns from cohorts of past trades and proposes refinements for your review — never auto-applied
- ·Strategy × segment attribution matrix (near-empty at n=7 until more trades close)
- ·Positioning page: live thesis radar with lifecycle state (WATCH → REVERSING → ARMED)
Social Paper Trading
Open the platform to more users on Firebase. Paper trading only — no capital at risk, and every strategy is a real, auditable AI. Users follow verified track records, not personalities, and get notified of every trade in real time.
Capabilities
- ·Secure multi-user accounts with isolated data per user
- ·Strategy Marketplace — publish, discover, copy strategies with full audit trail
- ·Follow a track record — followers subscribe to a verified paper portfolio and get notified of its trades
- ·Conversational strategy creation: chat with AI Strategy Advisor to design custom rules
- ·Backtest-as-a-service before any strategy is published
- ·Mobile-first responsive design + push notifications
- ·Stripe billing — Free / Plus / Pro tiers
Advanced Intelligence & Scale
Deeper personalisation, still paper-only. Multiple portfolios, each with its own risk profile and an ensemble of strategies the AI reweights as the macro regime shifts — the flywheel running for every user. The platform never touches real capital.
Capabilities
- ·Multi-portfolio optimisation — per-portfolio risk profile, timeframe, and strategy mix
- ·Strategy ensemble that reweights with the macro regime (the flywheel, per user)
- ·Advanced visualisation: regime maps, factor attribution, scenario analysis
- ·Team & enterprise features: SSO, shared workspaces, richer reporting
- ·Deeper backtest + counterfactual replay before any strategy is followed
Monetisation roadmap
From single-operator validation to a follower marketplace
We earn nothing during validation. The product becomes commercial in Phase 2, when paper-trading users subscribe to follow verified strategies and creators earn a share of that subscription. It sits in the large copy-trading market, with one difference: full algorithmic transparency, on paper-only track records.
Phase 1 — Now
£0
Operator-only validation phase. The engine proves the thesis on real bracket orders against Alpaca paper. No external revenue. No external users.
Phase 2 — Marketplace
SaaS subscriptions
Free / Plus / Pro tiers. Followers subscribe to verified track records; creators earn a share of that subscription. Stripe billing.
Phase 3 — Scale
Tiers + licensing
Higher subscription tiers and team / enterprise licensing for the paper-advisory platform. Still no real capital, ever.
Platform credits
Built on three active integration partners
SentinelHub composes against the open-source and partner platforms above. Each integration is on the product roadmap; the agent tree degrades gracefully when any single platform is unreachable.
The APP-051 doctrine
The six-layer funnel — what to trade, and when to stop
Long-only, sector-aware, multi-TF self-stopping. Each page in this dashboard surfaces a chip mapping it to one of these layers. The funnel runs top to bottom every day, then reflects and rinses-and-repeats.
- L0 — Macro tailwind
The global regime gate
A healthy US + global economic regime is the foundational gate at the top of the funnel. When the macro tailwind is green it enables long-only deployments; when it turns red the funnel skips the costly dislocation and sector steps entirely.
- L1 — Dislocation scan
Exogenous-event dislocation scan
News, sentiment, and political-event signals surface sectors that have been beaten down despite the macro tailwind — the unloved, oversold pockets a long-only operator can actually buy. Each candidate carries an evidence chain back to the event that caused it.
- L2 — Sector identification
From 13,000 tickers to a sector universe
The dislocated segment is filtered from the ~13,000 Alpaca-tradeable tickers down to a curated sector universe of ~5-12 ETFs (energy, materials, miners…), checked for liquidity and dispersion.
- L3 — Strategy activation
Bind a strategy template to a sector universe
A strategy template (RSI-2, Momentum, Squeeze, or custom) is bound to the sector universe to produce an active strategy deployment with its own parameters. Different sectors get different templates. The entry signal (L3a) inside a deployment always fires as a bracket order — a stop-loss and take-profit from the moment of submission, no naked entries.
- L4 — Multi-TF overheat
Self-stopping when the sector runs hot
A 30m / 1H / 3H / 1D confluence scorer watches each deployment's sector universe. When the sector overheats the deployment auto-pauses — no new entries — while existing bracket orders manage open positions to their natural exit. The platform never chases a move that has already mean-reverted.
- L5 — Reflection
Reflect, then rinse-and-repeat
At end of day the reflection engine partitions closed trades by strategy × sector × regime, attributes which factors drove the outcomes, and Gemini narrates the cohort evidence into an operator-approvable proposal for the next deployment's parameters. The next day re-runs Layers 0-2 to spot the next dislocation.
Phase 1 — Foundation & Validation · v1.11.0 (Positioning Intelligence)
The engine runs. Positioning is live. External validation is next.
The engine places real bracket-protected orders on Alpaca paper. The Positioning layer — Dislocation Researcher, Recovery Thesis radar, daily re-evaluation — is live and wired. Known gap: data freshness (the engine writes local-first; stale Mongo replicas are the next workstream). The design-partner beta phase opens once the data foundation is proven fresh and complete. Strategies first, capital later.