Agentic execution

An autonomous agent that trades your accounts for real. Agent Alpha places, manages and closes live orders on your connected brokers under guardrails you set, around the clock, and gets sharper with every trade it takes.

Most “AI trading” stops at a signal on a screen. Agent Alpha does the work a trader does: it reads the market, forms a thesis, sizes the risk, sends the order, manages the position, and confirms exactly what happened. You command it in plain language or leave it to run on its own heartbeat. Either way, real orders reach a real broker through a governed path you control.

• 24/7 — multi-market autonomous operation, at machine speed.
• Live orders — real fills on real broker accounts, not backtests.
• Every entry stopped — a naked entry is refused before it reaches your broker.

Real orders, not signals

Agent Alpha holds the full trading toolkit, not a notification feed. It opens market, limit and stop entries; attaches brackets and one-cancels-other orders so a target and a stop go on together; and manages the position for its whole life, not just its birth.

Once in a trade, it does what a disciplined trader does by hand: banks part of a winner and lets the rest run, trails the stop as price moves in your favour, pulls the stop to break-even to take risk off the table, and tightens or extends the target as the picture changes. Every one of these is a live action on your account, taken under the same governance as the entry.

Every entry carries a stop

Protection is not optional and it is not an afterthought. Every live entry must carry a protective stop-loss. A naked stop, or a stop placed on the wrong side of price, is refused before the order ever reaches your broker. There is no configuration that turns this off.

This is the floor under everything the agent does: it cannot open exposure it hasn’t defined the downside of first.

Command it, or let it run

Agent Alpha works two ways, and both are always available.

Conversationally. Talk to it as you would a trader on your desk, in natural language. Ask it where your account stands, hand it an idea, tell it to close something or move a stop. It reasons over live market and account state, acts through the governed path, and reports back.

Proactively. Between your messages, it runs on its own heartbeat, on a cadence you choose, from minutes to daily. It never sleeps: it checks the live state of your markets and your accounts, decides whether anything is worth acting on, and acts when it is. You can leave the desk and the desk keeps working.

Woken by the clock, or by the market

The heartbeat is the baseline, not the limit. Agent Alpha also wakes to events, so it is present the moment something changes rather than on the next scheduled tick. A high-impact news release, a price alert you set, or a shift in market regime can all bring it to attention out of cycle. When the market moves, the agent is already looking.

It reads the market like a trader

Before it decides anything, Agent Alpha builds a genuine read of the market, not a single indicator crossing a line. In one pass it takes in the state of volatility, structure across multiple timeframes at once, candlestick patterns, support and resistance, whether the market is trending, ranging or choppy, and how your instruments are moving relative to one another. It reads all of this against your live account, its open positions and its current risk, from the broker’s own up-to-the-minute data, never a stale batch.

That is what lets it size to conditions and act with context, the way an experienced trader weighs the whole tape before committing.

How the agent sees the market

Volatility state Multi-timeframe structure Chart patterns Support & resistance Market regime Cross-market correlation Live account & open risk

It learns from itself

This is what makes Agent Alpha different from a static rule-set: it improves from its own results.

At the moment it enters, it writes down its thesis and how confident it is. When the trade closes, it reconciles that thesis against what actually happened, the real profit or loss and how far the trade ran for and against it. Each reconciled decision is graded and turned into a calibrated lesson, sorted into what genuinely worked, what was right for the wrong reasons, and what had no edge. Those lessons are carried into the next decision.

The effect compounds. The longer Agent Alpha runs on your accounts, the more it has learned about what works in which conditions, and the sharper its judgement becomes. It learns from its own wins and losses by design, not by repeating a fixed script.

Honest about outcomes

Agent Alpha never assumes a fill it didn’t get. After every order it confirms the true, final result, whether it executed, was rejected, was held back by a check, or is still pending, and it reads that back to you honestly. A position it thinks it holds is a position it actually holds. There is no optimistic guessing between the agent and your broker, which is exactly what you need from something trading real capital on your behalf.

Research engine

A disciplined funnel from idea to deployed edge — and nothing reaches live capital until it survives it. You bring the hypothesis; the engine handles the heavy science — backtesting that behaves like live, optimisation that resists hindsight, and a confidence gate that only lets a strategy trade real money once it has earned the right. Reproducible, seed-locked, and rebuilt to run entirely license-free.

From idea to deployed edge

Every strategy moves through the same six stages, in the same order, every time. Each stage is a gate, not a suggestion — a strategy that fails to clear one never advances to the next, and capital is only ever committed at the end.

Humans and agents research in the very same workbench, at the same rigour — you can drive it by hand, or let the agent run the research funnel across thousands of instruments at once, right up to the deploy gate, which stays under your control.

Backtests that behave like live

