Designing AI‑Native Trading Platforms Where Conversation Replaces Clicks and Dashboards

Abstract. This article outlines the rationale, design process, and technical considerations behind an AI‑native trading prototype built for the Deriv AI Hackathon. The concept replaces conventional point‑and‑click workflows with agent‑mediated chat, allowing users to express trading intent in natural language while the system handles planning, risk analysis, and execution. The discussion is framed for both product managers evaluating next‑generation trading experiences and engineers seeking implementation guidance.

1 · From Graphical User Interfaces to Conversational Agents

Trading user interfaces have long been dominated by market information density. Multicolour charts, depth‑of‑market ladders, time‑and‑sales streams, and widget‑heavy dashboards promise speed but overwhelm new participants. Even experienced traders juggle multiple monitors to keep sentiment, order management, and risk controls within reach. The conversational paradigm offers an alternative: surface only the information relevant to the current intent and let an agent negotiate the rest.

In an AI‑native environment, the language model acts as interpreter and coordinator. When the user types, “Scale out my NASDAQ position by 25 % if the index re‑tests the 200‑day moving average,” the agent:

1. Parses the instruction into structured Intent, Conditions, and Actions.
2. Queries historical price data to identify the referenced technical level.
3. Simulates slippage and calculates potential margin impact.
4. Responds with a concise plan—“Here is the projected fill range and updated account exposure; approve?”
5. Waits for the user’s go‑ahead before sending an execution request to the broker API.

The GUI in this scenario becomes a contextual display. A micro‑chart appears inline only to illustrate the moving average touch; once confirmed, it collapses, keeping the chat thread readable.

2 · Architectural Overview

The prototype is built on four layers:

• NLP & Orchestration Layer. A large language model (LLM) fine‑tuned on trading vernacular sits behind a lightweight intent schema. A rules engine supervises safety checks (e.g., preventing market orders during illiquidity windows).
• Market Data Layer. Real‑time price feeds, historical bars, and derived analytics (VWAP, ATR) stream through a time‑series database accessed by both the agent and the UI.
• Execution Layer. A mock broker gateway normalises order placement, amendments, and status callbacks. In production, this would map to FIX or REST endpoints of multiple venues.
• Interface Layer. A chat‑first React front end renders Markdown responses, embeds trading‑view widgets on‑demand, and exposes confirmation buttons that feed back into the conversation as structured approvals.

Every user action—approval, cancellation, or new instruction—travels through the chat socket. This simplifies state management; the chat log is the audit trail.

3 · Designing Chat as System, Not Feature

Attaching a chatbot to an existing multi‑panel trading terminal often feels gimmicky because the UI and the agent compete for control. By starting from chat, layout pressure flips. The single column becomes an expandable canvas: if the user requests a Monte Carlo risk plot, the agent injects it inline; otherwise the viewport remains text‑centric. Information architecture therefore hinges on progressive disclosure—show detail only when a conversation turn demands it.

Several UX heuristics proved helpful:

1. Temporal locality: Visual elements should appear next to the instruction that spawned them; global dashboards break conversational flow.
2. Ephemeral widgets: Charts auto‑collapse after approval, keeping the thread scannable.
3. Context flags: When risk limits approach thresholds, the agent prefills the next message with a warning badge before the user asks.
4. Inline simulation: Users preview order impact within the chat bubble, eliminating modal pop‑ups.

4 · Prompt Engineering to Trigger Front‑End Events

Because the hackathon timeline was one month, I opted to simulate complex brokerage interactions via prompt‑driven front‑end hooks. Each time the agent emitted a JSON blob with the key "event": "SIMULATE_TRADE", the React component intercepted it and triggered a side panel animation illustrating hypothetical fills. This pattern decouples language logic from UI rendering while requiring minimal back‑end glue code.

A simplified event looks like:

{
  "event": "SIMULATE_TRADE",
  "instrument": "EURUSD",
  "side": "BUY",
  "size": 5000,
  "condition": {
    "type": "LIMIT",
    "price": 1.08345
  }
}

The chat component renders a summary, while a sibling hook queries historical data to animate expected slippage. These micro‑interactions make the conversation tactile without traditional forms.

5 · Lessons Learned from the Deriv AI Hackathon

The prototype validated several hypotheses:

• Semantic compression matters. Users preferred concise, bullet‑based confirmations over verbose agent explanations.
• Visibility of system state builds trust. Surfacing the agent’s reasoning (in plain English) reduced anxiety about hidden automation.
• Deterministic prompts beat probabilistic chatter. By pinning the agent’s response schema, approvals never drifted into small talk.
• Latency tolerance is lower than expected. A 1.2‑second median response was acceptable provided the agent previewed it was “Checking liquidity….”

The chief limitation was depth of order‑book simulation. Real production deployment would require venue‑specific latency arbitration and smart‑order routing. These are engineering problems, not conceptual blockers.

6 · From Prototype to Production

Scaling an AI‑native trading interface raises open questions:

1. Regulatory oversight: How do we expose agent logic to compliance teams without revealing proprietary prompts?
2. Adversarial input: Can prompt injection spoof orders? We mitigated this via strict JSON filtering, but formal verification is needed.
3. Multimodal context: Should the agent leverage voice input or even sentiment from financial news feeds to pre‑empt user queries?
4. Edge‑case workflows: Corporate actions, margin calls, and partial fills require specialised response templates.

7 · Future Research Directions

Next iterations will explore hierarchical tool use: language models orchestrating specialist micro‑agents—one for options pricing, another for macro calendar risk, and a third for portfolio rebalancing. Embedding AGC‑style semantic chunking of broker documentation may also improve answer fidelity when users ask policy questions like “How are overnight financing fees calculated?”

Conclusion

Re‑imagining a trading platform around conversation surfaces both UX elegance and architectural challenges. Yet the prototype demonstrates that intent‑driven, agent‑centric models can streamline complex financial workflows without overwhelming users. By viewing chat as infrastructure rather than an add‑on, we unlock design freedoms impossible in legacy terminals—and open a path toward genuinely intuitive markets access.