Overview
Launch and operate agentic trading strategies through Naven's managed runtime layer.
Naven Agentic Trading is infrastructure for products that want to let users launch autonomous trading strategies without building a strategy platform from scratch.
The product primitive is a Strategy Runtime: one immutable Strategy version bound to one execution Account, one Schedule, and one set of capital and risk limits. The Runtime is the independently operated trading Agent.
Strategy + Account + Schedule + Guardrails = Runtime
↓
Scheduled or manual ExecutionsThis is deliberately a higher-level contract than an order or Trade Intent API. A product tells Naven which Strategy to run and how it may operate. The strategy engine handles market context, reasoning, risk evaluation, and venue execution behind the runtime boundary.
What developers build with it
A product can use the Naven runtime layer to:
- Publish a reusable Strategy and immutable versions.
- Create or connect an isolated execution Account.
- Launch a Runtime with a schedule, capital limit, leverage limit, and maximum drawdown.
- Run the Agent immediately or let it execute on schedule.
- Pause, resume, or permanently stop the Runtime.
- Display each Execution with its decision, risk assessment, order, and error state.
The product owns its interface and user relationship. It does not need to own a scheduler, strategy worker, wallet signer, venue integration, or execution history system.
Resource model
| Resource | Purpose |
|---|---|
| Strategy | Reusable trading logic, metadata, visibility, and discovery |
| Strategy Version | Immutable instructions, universe, data inputs, and interval |
| Account | Wallet or exchange identity used by one or more products |
| Runtime | A live Agent with one Strategy version, Account, schedule, and guardrails |
| Execution | One scheduled or manual evaluation and its recorded outcome |
A Strategy is not an Agent. Multiple Runtimes can use the same Strategy version with different Accounts, capital limits, schedules, and guardrails.
Naven's infrastructure boundary
Naven owns the stable developer-facing contract:
- Authentication and product tenancy.
- Strategy and version lifecycle.
- Runtime creation and lifecycle controls.
- Normalized Runtime and Execution states.
- Usage metering, billing, and operational evidence.
- Provider routing and compatibility.
The strategy-runtime provider owns implementation details:
- Market-context collection.
- Model or rule evaluation.
- Runtime risk evaluation.
- Wallet signing and venue communication.
- Order, fill, and position reconciliation.
This separation lets Naven use a proven strategy engine initially and replace or add providers later without forcing products to rebuild their integrations.
Relationship to existing Naven products
| Naven capability | Role in agentic trading |
|---|---|
| Marketplace | Discover paid signals, research, tools, and eventually Strategies |
| x402 | Meter capability calls, Runtime activation, or Execution usage |
| Wallets | Provide isolated payment identity and, where supported, execution accounts |
| Events | Power durable Naven-owned workflows and integration events |
| Workspace agents | Host research and orchestration agents around a Strategy Runtime |
| x402scan | Preserve economic activity and settlement evidence |
Availability
The existing Marketplace, x402, Wallet, Workspace, Events, and x402scan foundation is live. The normalized Strategy Runtime API is available to Naven Projects through the Agentic Trading endpoints.
Continue to Architecture for the provider boundary or Runtime model for the resource lifecycle.