Most backtests flatter a strategy because they are too kind — perfect fills, no spread, no slippage, infinite liquidity. Ours are built to behave like the real thing. Your strategy emits genuine orders into a simulated venue and they are filled the way a broker would fill them.

• Tick-level, order-level simulation — spreads, slippage, partial fills and stop-out mechanics are all modelled, so simulated behaviour tracks live behaviour rather than an idealised curve.
• A full margin-account model — leverage, used margin and stop-out liquidation are all accounted for, and each instrument is costed with its true pip size, contract size, point value and swaps. FX, metals and indices are sized and charged correctly, not approximated.
• The same governance as live — every simulated order passes through the same risk checks your live orders will. What you test is what you deploy.

Honest by construction

A backtest is only useful if it plays by the same rules the live agent does — and if it gives you the exact same answer twice.

• The same news blackout as live. Backtests respect the identical high-impact news embargo the live agent obeys, so an edge can’t be quietly manufactured by trading straight through events your live system would sit out.
• Reproducible and seed-locked. Every run is pinned to its data, its code and its seed. Same inputs, same result — auditable and repeatable, never a number you can’t reproduce.
• License-free. The whole engine was rebuilt from first principles to run with no third-party subscriptions, so your research is never gated behind someone else’s license.

Optimisation built for robustness, not hindsight

Tuning parameters until a backtest looks perfect is the fastest way to fool yourself. The engine is designed to make that almost impossible — it optimises the way live trading actually unfolds, and it prizes stability over lucky peaks.

• Rolling walkforward, out-of-sample only. Parameters are fitted on a training window, then judged solely on the held-out window that follows — and the process rolls forward. Only stitched out-of-sample results ever count towards a verdict, because that is the only performance you could have actually captured.
• Sweeps that keep plateaus, not peaks. Grid sweeps fan out across the parameter space and reward broad, stable plateaus of good performance rather than a single knife-edge setting that happens to shine on one history. A robust edge survives small changes to its inputs; a fragile one doesn’t.

Overfit science

Run enough trials and something will look brilliant by chance alone. The engine corrects for exactly that, adjusting a strategy’s result for the full breadth of the search behind it — so what remains is signal, not survivorship.

An edge has to be real, not lucky.

Stage B — the confidence gate

This is the wall between research and real capital. Passing a walkforward earns a strategy a hearing; it does not earn it money. In Stage B, each candidate is stress-tested until it either proves it can survive the market’s worst moods — or it’s turned away.

• Thousands of alternate histories. Rather than trust the one path that actually happened, Stage B resamples a strategy’s trades into thousands of plausible alternate histories, asking not “did it work once?” but “how reliably does it work?”
• A black-swan stress library. Every candidate is put through catastrophic scenarios — violent volatility regimes, adverse gaps straight through the stop, news-driven liquidity shocks, and a replay of the 2015 Swiss franc de-peg, one of the most brutal currency dislocations on record.
• The Wilson lower-bound gate. A strategy is only cleared for capital if the lower confidence bound on its pass-probability clears the bar. Judging the pessimistic edge of the estimate — not the hopeful average — means a strategy earns capital by being reliably good, never by getting lucky once.

Verdicts you can size a position on

Stage B doesn’t return a pass/fail stamp. It returns a full risk picture — the numbers a professional actually needs before committing capital, computed per account and across the whole book.

Illustrative layout — values are placeholders, not a track record.

Strategy lifecycle and health

An edge is not a one-time event — markets move, and a strategy that was validated last quarter can quietly drift out of shape. The engine tracks every strategy from first draft through its live life, and watches it once it’s trading.

• Versions and lineage. Each strategy carries its full version history and lineage as it moves through its lifecycle — draft, backtested, walkforward, ready, live — so you always know exactly which iteration is running and how it got there.
• Drift monitoring against a validated baseline. When a strategy passes validation, its expected behaviour is pinned as a baseline. Deployed strategies are then watched continuously against it, worst-first, so degradation surfaces early rather than as a nasty surprise on the P&L.
• Revalidation, on your authority. When a strategy drifts out of tolerance, the engine flags it and opens a revalidation trigger — it never silently changes a live-money strategy on its own. You stay in control of what runs and when it’s put back through the funnel.

Data brain

One always-current view of the whole market. The market, gathered and cleaned into a single governed picture as the fleet grows — so your agents and your research read the same truth at the same moment. No stale feeds, no conflicting snapshots, no gaps between what the machine sees and what you see.

Most desks stitch their view of the world from a dozen disconnected sources, each on its own clock. VCTraderAI collapses that into one living data brain: deep history and live signal held together, structured for machines to reason over, and shared across the whole fleet.

Twenty years of market history, in one place

