Product Architecture
This page defines the system structure of Orien AI and the role of each layer.
Read it in two passes: first follow how a request moves through the platform, then look at the responsibility of each component.
Overview
Orien AI is organized so that interfaces remain narrow, execution remains shared, and strategy logic remains inspectable.
Three ideas drive the architecture:
- requests should pass through explicit runtime stages before they reach the market
- tools and strategies should be extensible without fragmenting the execution layer
- all trading surfaces should converge on one operational model
System request flow
A trading request should move through a narrow, inspectable path. Interfaces stay thin; execution logic lives deeper in the system.
AI Chat, Integrated Agents, Web, Telegram
Skill loading, orchestration, model-assisted reasoning
limits, replay, policy checks, approval boundaries
Trade Kit, Data API, Wallet Layer
exchange or paper execution environment
Each stage narrows uncertainty before an action reaches the market.
Execution path
Most requests begin in one of three surfaces: AI Chat, Integrated Agents, or lightweight endpoints such as Web / Telegram.
From there, the request moves through the same chain:
- the interface captures intent
- the pipeline runtime resolves strategy logic and orchestration
- risk and backtest-aware checks narrow the set of allowed actions
- the execution core handles data access, order routing, and wallet boundaries
- the final action reaches an exchange or paper trading environment
This is why Orien AI can support different entry points without creating different trading systems behind them.
Three layers
Layer 1: Operator Interfaces
These are the surfaces where intent enters the system.
AI ChatIntegrated AgentsWeb / Telegram
They should stay thin. Their job is to capture intent and send it into the shared runtime.
Layer 2: Pipeline Agent Layer
This is the strategic center of the product.
It is where the platform becomes more than a tool library:
- Skills are loaded into runtime phases
- orchestration turns multi-step logic into repeatable execution
- model-assisted reasoning can be used without giving up runtime control
- risk checks and backtest assumptions stay close to the execution path
This layer is the main answer to early prompt-driven trading agents, which often mixed reasoning, execution, and policy into one opaque loop.
Layer 3: Agent Operating System
This is the shared execution substrate under all trading surfaces.
Trade Kitprovides unified exchange execution APIsData APIprovides market and account contextWallet Layerdefines the signing and custody boundary
Because these capabilities are shared, operators do not need a separate execution stack for each interface or each agent type.
Two ecosystems
The two ecosystems extend different attachment points in the system.
MCP ecosystem
MCP extends AI Chat with reusable tool servers.
It is designed for:
- tool discovery and installation
- chat-side workflow extension
- versioned and paid tool publishing
Skill ecosystem
Skill extends Pipeline Agents and Integrated Agents with strategy packages.
It is designed for:
- packaging trading logic into reusable modules
- binding strategy logic to runtime phases
- versioned and paid strategy distribution
Ecosystem attachment points
MCP and Skill extend different parts of the platform. They do not compete for the same role.
- Extends AI Chat with tools
- Publishes paid MCP servers
- Supports install, versioning, and reuse
Both ecosystems converge on the same execution, monitoring, and risk model.
- Packages trading logic as Skills
- Serves pipeline and integrated agents
- Supports paid strategy distribution
One shared core
Everything converges on the same core capability: Agent Trading.
That core includes:
- market data access
- strategy evaluation
- risk enforcement
- order execution
- monitoring and reporting
The architecture matters because it lets Orien AI expand surfaces and ecosystems without duplicating the critical execution layer underneath.