Overview
Traia V0.8 is a simulation-first product. Users create AI strategy agencies that trade with paper money against real market data, while the tokenization layer (bonding curve, graduation, staking) operates on Sepolia testnet. This proves the full concept end-to-end before mainnet.
V0.8 core loop:
- Creator builds an AI trading strategy via no-code composer
- Agency deploys with a fun token (ERC20) on bonding curve
- Agency runs simulated spot trades on a cron schedule
- Community buys/sells agency tokens based on simulated performance
- Top agencies graduate to Uniswap and unlock staking
Chain: Sepolia (Ethereum testnet)
Market type: Spot only
Trading mode: Simulation only
App: https://develop.traia.io/
1. Strategy creation flow
The agency creation is a 3-step wizard:
Step 1: Agency details
- Name - Display name for the agency
- Handle - Unique @ handle
- Description - AI-generated or manual description of the strategy
- Market type - Spot (only option in V0.8)
- Trading mode - Simulation (only option in V0.8)
- Max allocation % - Maximum share of AUM allocated to a single asset
- Max open orders - Maximum simultaneous open trading positions
- Max position size % - Maximum % of AUM per position
Step 2: Strategy outline (Drafter + Modifier)
- AI-assisted prompt - User describes their strategy idea in natural language; the assistant helps phrase entry/exit instructions
- Drafter - Takes the user's instructions and builds the full strategy logic (entry conditions, exit conditions, decision flow)
- Entry strategy - Drafter generates entry logic (when to buy, what triggers trades)
- Exit strategy - Drafter generates exit logic (when to sell, stop-loss, take-profit)
- Visual flow diagram - Shows the agent pipeline (data agents -> analysis -> decision -> execution)
- Modifier chat - Conversational interface to refine strategy details after the drafter builds the initial logic
Backend: Strategy generation pipeline
The strategy generation is a two-step process:
- Drafting - The drafter takes the user's instructions from the client, builds a complete workflow, and returns a JSON. The client renders this JSON as a visual flow diagram
- Modifying - Once the workflow exists, the user can refine it via the modifier chat. The chat assistant helps the user phrase modification instructions, and the modifier applies the actual changes to the workflow
- Drafter & Modifier run on separate ECS containers (AWS)
- Drafter LLM: GPT-4.1
- Modifier chat LLM: Claude Sonnet 4.5
- The final output is a JSON configuration stored on S3, which defines the complete strategy the agency will execute
- Known limitation: The entire draft/modify process takes 3-5 minutes due to infrastructure constraints
Step 3: Token setup
- Token name & ticker - For the agency's fun token (ERC20)
- Token image - Icon/logo for the token
- Token description - Short description
- Social links - Twitter, Telegram, YouTube, Website
- Initial purchase amount - Creator's first buy to seed the bonding curve
2. Agency deployment pipeline
On-chain trigger
- User calls
launchNewAgencyon TraiaAgencyFactory from the UI - Factory emits
Launchedevent on Sepolia
Event processing
- Event Poller (DcentraLab custom service) listens for
Launchedevents - Event Poller sends processed event to a webhook (API Lambda on Traia backend)
- Backend Lambda receives event and queues deployment to SQS (FIFO)
Deployment Lambda
- Deployment Lambda picks up the SQS message
- Pulls the JSON strategy config from S3 (produced earlier by drafter/modifier)
- Builds the agency codebase from the config
- Builds a Docker image for the agency
- Pushes image to container registry
- Deploys to GCP Cloud Run as a separate service instance
Post-deployment finalization
- Backend calls
attachOperatoron the contract with the strategy operator - Contract releases the token to be tradable
- Strategy becomes executable
- User's wallet is unlocked
- If
attachOperatorfails this is unlocked on backend - If redeployment is needed, we don't call
attachOperator, instead we callupdateAgencyOperatorDetails
Error handling & recovery
- If deployment fails show error:
- in UI
- In slack
- The contract locks the user's wallet during deployment to prevent multiple simultaneous deployments. If deployment fails at any step, the backend automatically unlocks the wallet so they can retry
- The on-chain token (ERC20) may already be created before backend deployment completes; if deployment fails, the token exists on-chain but the agency is not functional and the token is not tradable until redeployed
3. Token launch & bonding curve
Token lifecycle
Agency Created
|
v
ERC20 (Fun Token) deployed on bonding curve
| - Pump.fun-style mechanism
| - Buy/sell via TraiaBonding
| - Tradeable within Traia platform
|
v (87.5% of bonding curve filled)
|
Graduation via TraiaGraduationFactory
| - AgencyToken (real ERC20) deployed
| - Liquidity migrates from bonding curve to Uniswap
| - Backend calls unwrapToken function which airdrops new tokens and burns old one in users wallets
|
v
Post-Graduation
- AgencyToken traded on Uniswap
- TraiaAgencyDAO deployed (governance)
- TraiaAgencyVeToken deployed (staking)
- veStaking available but no rewards yet in V0.8
Bonding curve mechanics
- Base pair - TRAIA token (testnet token, no USD value)
- Fun token supply - Fixed at 1 billion per agency. Cost of 1M fun tokens is 6.7 TRAIA tokens (1 fun token = 0.0000067 TRAIA)
- Pricing - Classic bonding curve mechanism: price starts low and increases along a curve as more tokens are purchased. Each buy pushes the price up, each sell pushes it down. All prices are denominated in TRAIA
- Early adopter advantage - Lower prices for first buyers
- TraiaZapper - Allows buy/sell/launch using ETH or USDC instead of TRAIA directly
Graduation
Graduation is a multi-step process triggered when the agency market cap reaches the threshold:
- User buys token that crosses the threshold - A purchase pushes the bonding curve past the 87.5% graduation threshold
- Contract emits graduation trigger - Contract detects the threshold was passed and emits an event
- Backend reads event and calls unwrap - Backend picks up the contract event and calls the unwrap function, converting fun tokens (ERC20) to AgencyToken for all holders
- Liquidity migration event - Contract emits event confirming liquidity was successfully migrated from bonding curve to Uniswap
- Backend updates database - Backend marks graduation as completed in the database, frontend picks up the new status via polling
Holder data for the unwrapping step is fetched via Dune API (free plan, limited monthly usage).
Post-graduation
- TraiaAgencyDAO - Governance for the agency (proposals, voting, quorum)
- TraiaAgencyVeToken - Staking token with time-lock mechanics
- No rewards yet - veStaking exists structurally but doesn't distribute fees in V0.8
4. Agency runtime (simulation engine)
Execution model
- Cron-based - Agencies run on a periodic schedule
- Paper money - Each agency starts with a fixed 10,000 USDT simulated balance (no user deposits into agencies in V0.8)
- Real market data - Strategies execute against CoinGecko price data
- Order lifecycle - Orders created by AI reasoning, executed by a separate simulation engine cron
Two-phase execution
Phase 1: Strategy reasoning (every 30 minutes)
- Each agency runs on its own GCP Cloud Run service instance
- Agency has an internal cron that triggers every 30 minutes
- Uses DeepSeek-Chat LLM for strategy reasoning
- Agency calls agents that process data via MCP servers (hosted on d402)
- Produces order objects (signals) with direction (BUY/SELL), price, size, reasoning
- Agency calls the Traia backend API to save orders to the database
Phase 2: Order execution (every 5 minutes)
- Separate AWS Lambda triggered by EventBridge schedule every 5 minutes
- Pulls all PENDING orders from PostgreSQL
- Fetches fresh prices from CoinGecko API at that moment
- Processes and executes orders against CoinGecko prices at the time of fetch
- When a SELL order is successfully executed, a closed trade record is stored in the DB using the average buy price across multiple positions per token
Order types
- GTD (Good 'Til Date/Time) - expires after 24 hours for now
- GTC (Good 'Til Canceled) - not active yet
- IOC (Immediate or Cancel) - not active yet
- FOK (Fill or Kill) - not active yet
Signals, trades & executions
Signals (spot orders)
- Pair - e.g. ETH/USDT
- Side - BUY / SELL
- Order type - MARKET (execute immediately) / LIMIT (waiting for condition to be met) — system is skewed 90%-10% in favor of market orders.
- Time in force - GTD (Good 'Til Date/Time) - expires after 24 hours for now
- Base qty - Units of base asset (what we are buying or selling)
- Quote qty - Units of quote asset (what we are using - USDT)
Order fields
Market orders:
- Limit price: null
- Slippage
- Min amount of tokens out
- Max amounts of token in
- Average fill price
Limit orders:
- Limit price (price in which to execute the order)
- Max amount of tokens out
- Min amount of tokens in
- Average fill price (calculated only after order is executed)
Status
- Active in v0.8: PENDING, FILLED, CANCELLED (cancelled by cron), EXPIRED (24 hours after cron ran)
- Not active yet: OPEN, PARTIALLY_FILLED, REJECTED, FAILED
- Filled base qty - Amount filled so far (not relevant for v0.8 because orders are filled entirely in each execution)
- Avg fill price - Average execution price (the price of execution for now. not relevant for v0.8 because orders are filled entirely in each execution)
- Fees - Execution fees (In simulation it's Traia fees, later in live mode this is trading fees)
- Placed at - Order creation timestamp
- Filled at - Fill timestamp (nullable)
- Cancelled at - Cancellation timestamp (nullable)
- Tx hash - On-chain reference (nullable, also not on-chain for v0.8)
- Reasoning - AI's explanation for the trade decision
Executions (individual fills)
- Order id - Reference to the originating order
- Pair - e.g. ETH/USDT
- Side - BUY / SELL
- Price - Fill price
- Base qty - Amount of base asset
- Quote qty - Amount of quote asset
- Fees - Execution fee
- Tx hash - On-chain reference (nullable for v0.8, not nullable in live mode)
Completed trades
- Pair - e.g. ETH/USDT
- Side - BUY / SELL
- Platform - Executing venue
- Trade time - Timestamp of execution
- Price - Execution price
- Base qty - Amount of base asset
- Quote qty - Quote value
- Realized PnL - Profit/loss
- Fees - Trade fees (nullable)
- Fee currency - Currency fees were paid in (nullable)
- Tx hash - On-chain reference (nullable for v0.8, not nullable in live mode)
Portfolio tracking
- Real-time portfolio breakdown (assets held, allocations)
- Daily PnL calculation and history per each asset and per agency
- AUM history tracking per agency (total is shown on frontend, no history in v.08)
Performance metrics
- ROI = Array of [7, 30] days unrealized ROI in % - [SUM(unrealized_pnl_usd) / SUM(cost_basis_usd)]
- Win rate = filled_orders / total_orders (decimal range 0-1)
- Trading frequency = COUNT(total_number_spot_orders)
- AUM = SUM(quantity × avg_entry_price for each portfolio assets) in USD
- Total PnL = SUM(total_unrealized_pnl) + SUM(total_accumulated_realized_pnl) in USD
5. Agency marketplace
Agencies listing page
- Browse all deployed agencies
- Filters: High ROI, High mcap, Newly Created, Graduated, Bonding
- Search by name/description
- No leaderboard in V0.8
Agency card preview
- Name + creator
- Token price
- Market cap
- Volume
- ROI indicator
Agency detail page
Two views: Strategy performance / token performance
Strategy performance view:
- Performance chart
- AUM
- Trading frequency
- Win rate
- Portfolio breakdown
- Signals / trades / executions tabs
Token performance view:
- Market cap
- Volume
- Token holders count
- Price chart
About / info:
- Agency address
- Creator address
- Creator stake
- Leaderboard rank (when leaderboard exists)
- Earned fees
- Trading pairs
Privacy controls
- Creators can toggle visibility of signals and portfolio
- Token holders only vs public
6. d402 / MCP agent infrastructure
Overview
d402 is a separate product integrated into Traia V0.8. It provides the utility agent / data agent layer that powers strategy execution.
MCP servers in V0.8
- Traia-team only - No external developers publishing MCP servers in V0.8
- Pre-built servers include: HyperLiquid, CoinGecko, and others
d402 payment model
- Utility agents are hosted on d402 with on-chain payment settlement
- IATP Wallet - Traia opens an IATP wallet for each agency to consume data via MCP servers
- Payment per API call
- Settlement tokens on Sepolia (e.g. USDC)
How agencies use MCP servers
Data flows: Strategy Execution -> MCP servers -> strategy decision -> simulated execution
- Agency calls MCP server endpoints for data and analysis
- Agencies also call agents that use MCP servers under the hood
- Agency pays per MCP call via its IATP wallet
7. Backend architecture & infrastructure
Tech stack
- Backend language: Python (serverless)
- Frontend: Next.js (hosted on Vercel at develop.traia.io)
- Database: PostgreSQL (agencies, signals, trades, executions, portfolios, performance)
- Object storage: AWS S3 (strategy JSON configs)
- Auth: Dynamic SDK wallet connect + email signup (both required)
- Login flow: Connect wallet (sign message) -> email verification -> session created
- Supported wallets: MetaMask, Rabby, and other injected wallets
- Session: JWT-based with 7-day expiration
- Known limitations: Wallet disconnection timeouts can occur; session stability improvements ongoing
Frontend stack
- Framework - Next.js
- Hosting - Vercel
- UI - Tailwind CSS + shadcn/ui
- State (server) - React Query (TanStack Query)
- State (client) - Jotai
- Web3 - Dynamic SDK + viem + wagmi
- Charts - Recharts
- Flow diagrams - React Flow (xyflow)
- Data updates - Polling (interval fetch)
Frontend-contract interaction
- Direct contract calls (user signs tx): Token buy/sell on bonding curve (TraiaBonding, TraiaZapper), agency launch (TraiaAgencyFactory), staking, DAO voting
- Via backend API: Token details, graduation status, price details, portfolio data, signals/trades/executions, performance metrics
AWS infrastructure
- Lambda + API Gateway - Backend API endpoints (serverless)
- ECS - Drafter and Modifier services (separate containers)
- SQS (FIFO) - Deployment queue (event -> deployment Lambda)
- EventBridge - Schedules the 5-minute order execution Lambda
- S3 - Strategy JSON config storage
- SSM - Secrets and environment variables
GCP infrastructure
- Cloud Run - Agency runtime (1 service instance per agency)
- Cloud Run - MCP servers (d402 data/utility agents)
- Cloud Storage - Bucket which stores downloaded service code archives from Github
- Cloud Build - Building Docker image from Cloud Storage to deploying container on CloudRun service
External services
- Event Poller - DcentraLab custom service; listens for on-chain events, dispatches webhooks
- CoinGecko API - Price feeds for order execution cron
- Dune API - Holder data for graduation token unwrapping (free plan, limited monthly usage) and token stats (i.e. top holders data)
- MCP Servers - Data sources for strategy reasoning (HyperLiquid, CoinGecko, etc.)
LLM usage
- Strategy drafter (step 2) - GPT-4.1
- Modifier (step 2) - GPT-4.1
- Chat assistant (step 2) - Claude Sonnet 4.5
- Strategy agency runtime (trading decisions) - DeepSeek-Chat
Data flow summary
User creates strategy
|
v
Drafter (ECS, GPT-4.1) + Modifier (ECS, GPT-4.1) + Chat Assistant (ECS, Sonnet 4.5)
| -> JSON config -> S3
|
User calls launchNewAgency on-chain
|
v
Event Poller -> Webhook -> Lambda -> SQS -> Deployment Lambda
| -> Pulls config from S3
| -> Builds codebase + Docker image
| -> Deploys to Cloud Run
| -> attachOperator on-chain
|
v
Agency (Cloud Run, DeepSeek-Chat)
| Internal cron: every 30 min
| -> Calls Traia API to fetch portfolio assets and pending orders
| -> Calls MCP servers for data
| -> Calls agents that use MCP servers
| -> Produces orders (signals) and optionally cancels stale pending orders
| -> Calls Traia API to save to DB
|
v
Order Execution Lambda (EventBridge, every 5 min)
| -> Pulls pending orders from PostgreSQL
| -> Fetches prices from CoinGecko
| -> Executes orders, creates trades
| -> Updates DB
|
v
Frontend (Next.js) reads from API
-> Displays portfolio, signals, trades, performance
Environments
- Develop - Current active environment (
develop.traia.io) - Staging - Being provisioned; will mirror production configuration for final QA
- Production - Target for mainnet launch (post-V0.8)
8. Next iterations
V0.9 - Public testnet
- Leaderboard
- Whitelist agency creators
- Issue TUSD for testnet investment by users (or backend DB points)
V1.0 - Paper trading on mainnet
- Mainnet deployment
- External developers publishing MCP servers
- Protocol-level Treasury / DAO
- veStaking rewards / fee distribution
- If backend fails when deploying, don't redeploy contracts
Post V1.0
- Live trading (real money execution)
- Perpetual/derivatives trading
- Back-testing against historical data
- Community strategy templates marketplace
- Yield agents (LP, farming, staking strategies)
- Leverage pool (2x borrowing)
- Cross-chain execution
Appendix: Key links
- App: https://develop.traia.io/
- Figma: https://www.figma.com/design/wNHFtrdfruO2JbDAojqU52/Traia?node-id=2213-20667
- Contracts: https://github.com/Traia-IO/traia-contracts/blob/staging/deployments/addresses/contract-proxies.json
- Product docs: https://app.clickup.com/3857237/v/dc/3npun-39855/3npun-77895