Under everything sits a deep, governed data lake — twenty years of tick-level history spanning foreign exchange, metals, indices, futures and crypto, held across eleven timeframes. This is the raw material every backtest, every walk-forward and every research session draws from — feeding the same governed picture your charts and your agents read live. One pool, whether you are charting a symbol, researching an idea, or running a strategy in the market.

It stays current on its own. The record is kept continuously up to date and checked, so what you research against reflects what actually happened — with freshness monitoring that raises an alarm the moment data risks going stale.

A live economic calendar, driving both sides of the platform

A live macro-event calendar — actual, forecast, previous and revised — sits at the centre of the data brain, and it does real work in two places at once. It feeds research, so a strategy is tested against the same event landscape it will face in the market. And it drives the live news gate, so your agents stand aside around high-impact releases rather than trading blind into them.

The calendar refreshes on a smart cadence: fast inside a live news window, relaxed the rest of the day — always current when it matters most, without wasting effort when it doesn’t.

Built to fuse the wider market

Price is only the beginning. The data brain is built to fuse the whole market context an institutional desk would want at hand — and to keep it in one coherent, always-current picture rather than a pile of browser tabs.

The honest picture today: tick and price data and the economic calendar are live and load-bearing — they run the platform right now. The wider context domains are the surface the data brain is built to fuse, brought online as the fleet expands. We frame this as trajectory, not as a finished board — because the value of the design is that all of it lands in one structured view, not that we claim it all today.

Market perception, on tap

The data brain doesn’t just store the market — it reads it. A set of always-ready perception views turns raw price into the reads a trader actually reasons with, computed the same way for you, your research and your agents.

Because these reads come from the shared data brain, an agent’s sense of “the market is choppy and volatility is elevated” is the same read you would get on the chart — one truth, not two opinions.

Knowledge graphs — a shared map of how the market is wired

The most valuable thing an autonomous fleet can share isn’t data — it’s understanding. The data brain turns what it gathers into knowledge graphs: an always-current map of symbols, events and the hidden connections between them. When oil moves, what tends to move with it. Which events historically shook which pairs. How today’s regime rhymes with the past.

Crucially, this map is shared and live. Any agent that learns something updates the map; every other agent reads the update instantly. There is no lag between one part of the fleet discovering a connection and the rest acting on it — the whole system holds one continuously refreshed picture of how the market is wired.

Why it matters

• Breadth — the whole market in one place, from twenty years of ticks to the wider context an institutional desk would want at hand.
• Freshness — everything current, refreshed on the cadence each source deserves, with staleness caught before it can mislead a decision.
• Shared truth — one governed view that agents, research and your screens all read the same. The machine and the human never argue over what’s real.

This is the substrate the rest of the platform stands on — the same clean, current picture feeding perception, research and every governed decision.

Journal → ML corpus

Every trade the platform ever takes — live, paper and backtested — lands in one feature-rich record. Not a spreadsheet of entries and exits, but the raw material for what comes next: the training set built to teach your desk to grade its own odds and get sharper with every position it holds.

Most journals tell you what happened. This one is built to make the next trade better.

One journal, every trade

There is a single source of truth for the whole book. Every position — whether it came from a strategy, an autonomous agent, or your own hand — lands in the same canonical journal, backtested and live side by side. No fragmented histories, no reconciling one venue against another. One record of what happened and, more importantly, why.

Because the journal is the same across simulation and live, an idea’s behavior in research and its behavior on real capital are recorded on identical terms. What you studied in the lab is what you can hold to account in production.

Tagged by who placed it

Every trade is attributed to its actor — a specific strategy, an agent, or you. That single distinction changes how you read your own book: performance can be sliced by who, or what, was behind each decision. You see plainly which strategies are carrying the desk, how your autonomous agents compare to your discretionary calls, and where conviction is paying off — all from one honest record.

Synced from your broker’s own record

The journal reflects the venue’s own account history, synced live as trades close and backfilled across your full history. It mirrors what your broker actually recorded — real fills, real prices, commissions and swap included — not an internal estimate of what should have happened. When the journal and your statement agree to the cent, you can trust everything built on top of it.

Full context, not just entry and exit

A price and a timestamp tell you almost nothing about whether a trade was a good decision. So each record carries the market as it stood around the signal — the volatility state, the trend and structure, the regime, the session and time of day, what the calendar had scheduled, how the position ran between open and close. The conditions that actually shaped the outcome travel with the trade, permanently.

This is what turns a journal into a corpus. A trade with its full context is no longer just a result — it is a labeled example the platform can learn from.

The thesis: grade the odds, not the price

Raw price is close to random and brutally hard to forecast. So the platform isn’t built to. Instead of predicting where a market will go, it is built to grade the probability that a given signal will win in the conditions in front of it right now.

