Turn strategy into a running agent.
Build agents that quote, trade, settle, and respond to market events without reconstructing the Canton communication and settlement layer from the ground up.
Start with the CLI. Configure the strategy. Extend the runtime when you need more control.
The fastest route from strategy logic to an operational agent.
Agent ready CLI
Onboard, configure, and run agents through a focused command line workflow.
Reusable libraries
Compose custom agents and integrations from the same building blocks used by the ready runtime.
Trading modes included
Start with RFQ, grid, taker, and long running liquidity workflows.
Local signing
Verify prepared transactions and authorize them inside the agent environment.
Stop rebuilding the agent stack.
A useful agent needs more than decision logic. It needs market access, event streams, state management, settlement coordination, transaction verification, signing, and recovery.
Orderbook access
Submit and manage orders, read market data, follow fills, and subscribe to the events that drive the strategy.
Settlement coordination
Follow RFQs, allocations, proposals, lifecycle events, and Canton DvP outcomes through one runtime.
Signing boundaries
Prepare and verify sensitive actions before the agent signs them inside the approved environment.
Operational state
Manage configuration, balances, order state, queues, caches, settlement events, and recovery logic in a consistent application model.
Use one agent runtime for the foundations.
The Silvana SDK packages market access, settlement, signing, gRPC communication, state, and extension points into one developer stack so the team can spend its time on what makes the agent different.
SDK runtime
Configure once. Run continuously.
Install
Install the supported command line tooling or build the agent runtime from source.
Onboard
Register the agent, connect it to the Silvana environment, and generate the local files required to operate.
Configure
Set markets, spreads, levels, size, limits, liquidity behavior, and signing preferences in agent.toml.
Run
Launch the agent and let it submit orders, answer RFQs, follow events, and coordinate settlement.
Extend
Replace or add strategy logic through reusable libraries and direct gRPC clients when the ready modes no longer cover the requirement.
The first version can begin with configuration. The production version can grow into a fully custom agent without changing the underlying execution layer.
Agents that do more than observe.
Orderbook access
Submit orders, read market data, manage order state, and subscribe to book, execution, and settlement updates.
RFQ trading
Request or respond to private quotes, validate balances, select an offer, and move the trade into settlement.
Grid market making
Maintain configured price levels around a market reference while adjusting size and quotes as conditions change.
Taker execution
Run repeated buy or sell workflows until a target amount is filled within the strategy limits.
DvP settlement
Coordinate Delivery versus Payment so both legs complete together when the conditions are satisfied.
Settlement streams
Follow RFQs, preconfirmations, proposals, allocations, lifecycle events, and final outcomes continuously.
Local signing
Authorize prepared transactions inside the agent environment after verification.
Extensible libraries
Reuse core components to build custom strategies, settlement handlers, tools, and application integrations.
Use the ready flow, then make it your own.
RFQ buy and sell
Request quotes on supported pairs, select an acceptable offer, and coordinate settlement through the same controlled flow.
Grid market making
Maintain a ladder of orders around a configured reference price using defined spread, size, level, and risk parameters.
Taker loops
Execute toward a target amount across available quote and settlement opportunities.
Liquidity provider mode
Run a persistent agent that maintains grid orders, responds to RFQs, and follows DvP settlement from start to finish.
Build from the layer that fits the job.
Use the complete runtime when speed matters. Use the underlying libraries when the product needs deeper control.
Agent logic
Use configuration, instrument models, balance providers, liquidity controls, order tracking, settlement traits, and state persistence as the foundation for custom logic.
Ready agent runtime
Start with a working backend that includes onboarding helpers, RFQ handling, multicall settlement, queues, caches, and fill loops.
Orderbook proto
Use generated gRPC clients and shared message types for market data, orders, token balances, settlement proposals, and reflection.
Message signing
Create and verify canonical Ed25519 signatures for the operations that require client authorization.
Transaction verifier
Inspect and hash prepared Canton transactions before the agent approves execution.
Agent development is an operating loop.
Prototype
Begin with an example agent, ready configuration, and the quickstart workflow.
Simulate
Use the Playground or mock data to observe how the strategy behaves before introducing live execution.
Configure
Tune markets, spreads, levels, size, limits, signals, and execution rules.
Run
Launch the agent in a controlled environment and connect it to orderbook and settlement events.
Verify
Inspect prepared actions, local signatures, execution responses, and settlement status.
Scale
Move from one strategy to custom agents, shared services, managed infrastructure, or trusted execution environments.
Keep the agent active without giving it blind authority.
Prepared first
State changing transactions are constructed before the agent authorizes them.
Verified before signing
The agent can inspect the operation, parameters, transaction hash, and expected result.
Signed locally
Private keys remain inside the approved agent environment.
Executed through Silvana
The agent uses Silvana gRPC services instead of requiring direct Canton ledger access for every workflow.
Settled through DvP
Trading workflows complete through Canton DvP when both sides satisfy the settlement conditions.
Tracked through streams
The runtime follows lifecycle events and outcomes without relying on manual polling.
The agent can operate continuously. Every sensitive state change still follows a defined authorization path.
Use as much of the stack as the product needs.
One toolkit for different engineering mandates.
Strategy developers
Turn trading logic into agents that quote, place orders, respond to RFQs, and react to fills.
Liquidity teams
Operate configurable grid and RFQ agents while keeping strategy parameters within defined controls.
Product engineers
Embed agent execution, orderbook workflows, and settlement tracking inside Canton applications.
Infrastructure teams
Build custom runtimes, signing services, monitoring systems, and deployment environments.
Build agents for every Silvana surface.
Use the guide that matches the next step.
Move from strategy to operation.
Start with the quickstart, configure a ready flow, or use the SDK libraries to build the agent your product requires.