A simpler way to launch investing agents.
Building an investing agent from scratch with AI tools is complex: prompts, data, ranking, backtesting, validation, portfolio setup, and ongoing management all need to work together. AgentX packages that into a guided product: clients can choose an agent from the Store or create one through a controlled workflow.
What AgentX Is
A client-facing explanation for investors, relationship managers, and product teams.
AgentX turns investment ideas into managed agents.
Instead of asking a client or advisor to assemble their own AI stack, data pipeline, strategy logic, trading rules, and monitoring layer, AgentX provides a guided path from idea to launched agent. The client experience is simple: browse, choose, customize, review, launch, and monitor.
The Client Path
AgentX gives two entry points: select a proven strategy from the Store or create a new one through a guided mechanism.
Start
Choose a Store agent or describe a new investing idea in normal language.
Structure
AgentX turns the idea into objective, universe, risk, rebalance style, and rules.
Validate
The system checks whether the idea can be mapped to tradable instruments and reviewed evidence.
Launch
The selected or created agent becomes a managed portfolio workflow with clear controls.
Monitor
Clients and teams can track behavior, performance, risk, drift, and decision history.
Agent Store
The Store is the simple path for clients who want to start from curated agent templates instead of creating a strategy from zero.
Browse agents
Clients can compare agents by theme, goal, risk, asset class, rebalance cadence, and performance evidence.
Understand fit
Each Store agent should explain what it tries to do, what market universe it uses, and what risks or limits apply.
Launch faster
The client starts from a reviewed strategy object, not a blank AI prompt or a custom engineering project.
Creation Mechanism
Creator Studio is the guided path for new agents: it makes AI creation structured, reviewable, and operational.
What the client does
- Describe the investing thesis, goal, market, risk level, and optional tickers.
- Review the proposed universe, benchmark, holdings, and warnings.
- Decide whether to save, test, publish, or launch the agent.
What AgentX handles
- Turns the idea into a structured strategy contract instead of a loose prompt.
- Maps themes and concepts to tradable instruments and data-backed rankings.
- Carries validation, backtest evidence, risk settings, and lifecycle monitoring forward.
Why This Is Simpler
The message: AI can help build agents, but production-grade investing agents need more than a chat prompt.
What You Can Do With It
A practical client-facing summary of the product surface.
Personalize a portfolio
Turn a theme like dividend income, AI infrastructure, value, defense, macro, or quality growth into a governed agent.
Subscribe to strategies
Use the Store to launch agents built from approved strategy templates and tracked performance artifacts.
Explain every step
Client-facing people can show what the agent is trying to do, why it holds positions, and where the controls are.
Manage after launch
AgentX monitors signals, risk, drift, portfolio state, and health instead of stopping at creation.
Scale creator ideas
Successful ideas can become Store strategies so more clients can discover and launch them.
Keep a review trail
Strategy versions, validation reports, run logs, and decision records make agents easier to audit and improve.
Technical Architecture
The existing engineering overview remains below for teams that need the data, validation, and runtime details.
The Three Pillars
AgentX is built on three core systems that work together: a unified data operating system, semantic strategy creation, and managed agent lifecycle. Each is detailed in its own section below.
Data operating system
QuantDB centralizes market data, factors, signals, portfolio data, app state, and DCC taxonomy behind one API and one schema explorer.
Semantic strategy creation
User prompts become structured strategy intent, taxonomy concepts, risk profile, benchmark, and eToro-tradable ticker universes.
Managed agent lifecycle
Agents continue after launch: signal generation, regime detection, conviction checks, LLM context, drift monitoring, risk controls, and execution routing.
Interactive Architecture Diagrams
These four diagrams show how the three pillars fit together. Pan, zoom, and drag to explore.
Creator Workflow
The creator flow is designed to prevent vague prompts, unreviewed universes, unsafe requests, and untraceable backtests.
Prompt to Strategy Preview
Step-by-step request flow from creator prompt to QuantDB validation and back.
QuantDB And Semantic Layers
AgentX reads from QuantDB directly for low-latency internal queries and through data.quantclaw.org for stable service contracts.
| Layer | Purpose | Important surfaces | How AgentX uses it |
|---|---|---|---|
raw | Provider landing zone | Source-specific raw snapshots | Auditability and provider lineage before normalization. |
data | Canonical market data | instruments, price_history, factor_scores, consensus_snapshots, taxonomy_mapping | Ranking, semantic universe resolution, PIT-aware backtest inputs, profiles, and live data. |
signals | Signal and derived analytics | signals, derived_indicators, external_signals, signal_backtests, feature snapshots | Signal history, model outputs, evaluation, and research feedback loops. |
portfolio | Portfolio analytics | holdings, trade_blotter, monthly_scores, backtests | Model portfolio analytics and performance reporting. |
app | Application state | vault_agent_portfolios, subscriptions, conversations, validation results | Auth-linked portfolio state, user workflow state, and operational metadata. |
agentx | AgentX app schema in QuantDB | strategies, strategy_creators, strategy_versions, subscriptions, run logs, target weights | Reviewed from AgentX migrations and code: Creator Store, StrategySpec persistence, validation history, and target portfolio snapshots. |
Data Lineage: Provider Data → Agent Decision
Strategy Store Apparatus
The Store is both a product surface and a contract boundary between creator workflows, validation, performance evidence, and subscriptions.
Marketplace state
agentx.strategiesstores published and system strategies.agentx.strategy_creatorsjoins creator identity and display metadata.agentx.strategy_versionspreserves published snapshots for review and rollback.agentx.strategy_subscriptionsconnects Store strategies to launched user agents.- Rows carry status, subscriber count, validation score, validation report, factor config, and backtest result payloads.
- AgentX maps DB rows back into UI-compatible strategy templates.
Backtest cache and honesty layer
- Daily cache refresh runs engine results into
runtime/backtest-cache/store. - Each run writes a structured log under
strategies/run_logs. latest-good.jsonprotects the Store UI from failed refreshes.- The API exposes freshness, cache status, bias status, coverage, and failure metadata.
Schema / Domain Relationships
Managed Agent Lifecycle
After creation, AgentX manages agents in repeated cycles. The loop is designed to degrade gracefully when data is missing and to separate paper, shadow, and live execution modes.
Swimlane: Creator Publish & Store Lifecycle
Batch route loads active agents, filters archived/test/guest shells, checks market hours, and narrows each universe to open-market tickers.
Regime detector produces growth, reflation, slowdown, or stress context with cash target, size multiplier, threshold adjustment, and factor overrides.
Signal generator, conviction buffer, portfolio manager, and risk manager produce buy/sell/wait decisions with bounded failure isolation.
LLM context activates only for anomalies, rule conflicts, earnings, macro events, or corporate actions. It can confirm, pause, adjust score, flag human, or no-op.
Drift monitor compares live/eToro reconciled positions to target weights and proposes trims, fills, or missing-position buys.
Execution bridge supports paper, shadow, and live modes, with live requiring authenticated agent-portfolio state and safety approvals.
Startup instrumentation validates schema, starts the portfolio poller, and drains DB/Redis cleanly on shutdown. Order monitoring uses private-feed events with HTTP fallback.
Each batch stores run status, signals, trades, live fills, errors, and human-readable decision summaries for admin review.
Runtime Management Loop
Operational Visibility
The platform has multiple health surfaces so product and engineering can separate data staleness, app health, execution health, and strategy behavior.
Agent health
/api/agent/health checks QuantDB Platinum data, regime state, schema health, portfolio risk state, and per-agent conviction backlog.
Admin dashboard
/api/admin/dashboard aggregates Store cache freshness, live portfolio monitor events, active PM status, data health, and pipeline alerts.
Pipeline health
/api/v1/pipeline/health checks staleness across price history, derived indicators, factors, GuruFocus rankings, PIT fundamentals, revisions, consensus, and daily signals.
Code Map
Primary files and endpoints reviewed for this overview. These are the best entry points for R&D, product, and technology teams.
| Area | Files / endpoints | Role |
|---|---|---|
| Data API | quantdb-api/src/index.ts/schema, /architecture, /docs, /v2/smart-portfolio/* | Unified data gateway, API docs, schema explorer, and public-safe technical pages. |
| Schema explorer | quantdb-api/src/routes/schema.ts | Read-only introspection of schemas, columns, row counts, sizes, indexes, and relationships. |
| Semantic universe | agentx-current/src/lib/semantic-universe.tsagentx-current/src/lib/strategy-universe-resolver.ts | Prompt-to-taxonomy matching, alias seeds, QuantDB taxonomy lookup, and eToro instrument validation. |
| LLM intent | agentx-current/src/lib/strategy-intent-interpreter.ts | Provider-backed classification, safe rejection reasons, normalized objective, factors, geography, and risk. |
| Strategy contract | agentx-current/src/lib/strategy-spec.tsagentx-current/schemas/strategy-spec/* | Canonical type system used by builder, rank API, backtest, DB persistence, and validation. |
| Creator APIs | /api/strategy-preview/api/creator/rank/api/backtest | Preview contract, QuantDB rank proxy, and backtest invocation with structured run logging. |
| Store APIs | /api/store/strategies/api/store/backtestsagentx-current/src/lib/strategy-store.ts | Marketplace listing, strategy CRUD, Store cache, validation reports, creator attribution, and subscribers. |
| Agent loop | agentx-current/src/lib/agent-loop.ts/api/agents/loop/batch | Batch orchestration for regime, signals, LLM context, risk, drift, execution, and ledgers. |
| Ongoing management | agentx-current/src/instrumentation.tsagentx-current/src/lib/portfolio-poller.tsagentx-current/src/lib/order-monitor.tsagentx-current/src/lib/drift-monitor.tsagentx-current/src/lib/etoro-execution-bridge.ts | Startup checks, portfolio polling, order lifecycle monitoring, drift detection, eToro reconciliation, paper/shadow/live phases, and go-live controls. |
Demo Talk Track
Use this sequence to explain the depth of the platform to R&D, technology, and product teams.
Product lens
AgentX lets a user describe an investing thesis, turns it into a structured agent, shows evidence, and makes it subscribable in the Store.
Technology lens
The system has strict contracts: StrategySpec, preview hash, QuantDB APIs, schema introspection, PIT semantics, cache status, and run logs.
R&D lens
The agent loop combines quantitative scores, market regime, conviction thresholds, LLM anomaly checks, drift monitoring, and execution modes.
Reviewed Sources
This page is based on local code and live read-only service metadata, not hand-waved architecture.