That is a very different, and far more tractable, question — and it is the one that actually matters at the moment of a decision. A probability on every opportunity is something you’ll be able to act on — sizing exposure, ranking competing ideas, deciding what earns capital and what waits. The goal is not a crystal ball. It is disciplined, calibrated judgment, applied consistently and without fatigue across the whole book.

The corpus grows itself

This is the quiet compounding advantage. Every trade the fleet takes — across every strategy, every agent, every market, around the clock — adds another labeled example to the corpus. The more the desk trades, the more the corpus has to learn from; the dataset the grading will draw on sharpens with every trade. A platform running continuously across many markets writes its own curriculum, and it never stops adding to it.

Left running, the raw material for the edge doesn’t stay still. It accrues.

Built today, learning tomorrow

We are precise about where this stands. The canonical journal is live and being built right now: every trade landing in one context-rich, actor-tagged, broker-synced record is happening today, across live, paper and backtested activity. Native ML and RL models that consume this corpus are the near-term roadmap — the dataset that trains them is being assembled with every position the platform holds.

That order is deliberate. The hard part of machine learning in markets is not the model; it is a clean, honest, richly-labeled dataset of real decisions and real outcomes. That is what is being laid down now, so that what comes next has something worth learning from.

Risk Management

Autonomy is only worth having if you can trust it. Every order your agent places is checked before it can reach your broker, a kill-switch sits in your hand at all times, and you decide exactly what the agent is allowed to do — on which accounts, and for how long. This is autonomy a fund, and a regulator, can trust.

Every order runs a gauntlet

Before a single order reaches your broker, it passes a 25-check pre-trade risk gate — a fixed catalogue of checks applied to every intent, whether it came from you, a strategy, or the agent acting on its own. Nothing skips it. The first check that fails stops the order cold, and the reason is recorded. What you get is a simple guarantee: no order leaves the platform unless it has cleared every rule you rely on.

The gate reasons across the things that actually blow up accounts:

• Size and concentration. Per-strategy and per-account size caps, a notional ceiling, and limits on how much of the book can pile into one symbol or one asset class — so a single conviction can never quietly become the whole account.
• Loss and drawdown. Daily-loss and maximum-drawdown limits, measured against the worst case if every open stop were hit — not just against paper gains. An order with no protective stop is rejected outright.
• A mandatory news embargo. Entries are blocked inside high-impact economic-event windows. This one is non-negotiable and cannot be switched off.
• Price sanity and rate limits. Orders that sit too far from a fair mid price, ride an abnormally wide spread, or lean on a stale, frozen quote are refused — and submission rate is capped so nothing can hammer the broker or replay its way past a limit.

The discipline does not stop at entry: every trade stays supervised while it is live, and its execution is checked once it is done — so what happened is always something you can verify, not take on faith.

A kill-switch in your hand

You decide what the agent may do

The agent cannot trade an account you have not explicitly turned on. Arming live execution is a deliberate act: you enable a specific account, and you open a time-boxed window during which the agent is allowed to act on it. Outside that window, the agent cannot place live orders on its own — any action it wants to take comes back to you as a proposal to approve, not a done deal.

And you can pull the brake at any moment. Revoking an open window is instant and low-friction — one action disarms the agent on that account, immediately. Permission is always yours to grant and yours to withdraw.

A human stays in the loop where it counts

Routine reads and low-stakes actions flow freely. The more consequential the action, the more the platform asks of you before it happens — a graduated set of confirmations that scale with the stakes. High-impact actions require you to type a confirmation, not just click. The most sensitive add a step-up security check bound to that exact action, and the very highest add a deliberate cool-off before they can go through, so nothing catastrophic can happen on a reflex or a stray click.

The effect is that you are never surprised. The bigger the consequence, the more deliberate the platform makes it — and the friction is exactly where you want it.

Ceilings nothing can loosen

Above every account-level setting sits a set of hard, platform-wide ceilings — absolute limits on exposure, position size, loss and order rate that no configuration, and no agent, can widen. You can always make your own risk tighter; you can never make it looser than the platform allows. The mandatory news embargo lives here too: there is no switch to turn it off.

Two more brakes run continuously in the background:

• A per-account circuit breaker that trips on drawdown, session loss, over-exposure or a burst of orders, denies further trades on that account, and cools off before anything can resume.
• A daily spend cap on each workspace, so the cost of running an autonomous agent can never run away from you — it stops cleanly at the ceiling you set.

Everything is auditable

Every consequential decision the platform makes — every gate verdict, every configuration change, every step in an order’s life — is written to a permanent, tamper-evident trail you can inspect. Nothing is quietly overwritten, and any attempt to alter the record shows. You can filter it, drill into any single decision, and watch it stream live. When you ask why the agent did something, or why an order was refused, the answer is on the record — complete and trustworthy.

