Give agents a controlled way to act on Canton.
Agentic API turns Canton transactions into typed operations that applications can prepare, verify, sign, execute, and reconcile through one gRPC interface.
Define the logic. Keep signing inside your environment. Receive a structured result.
One controlled interface for Canton execution.
One gRPC surface
Connect agents and backend applications to Canton through one consistent service layer.
Typed operations
Use explicit operation types for transfers, payments, DvP, recurring workflows, multicall, and service requests.
Local signing
Prepare the transaction through Silvana, then sign the exact transaction hash inside the approved environment.
Structured results
Receive status, update references, created contracts, traffic information, and errors in a form applications can store and reconcile.
Canton execution without rebuilding the machinery.
Applications should be able to focus on the asset workflow they are creating. They should not have to reconstruct transaction preparation, signing, party coordination, settlement state, and reconciliation for every new product.
Transaction construction
Agentic API translates supported workflows into explicit operations with known request and response structures.
Authorization
Agentic API prepares a defined action and gives the client a specific hash to verify and sign.
Workflow composition
Payments, transfers, settlement, recurring operations, and provider services come into one service model that can be composed around the application.
Reconciliation
Agentic API returns the references and structured fields required to track, audit, retry, and recover.
Prepare. Verify. Sign. Execute. Reconcile.
Every state changing operation follows the same explicit path.
Prepare
The client selects a supported operation and sends the matching parameters. Silvana returns the prepared transaction, its hash, a transaction identifier, a command identifier, and the expected traffic requirement where available.
Verify
The application checks the operation, recipient, asset, amount, traffic estimate, and expected result before authorization.
Sign
The approved environment signs the prepared transaction hash. Private key material remains inside the client, agent, server, or trusted execution environment responsible for authorization.
Execute
The client submits the transaction identifier and signature. Silvana sends the authorized transaction into the relevant Canton workflow.
Reconcile
The application stores the execution status, update identifier, created contracts, traffic usage, and structured errors for tracking and recovery.
The operation is defined before it is authorized. The result is structured after it executes.
One interface for the workflows behind real applications.
Payments and transfers
Support Canton Coin transfers, CIP 56 token workflows, split operations, and other approved asset movements.
DvP settlement
Propose, accept, allocate, execute, and follow Delivery versus Payment workflows through final settlement.
Recurring operations
Create prepaid, usage based, or scheduled payment flows where the enabled environment supports them.
Multicall
Combine multiple supported operations into one coordinated execution request.
User services
Request provider defined actions through a typed service interface instead of creating a new integration for every workflow.
Live state
Read balances, active contracts, ledger position, updates, and supported service information through the same platform layer.
Agent onboarding
Register agents, follow onboarding status, and connect the resulting Canton identity to permitted workflows.
Bridge operations
Use bridge related services where they are enabled for the current environment.
Expose the right capabilities for each environment.
Agentic API organizes operations into functional groups. This allows an application or service environment to expose the required surface without enabling every available operation.
Core
Read service information, balances, active contracts, ledger position, and updates.
Transfer
Enable approved Canton Coin transfer and split workflows.
DvP and CIP 56
Enable settlement operations and token transfer workflows where supported.
Recurring and multicall
Enable repeated payment models and coordinated multi operation execution.
Onboarding
Enable agent registration, onboarding status, configuration, and signatures.
User service and bridge
Expose provider defined workflows and bridge operations when the server supports them.
Applications can inspect the live service and discover which operations are enabled before they build the workflow.
Real operations inside explicit boundaries.
Agentic API gives agents the ability to act while preserving clear controls around what is prepared, what is signed, and what is returned.
Typed operation
Every state changing flow uses a defined operation rather than an open ended instruction.
Prepared hash
The service returns the exact transaction hash that requires authorization.
Local signature
The approved environment signs locally, keeping private key material out of the platform.
Traffic estimate
Where available, the preparation response gives the application visibility into expected traffic requirements before execution.
Command identity
Command and transaction identifiers help applications manage retries and reduce inconsistent duplicate execution.
Structured response
Execution returns a known set of fields for status, contracts, traffic, rewards, and provider errors where applicable.
Use the stack your system already trusts.
Agentic API is defined through proto and supports standard gRPC tooling. Generate typed clients for the language your backend uses, or integrate through an SDK when you want higher level helpers and established workflow patterns.
One contract. Any backend stack.
Use reflection to inspect the service, generate the client, then connect the operation model to your application logic.
Inspect the live service
Use gRPC reflection and service information to discover methods, functional groups, and supported operations.
Generate the client
Create typed client code from the proto definitions in the language of your choice.
Build the workflow
Select the operation, provide the matching parameters, and connect it to the application logic.
Run in the right environment
Keep authorization inside local infrastructure, a managed runtime, or a trusted execution environment according to the security model.
A transaction result your systems can use.
update_id
The Canton update reference for a committed transaction.
transaction_status
The current execution result, such as executed or failed.
contract_id
The primary contract created by the operation when one is available.
created_contracts
The full set of contracts created by the transaction, including change or split outputs where relevant.
traffic
The actual read, write, and total traffic consumed by the operation where reported.
provider_error
A structured error returned by the service or provider when execution does not complete.
rewards_amount
Reward information returned by eligible workflows where the environment supports it.
Give agents work they can actually complete.
Agentic payments
Prepare and execute token payments, Canton Coin transfers, recurring requests, and approved payment flows.
Treasury automation
Coordinate transfers, allocations, multicall operations, and other controlled asset movements.
DvP settlement
Build applications that propose, allocate, execute, and track settlement through Canton.
Application services
Connect agents to provider defined actions without building a separate protocol for every service.
Reconciliation
Subscribe to updates, inspect active contracts, and keep internal systems aligned with the executed ledger state.
Agent onboarding
Register an agent, receive its Canton identity, and connect it to the operations permitted by the environment.
Move from execution primitives to complete products.
Agentic API is the execution interface inside the broader Silvana stack.
Connect agents to trading, settlement, and application workflows, then use the SDK when you want a faster path to a running agent.
Execution stack
Read the references behind the interface.
Build agents that can complete the workflow.
Start with the API reference, generate a client from the proto definitions, or use the SDK to reach a working integration faster.