Give agents Canton execution.
Use one gRPC interface to prepare, sign, and execute payments, transfers, DvP, CIP-56, multicall, and service workflows on Canton.
Define the logic. Keep keys local. Let agents execute.
Agents and backend applications transact on Canton through a unified Silvana Ledger interface.
Transactions are prepared before execution, and private keys stay under agent or client control.
Transfers, DvP, CIP-56, recurring payments, user services, and multicall flows use explicit operation types.
Every executed transaction returns structured status, update ID, contract data, traffic, and errors.
Canton needs agent infrastructure
Tokenized assets already exist on Canton, but applications still need execution logic, signing flows, settlement automation, workflow coordination, and reliable reconciliation. Agentic API turns those requirements into a developer-ready execution layer.
Ledger complexity
Unsafe automation
Fragmented workflows
Hard reconciliation
Prepare. Sign locally. Execute.
Every state-changing operation follows a controlled transaction flow, so agents can verify what they are about to execute before anything reaches Canton.
- 1
Prepare
The agent calls PrepareTransaction with a TransactionOperation and matching params. Silvana Ledger returns transaction_id, prepared_transaction_hash, prepared_transaction, command_id, and traffic_estimate.
- 2
Verify
The agent checks the operation, params, hash, traffic estimate, recipient, asset, and expected outcome before signing.
- 3
Sign locally
The agent signs prepared_transaction_hash with its Ed25519 private key. The key stays inside the client or controlled agent environment.
Private keys stay local - 4
Execute
The agent submits transaction_id and the signature through ExecuteTransaction. Silvana Ledger sends it to Canton and returns success, update_id, created_contracts, traffic, rewards, and structured errors.
- 5
Reconcile
The application stores update_id, transaction_status, created contracts, traffic usage, and provider errors for tracking, accounting, reporting, and recovery.
// 1. Prepare — the API builds the tx and returns payload + hashlet prepared = ledger.prepare_transaction(op).await?; // 2. Sign locally — private keys never leave the clientlet sig = signer.sign(&prepared.prepared_transaction_hash); // 3. Execute — submit the signature, get update_id + statuslet res = ledger.execute_transaction(prepared.transaction_id, sig).await?;println!("{} {:?}", res.update_id, res.transaction_status);Ship real Canton workflows
Agentic API gives agents and applications the primitives required to move assets, coordinate settlement, automate payments, and compose multi-step operations.
Payments
Programmable, verifiable payments using Canton's CIP-56 standard.
Transfer Canton Coin directly, in bulk, or through split operations.
Execute prepaid or pay-as-you-go recurring payment workflows.
Settlement
Propose, accept, allocate, and settle Delivery-versus-Payment workflows.
Coordinate settlement readiness by checking and submitting allocations.
Read settlement contracts and track lifecycle updates to final execution.
Automation
Execute multi-step workflows through one atomic batch operation.
Engage providers to perform actions inside provider-defined user flows.
Request and manage approvals before a later operation is executed.
Connectivity
Subscribe to Canton updates, balances, amulets, active contracts, and ledger state.
Run bridge-related operations through the DAppBridgeService where enabled.
Register agents, get onboarding status, and connect them to workflows.
Enable only what your app needs
Agentic API operations are organized into functional groups, so services can expose only the capabilities required by a specific application, agent, or environment. Core is always enabled; other groups can be enabled or disabled independently.
Core
EnabledRead-only queries: service info, ledger end, balances, amulets, active contracts, and updates.
Transfer
OptionalCanton Coin transfers and split operations.
DvP
OptionalSettlement contracts, DvP fees, proposals, acceptance, allocation fees, and allocations.
CIP-56
OptionalToken transfers and acceptance flows.
Recurring
OptionalPrepaid and pay-as-you-go recurring payment requests.
Onboarding
OptionalAgent registration, onboarding status, configuration, and onboarding signatures.
Multicall
OptionalAtomic multi-step execution through ExecuteMultiCall.
User service
Server-definedProvider-defined service requests for custom application flows.
Bridge
Server-definedCross-network operations through the bridge service.
From schema to execution
Agentic API is built for developers who want structured access to Canton without manually rebuilding signing, settlement, and reconciliation infrastructure.
Inspect the service
Use gRPC reflection with grpcurl, Postman, BloomRPC, or another reflection-aware client.
Generate the client
Use proto definitions from silvana.ledger.v1 to generate client code in the language of your choice.
Choose the operation
Select a TransactionOperation and pass the matching params oneof for the workflow you need.
Prepare the transaction
Receive transaction hash, prepared transaction, command ID, transaction ID, and traffic estimate.
Sign inside your environment
Sign the prepared transaction hash locally using Ed25519.
Execute and reconcile
Submit the signature, receive status and update ID, then reconcile contracts, traffic, rewards, or errors.
Automate inside clear boundaries
Agentic API lets agents perform real operations while every state-changing action remains typed, prepared, signed, and explicitly authorized.
TransactionOperation
One typed, prepared, locally-signed, explicitly-authorized action — surrounded by six structural checks.
Typed operation
Each state-changing flow uses a specific TransactionOperation instead of an open-ended instruction.
Prepared hash
The server returns the exact transaction hash that must be signed before execution.
Local signature
The agent signs inside its own controlled environment, keeping private keys out of the platform.
Traffic estimate
The response includes expected traffic cost before execution, so apps can reason about fees.
Idempotency
The command ID helps applications avoid duplicate or inconsistent execution flows.
Structured result
Execution returns status, update ID, created contracts, traffic consumed, rewards, and provider errors.
Build workflows agents can actually run
Agentic API is designed for financial applications where agents do more than observe. They move assets, coordinate settlement, trigger services, and keep systems synchronized.
Agentic payments
Treasury automation
Payroll
DvP settlement
Application workflows
Reconciliation
Agent onboarding
Bridge flows
Proto in. Agents out.
Agentic API is defined through proto, supports gRPC reflection, and can be consumed from any language that works with gRPC. Agents can run in secure environments while web applications connect through SDKs and typed clients.
Use any language
Generate clients from proto definitions and integrate Agentic API into your backend stack.
Build with SDKs
Use SDKs for faster integration when you want typed helpers, examples, and agent-ready flows.
Run secure agents
Keep signing inside controlled local, server, or TEE-backed agent environments.
Inspect live services
Use GetServiceInfo and reflection to discover enabled groups and supported operations.
Get results your systems can trust
Execution does not end when a transaction is submitted. Agentic API returns the fields applications need to track, audit, retry, and reconcile operations.
{"update_id": "0192…aa","transaction_status": "EXECUTED","contract_id": "00ab…","created_contracts": [ … ],"traffic": { read, write },"provider_error": null,"rewards_amount": 0,}- update_id
- Canton update ID for the committed transaction.
- transaction_status
- Execution state such as EXECUTED or FAILED.
- contract_id
- Primary contract created by the transaction when available.
- created_contracts
- All contracts created — useful for change, split flows, and new assets.
- traffic
- Actual read, write, and total traffic consumed.
- provider_error
- Structured error when execution fails.
- rewards_amount
- Rewards data (amount and round) when applicable.
Connect the rest of the stack
Agentic API sits between agents, applications, and Silvana execution products.
Silvana Book
Use Agentic API to connect agents to private orderbook workflows, settlement events, RFQ logic, and trading automation.
SDK
Use the SDK to onboard agents, configure logic, simulate flows, and integrate Agentic API faster.
EarnHub
Connect successfully settled activity to rewards, challenges, leaderboard progress, and seasonal participation where available.
Go deeper into Agentic API
Read the technical references behind service setup, authentication, transaction flow, and operation types.
Not sure where to start?
Tell us whether you are building an agent, a Canton app, a wallet flow, a treasury workflow, or a settlement product, and we'll point you to the right API path.
Build agents that execute
Start with the API reference, generate a client from proto, or use the SDK to move faster.
Start with docs
Review service setup, authentication, transaction flow, and operation references.
Start with SDK
Use ready-made tools to onboard agents, configure flows, and call Agentic API faster.