Multi-broker deployment

Validate once, deploy everywhere. The strategy you prove in backtest is the exact strategy that trades your live account — the same governed code path from research to paper to real capital, across your brokers and prop-firm accounts. No rewrite, no translation, no surprises between what you tested and what you run.

What you validate is what you deploy

Most platforms make you build twice: one version to backtest, another to trade. Every difference between them is a place for hidden risk to live. VCTraderAI closes that gap. Your logic runs through one execution path in every mode — tick-level backtest, paper, and live — gated by the same risk checks whether the order hits a simulation venue or your broker.

That means the behaviour you measure is the behaviour you get. Spreads, slippage, partial fills, stop-outs and margin are modelled in simulation the way they bite in the market, so a strategy that looks disciplined in research stays disciplined when it is your money on the line.

Demo and funded accounts run on the same footing, too. There is no privileged “real” path that behaves differently from the one you rehearsed on — a demo dry-run and a funded deployment travel through identical governance, so promoting a strategy from proving ground to funded capital changes nothing but the account it points at.

Deploy to your brokers and prop-firm accounts

Connecting an account is a guided, end-to-end wizard — not a hand-edited config file you hope you got right. You pick the firm, choose the challenge and phase, enter your credentials, and the platform provisions the connection, confirms the balance, syncs your trade history and resolves the tradable symbols, then hands you a live, ready-to-arm account.

Broker and venue coverage

Live MT5 execution — across IC Markets, The5ers and FTMO — is the proven path today, placing real orders on your live MT5 account. The deployment surface is built to reach further: the same governed deployment path is built to reach additional brokers and venues as each is brought online, so the platform grows with where you trade.

Prop-firm mode

If you trade a funded challenge, the hardest question is simple: would this strategy actually pass? VCTraderAI answers it before you risk the evaluation fee. Prop-firm mode replays a strategy’s equity curve through a firm’s full challenge — evaluation, verification, funded — and decides pass or fail at each stage against that firm’s real rules.

Pre-built rule-sets, out of the box

You don’t hand-code a firm’s fine print. The platform ships a curated library of prop-firm rule-sets — 38 pre-built risk profiles encoding the actual constraints of the firms it covers (FTMO, IC Markets, The5ers, Standard Trading), plus conservative, balanced and aggressive presets. Each rule-set assembles the firm’s full ruleset for your chosen variant and account size, so the guardrails are firm-correct from the first run.

Challenge auto-solvers that track it phase by phase

Beyond a single pass/fail read, per-firm auto-solvers work a strategy through a challenge’s phase rules and track its lineage and lifecycle as it advances — so you can see how a candidate progresses stage by stage rather than guessing whether it survives to funded.

Realistic net-after-fees economics

A challenge that “passes” on paper can still lose money once fees and splits are counted. Prop-firm mode models the evaluation fee per attempt, the fee refund on passing, and the funded profit-split — so what you see is the realistic net-after-fees outcome, not a gross figure that flatters the strategy.

A pre-deploy stress test, before anything goes live

The last gate before capital is a worst-case check. Before a strategy is allowed to go live, the platform computes its worst-case loss under extreme, adversarial scenarios — violent spread blow-outs, sharp volatility spikes, and a historic currency-de-peg replay among them — and refuses the deployment if that loss wouldn’t fit inside your account’s equity.

It is a simple, unbending promise: a strategy cannot be deployed into a position it could blow the account on. An operator can override a worst-case rejection only with a written justification recorded for audit — and only ever a loss-size override, never a bypass of the integrity checks that pin a strategy to its validated, production-ready form.

Managed from one place

Every connected prop-firm and broker account lives on a single Accounts surface — KPI cards, compliance and exposure lenses, per-account analytics, live-trading arming toggles and risk-config, with the onboarding wizard one click away. Deployment isn’t scattered across terminals and dashboards; it’s one governed cockpit for the whole book.

Specialist agents

A desk of specialists, each built to watch a single corner of the market and grade the odds it sees there — feeding high-conviction ideas to one governed executor that holds the trade authority. More minds on the market, one hand on the trigger.

A specialist for every corner of the market

A single agent can only pay attention to so much. So VCTraderAI’s fund-shaped design puts a specialist on each domain and leaves it to master that one patch. An energy specialist would live in oil and gas. A rates specialist is built to follow the yield curve and the central-bank calendar. Others are designed to own the equity indices, crypto, the earnings schedule. Each is meant to watch its patch continuously and in parallel, building its own patterns and carrying its own memory of what tends to work there and what doesn’t.

The design goal is depth without trade-offs. You would not be asking one generalist to stay equally sharp on crude, the Bund and Bitcoin at the same time. You would be running a specialist on each — every one fluent in its own market’s rhythm, its typical setups, and the events that move it.

