Build your first agent.
Follow one guided path from local setup to a working agent that can observe a market, act within defined limits, and follow execution through settlement.
Start with a working flow. Extend it when the strategy demands more.
A functioning agent, not a disconnected demo.
The guide should end with an agent that can connect to Silvana, read approved market state, apply a configured strategy, submit supported actions, and track resulting execution and settlement events.
Connect to Silvana
Create the local identity and configuration required to access the selected Silvana environment.
Read live service state
Confirm connectivity, inspect available markets or services, and verify that the agent can receive the information its strategy needs.
Run configured logic
Load the operating parameters that define the market, strategy, size, limits, and runtime behavior.
Prepare and authorize actions
Build supported state changing operations, inspect what will execute, and sign within the approved environment.
Follow the result
Track order, transaction, and settlement status through structured responses and event streams.
Start with a known environment.
Before running the guide, confirm that your local environment, access, SDK version, and target network match the current documentation.
Development environment
Use a supported operating system and the runtime or toolchain required by the current SDK release.
Silvana access
Have the credentials, invitation, or account access required for the selected environment.
Signing identity
Create or provide the signing identity required by the current onboarding flow. Keep private material inside the environment you control.
Network and assets
Confirm which network the guide targets and whether test assets are required for the selected workflow.
Current version
Check the SDK and CLI version used by the guide, then follow the corresponding release notes and documentation.
The maintained documentation is the source of truth for package versions, command names, network identifiers, and setup requirements. Last reviewed June 23, 2026.
From setup to first run in six steps.
Each step pairs concise explanation with a documentation backed command or code sample. A developer should be able to complete the sequence without choosing between competing setup paths.
Choose the environment
Select the Silvana environment the agent will use and confirm the endpoint, credentials, and asset environment.
Install the tooling
Install the supported CLI and SDK packages for the current release, then confirm the local tooling reports the expected version.
Create the local identity
Generate or import the signing identity required for the agent without exposing private key material.
Onboard and connect
Register the agent, receive required identifiers, and write the local configuration files used by the runtime.
Configure the mandate
Set the market, strategy, size, limits, and signing behavior the agent must follow.
Run and verify
Start the agent, confirm service connectivity, and follow the first order, quote, transaction, or settlement events.
Make the operating mandate visible.
A reviewer should understand what the agent can access and where its limits sit.
The final published example must use the current schema and supported field names. This marketing page shows structure and links to documentation for exact release details.
[environment]
network = "[SUPPORTED_NETWORK]"
[market]
pair = "CC/USDC"
[strategy]
mode = "grid"
levels = 6
spread = 0.0008
size = 2500
[limits]
max_order_size = "[VALUE]"
max_position = "[VALUE]"
[signing]
mode = "local"Market and environment
Define the network, market, assets, endpoints, and service settings required by the workflow.
Strategy
Choose the operating mode and set the parameters that govern how the agent observes, quotes, trades, or reacts.
Limits
Define order size, position, price, exposure, frequency, expiry, and other boundaries required by the mandate.
Signing
Specify where signing occurs and which identity or secure environment is authorized to approve transactions.
Runtime
Set logging, persistence, reconnect behavior, event handling, and other operational settings supported by the current release.
Observe, decide, authorize, and follow through.
The first agent should make the full operating model visible. Strategy logic is only one part of the runtime.
Connect
Open required Silvana services and confirm the agent identity, permissions, and environment.
Observe
Receive market data, order state, settlement events, balances, or other approved inputs.
Decide
Evaluate current state against the configured objective, strategy logic, and limits.
Prepare
Build the supported order or transaction request and return the information required for review.
Verify and sign
Check the operation, asset, amount, recipient, fees, and expected result before signing.
Execute
Submit the authorized action through the appropriate Silvana service.
Track and reconcile
Follow status, identifiers, created records, and settlement events until the workflow reaches a clear outcome.
Start with the infrastructure already solved.
The SDK reduces the amount of market, execution, signing, settlement, and runtime infrastructure a team must rebuild before it can focus on strategy logic.
Agent onboarding
Create the identity, configuration, and service access required for a supported agent runtime.
Orderbook access
Read market data, submit supported orders, manage order state, and receive execution events.
Private RFQ
Request, receive, evaluate, and respond to quotes within the available trading flows.
Strategy modes
Begin with supported examples for grid, market making, taker, or other documented workflows.
Settlement events
Follow proposals, readiness, lifecycle changes, and final outcomes through structured updates.
Transaction verification
Inspect prepared transactions and hashes before signing state changing operations.
Local signing
Keep private key material inside the agent, application, or approved secure environment.
Reusable components
Use clients, types, signing helpers, verification utilities, and runtime components to build beyond included flows.
Keep the working path. Replace the strategy.
Configuration layer
Load the environment, market, strategy, permissions, and runtime settings from one maintained source.
Service clients
Use typed clients for the orderbook, settlement, ledger, pricing, and supported signal services.
Strategy loop
Replace the included decision logic with custom rules, models, data sources, or orchestration.
Signing and verification
Reuse the supported signing and transaction verification path rather than introducing blind authorization.
State and recovery
Persist the state required to resume safely, reconcile outcomes, and recover from interrupted workflows.
Deployment layer
Run the same agent logic in the infrastructure model that fits your control, confidentiality, and operating requirements.
Prove the behavior before the agent touches live assets.
A successful local run is the beginning of validation, not the end. Move through environments deliberately and confirm behavior, controls, and recovery at each stage.
Local runtime
Confirm installation, configuration, service connectivity, signing, event handling, and basic strategy behavior.
Supported test environment
Where available, run against the maintained nonproduction environment using the current onboarding and asset flow.
Production readiness
Review permissions, limits, secrets, monitoring, incident procedures, and deployment ownership before enabling live workflows.
Simulation does not prove production readiness. Every code sample or demo should state which environment it targets.
The first agent should establish the right control model.
Explicit access
Give the agent only the services, operations, markets, assets, and environments required by its mandate.
Visible limits
Keep size, exposure, pricing, frequency, and strategy boundaries readable in configuration and reviewable by the operator.
Prepared actions
Inspect state changing transactions before execution rather than granting open signing authority.
Signing inside the runtime
Keep private key material inside the approved local, server, cloud, or secure execution environment.
Structured outcomes
Store the identifiers, status, events, and errors required to monitor and reconcile every important action.
Operational stop path
Document how the agent is paused, updated, or withdrawn when conditions require intervention.
Use the next reference when the first agent works.
Move from the guide to your own agent.
Complete the first working flow, replace the included logic with your strategy, and choose the runtime that matches your operating model.