They propose. They never place.

By design, every specialist does one job: surface opportunities and grade them. It weighs what it sees against the shared market brain and the canonical journal — the same always-current picture and trade history the whole platform reads — and forwards only its high-conviction ideas, each carried with a grade rather than a raw prediction.

What a specialist cannot do is trade. It holds no execution authority of any kind. It cannot place an order, move a stop or touch an account. It proposes; the decision to act sits elsewhere. That separation is deliberate and enforced — the fleet is meant to multiply how much of the market gets expert attention without multiplying who can commit your capital.

One governed executor

Only Agent Alpha executes. Every specialist idea, however strong its conviction, arrives as a proposal and then runs the same gauntlet as any other trade: the identical risk gate, the same spend cap, the same human supervision. A specialist’s signal earns no shortcut and no elevated privilege for having come from a domain expert — it is checked exactly like everything else before anything reaches your broker.

This is the fund-shaped principle in one line: more cognition, not more authority. You gain a room full of analysts feeding a single, accountable trader — never a crowd of hands all reaching for the account at once. One executor, one set of guardrails, one auditable path to live.

The attention edge

Some edges only exist if you were watching in time. When conflict flares in an oil-producing region, being long crude is the easy part — provided you saw it as it happened, not an hour later. No human desk can hold hundreds of instruments, every earnings report, every central-bank remark and every headline in view at once. The strain is physical: people blink, sleep, and look away.

A fleet of specialist agents is built to do none of that. Together they are designed to cover the breadth no trading floor can staff — always on, always in parallel, never distracted from their patch. That is the attention edge this architecture is built to capture: the market rarely rewards being right so much as being early, and a desk that never looks away is early far more often.

Where the fleet stands today

The single governed executor, its risk gate, and the shared market brain and journal the specialists grade against are live and load-bearing now. The event-driven specialist fleet — many domain agents coordinated at scale — is the near-term trajectory this architecture is built for: the same propose-only, one-executor design, widened across every corner of the market.

Agent messaging

Reach your desk from anywhere. The same agent lives in the web app and over Telegram, on desktop and phone — one continuous conversation you can pick up wherever you are, at any hour.

Your trading desk should not be tied to a screen. With VCTraderAI you talk to your agent the way you would message a trusted colleague: in plain language, from whichever device is in your hand. It reasons over what you ask, acts through the governed gate, and reports back — and it reaches out to you the moment something needs your eyes.

Talk to it like a trader, not a terminal

One agent, everywhere you are

The conversation follows you. Start a thread at your desk in the web app, continue it from Telegram on the train, and it is the same agent with the same memory of what you were discussing — not a second bot with a separate brain. Whichever device you reach for, you are talking to one desk.

• In the app — the full command surface, with the live market context alongside your conversation.
• Over Telegram — the same agent in your pocket, so you are never more than a message away.
• On any device — desktop or phone, the thread stays continuous.

Stay in the loop — approve, decline, and always know the outcome

You are never out of the loop, and never on the hook to babysit a screen. When the agent wants your sign-off on something — a consequential move, or a change to how it is armed — it comes to you as a clear approve-or-decline card: what it wants to do, and why. One tap to authorize, one tap to hold.

And the flow runs both ways. Alerts you care about — a price level tripped, a high-impact event landing, a position that needs attention — reach you wherever you are. So do results: when an action completes, you get the honest outcome, not a hopeful assumption. You always know where things stand.

Around the clock

Markets do not keep office hours, and neither does your desk. You can reach the agent 24/7, and it reaches you 24/7 — a message answered at midnight, an alert raised at dawn, an outcome confirmed while you sleep. The desk is always awake, and it is always one message away.

Python-native strategies

Build strategies in real Python — no MQL, no Expert Advisors, no MetaTrader terminal to babysit. Author your indicators, entries, exits and risk models in code you can read line by line, and every backtest runs against a full margin-account model, so what you test behaves like the real thing.

Real Python, not a walled garden

Most retail platforms hand you a proprietary scripting dialect and a compiler you cannot see inside. You learn their language, accept their limits, and trust a black box with your capital. VCTraderAI does the opposite.

Here you write in native Python — the language quants and data scientists already use — with the full expressiveness of code behind every decision. Indicators, strategies, risk models and research studies are all authored the same way: as code you own, inspect and version. Nothing is hidden, nothing is a black box, and nothing forces your logic into someone else’s template.

• Author everything in code — the signal, the sizing, the stops, the regime filter, the exit logic. If you can express it, you can build it.
• No proprietary DSL to learn — real Python and the libraries quants expect, not a cut-down scripting dialect.
• Nothing is a black box — you can read exactly what your strategy does, because you wrote it.
• Reproducible and versioned — every run is pinned to its data, its code and its seed, so a result you get today you can get again tomorrow.

No EAs. No terminals to babysit.

The Expert Advisor era asked you to keep a Windows terminal running on a VPS, pray it never disconnected, and debug a black box when a trade slipped. That whole apparatus is gone.

Your strategy is code that runs on secure, always-on cloud infrastructure — not a chart script tethered to a terminal on your desk. You deploy it and walk away; there is no MetaTrader instance to restart, no EA to reattach, no VPS to nurse through the night.

A 49-indicator library, ready to build on

Every strategy starts by reading the market well. The platform ships a library of 49 deterministic technical indicators — the same definitions used for charting, for building strategies, and for previewing them — spanning the full spread of market behaviour a systematic trader reasons about.

Across these families you cover the questions that matter to a systematic strategy: which way is the market leaning, how hard is it pushing, how much is it moving, where are the levels, who is participating, what is the structure, and what state is it in right now. Compose them freely in code — one indicator or a dozen — as inputs to your logic.

The Indicator Studio — author and preview your own

The 49 built-ins are a starting point, not a ceiling. When you need an edge the library does not have, the Indicator Studio lets you build it.

Write a custom indicator in code, then see it immediately — the studio renders your indicator as a live series over a data window, with annotations, on an interactive chart you can pan, zoom and inspect with a crosshair. You tune the logic and watch the output move against real market history, so an idea becomes something you can see and trust before it ever informs a trade.

• Create and edit in code — define the indicator exactly as you want it.
• Preview instantly — your series rendered over historical data with annotations.
• Read it on the chart — pan, zoom and crosshair to inspect the output bar by bar.

Everything you write runs through the same governed engine

This is the part retail platforms cannot offer. A strategy you build here is not a lone script firing orders into the void — it runs through the exact same governed engine as every other order on the platform.

Your custom code is held to the same standard as everything else: order-level backtests against a full margin-account model, the same overfit science and out-of-sample confidence validation before it earns capital, and the same 25-check risk gate on every live order it later places. You get the freedom of open Python with the discipline of an institutional risk framework wrapped around it — the creativity is yours, the guardrails are non-negotiable.

Notebook research

Notebook-grade quant analysis, AI-assisted. Open a notebook over 20 years of tick-level market data and go as deep as your questions take you — or simply describe what you want to know and let the agent do the building, the running and the charting for you. The full depth a quant expects, without the requirement to write the code yourself.

An open-ended research workbench

This is the professional bench, not a wizard with fixed options. You get a full notebook environment sitting directly on the platform’s tick-level data lake — the same deep history that feeds every backtest and every chart — so you can interrogate the market as openly as you like: profile an instrument’s behaviour across regimes, compare correlation structure before and after a central-bank event, pull apart the microstructure of a session, or prototype a study no menu would ever have anticipated.

Humans and agents work in the same bench with the same tools. Nothing is a black box, and nothing is dumbed down — the depth is real, you work on the raw tick data rather than a summary, and the analysis is yours to shape.

AI-assisted — depth without coding

The distinctive part: you do not have to be the one writing the code. Ask the agent, in plain language, for the analysis you want — a volatility study, a cross-market correlation map, a breakdown of how a setup performs by session or by regime — and it will research the question, build the notebook, run it on the platform’s compute, and hand back the result with the working shown.

You stay in command of the intent; the agent handles the mechanics. For quants, it is a tireless research assistant that turns hours of boilerplate into a single request. For traders who don’t code, it removes the barrier entirely — genuine notebook-grade analysis becomes something you can simply ask for.

Reproducible and versioned by default

Research is only worth acting on if you can trust it and reproduce it. Every run in the bench is pinned to the exact data, code and random seed that produced it, so a result is never a one-off you can’t recreate. Re-run it a month later and you get the same answer; hand it to a colleague — or to the agent — and it resolves to the identical figures.

That discipline is what lets an exploratory notebook graduate cleanly into something you deploy capital behind: the finding you signed off on is the finding that runs, with no silent drift in between.

Scales across thousands of instruments — you manage nothing

The same notebook that answers a question about one instrument runs, unchanged, across thousands. Point a study at a whole universe and the agent fans it out over elastic cloud compute, gathers the results, and brings them back to you — no cluster to provision, no environment to maintain, no server to keep alive. Compute spins up when you research and rests when you don’t.

The effect is leverage: a single well-posed question, answered at the scale of the entire market, with none of the infrastructure normally standing between a quant and that answer.

Deep account analytics

Know exactly where your capital stands — every account, every strategy, every risk. Portfolio, exposure and per-account performance lenses give you a fund manager’s view of your book: what is working, what is drifting, and where your real risk sits once overlap is accounted for.

Every trade the platform takes — live, paper and backtested — lands in one canonical record, synced from your broker’s own history. Your analytics read from that one record, so what you see is what actually happened at the venue, not an internal guess.

Trader-grade metrics on every account

Open any connected account and you get the numbers a professional actually judges performance by — not a vanity equity line. Sharpe and Sortino for risk-adjusted return, win-rate and expectancy for edge quality, and drawdown for the pain you’d have carried to earn it. Each metric is computed from your broker-synced trade history, so it reflects real fills, commissions and swaps — not an idealized curve.

Because every trade is tagged by who placed it — a strategy, an autonomous agent, or you — you can slice the same account by actor and see precisely which hand is carrying the return and which is bleeding it.

Portfolio and exposure lenses — honest about overlap

Two accounts can look independent and be running the same risk. The portfolio lens shows your exposure across accounts and strategies at once, so you see concentration before it hurts you — how much of your book leans on one symbol, one asset class, or one directional bet.

The correlation view is deliberately honest. Where two accounts don’t yet share enough overlapping history to say anything meaningful, the cell is left blank rather than filled with a false, comforting number. You never see a spurious perfect correlation invented to complete the grid — only relationships the data can actually support.

Performance reports, rendered to PDF

Fleet health at a glance — worst first

Deployed strategies decay. Markets shift, an edge that held for months quietly stops working, and the damage is done before a monthly review would ever catch it. The fleet-health view surfaces that early: it monitors your live deployments for drift and degrading behavior and lists them worst-first, so the strategy that most needs your attention is at the top of the screen — not buried on page three.

The moment a deployment starts to slip, you see it, and you can revalidate it through the research engine before it costs you more.

Illustrative — deployment names and states are placeholders.

Your whole book, in one command view

Above the individual accounts sits a portfolio-wide cockpit: equity and P&L at a glance, open positions, a P&L calendar that marks high-impact news and prop-firm phase milestones against your daily results, and a month-to-date summary. It’s the single screen that answers “how is everything doing right now” before you drill into any one account.

Export anything — your data, on demand

Your data is yours. Export your trade journal, account deals and history, experiment results and raw market data whenever you need them — even a large export comes down as one clean file — so you can run your own analysis, feed your own tools, or keep an independent record. Nothing is locked in.

Secure cloud hosting

Your strategies and agents run on secure, always-on infrastructure that we operate for you — around the clock, every day, with nothing to keep alive at your end. No VPS to rent, no MetaTrader terminal to leave running, no server to manage. You deploy, and the market is watched whether your laptop is open or not.

Deploy and walk away

The moment a strategy or agent goes live, it moves off your machine and onto infrastructure built to never sleep. It keeps trading, researching and perceiving the market through the night, through the weekend, through your holiday — on its own heartbeat, under the guardrails you set.

This is the difference between a tool you have to babysit and a desk that runs itself. Close the tab and the work continues. Open it a week later and every decision, fill and outcome is there, journalled and reconciled, exactly as if you had been watching the whole time.

Nothing to keep alive

Running strategies the old way means running infrastructure you never signed up to run — a virtual private server that must never reboot, a trading terminal that must never close, a connection that must never drop. Any one of them failing quietly at 3am is your position, unmanaged.

VCTraderAI removes that surface entirely.

• No VPS. You rent nothing, patch nothing, monitor nothing.
• No MetaTrader terminal. No desktop app to leave open on a machine in the corner.
• No EAs to babysit. Your logic runs natively in the cloud, not bolted onto a terminal.
• No uptime on you. Keeping it running around the clock is our job, not yours.

Your workspace, sealed off

Your workspace is yours alone. It is isolated from every other customer’s, so your strategies, your accounts and your data never share space with anyone else’s and can never be seen from outside it.

Your most sensitive material is encrypted and held under keys scoped to you — strategy code, broker credentials, API keys and the conversations you have with your agent. What you build and connect stays private to your workspace, full stop.

Compute that scales with you

When you launch a wave of backtests, walk-forwards or research, the compute behind it expands to meet the work — heavy analysis finishes without you provisioning a bigger machine or waiting in a queue you had to size yourself. When you stop, it quietly stands down. You are never paying to keep an idle server warm, and you never touch a dial to make either happen.

The result is institutional-grade capacity on demand: the compute of a quant desk when you need it, and none of the overhead when you don’t.

Always-on, by design

Being on infrastructure we run means the platform is watching for the failures that catch self-hosted setups off guard — a broker silently dropping a data feed, a connection needing to re-establish mid-session — and handling them so a strategy is never left trading on a stale picture. Your job is to decide what to run and where. Everything underneath it staying up, connected and current is ours.