Developers

What to build with Silvana.

An SDK that puts a trading agent on Canton without a line of Daml, two gRPC surfaces that reach the ledger and the book, and an agent kit whose model arrives already trained. Read the crate first — it is all open.

Explore the SDK Read the docs

Why bother

The agent works. You do not have to be there.

An agent you configured on Silvana keeps quoting, rebalancing and settling while you are not at the desk. Coming back to it means typing a sentence at it — or saying one.

The problem

Canton is not the hard part. Getting to it is.

An app that trades on Canton needs prices, a ledger, settlement, venues and a key that never leaves your side. Sourced separately, that is five integrations to write and five to keep working.

without-silvana.log

// five sources, five schedules, five ways to break

with-silvana.log

// one hub, one interface, one thing to keep working

the-week-you-lose.txt

Before the first order

Ledger client, message signing, order lifecycle, reconnection, a settlement watcher. None of it is your edge, and all of it has to be right before your edge gets to run at all.

the-week-after.txt

And then it moves

Every venue changes its own shape on its own schedule. Five integrations means five upgrades you did not plan, arriving in an order nobody chose.

one-hub.txt

One interface instead

Silvana is the access layer. Prices, ledger operations, settlement and the venue clients arrive through surfaces that are versioned together, so there is one thing to keep working.

Why here first

Build against the hub, reach the network.

If you are going to touch more than one venue on Canton, the adapters are already written — and they sit behind the same interface as everything else Silvana exposes.

90
Agent crates you can fork: 6
Venue clients behind one interface: 32
Canton operations already wired: 5
Book services on gRPC

adapters

The venues are already wired

The arbitrage agent ships six venue clients — centralized exchanges and Canton venues alike — behind one shared client interface, with the wire types mirrored from a schema that is the source of truth. Reaching a second venue is a client, not a project.

// packages/*-client — one interface, six implementations

open-core

You can read all of it

Ninety agent crates, each with its own doc and a demo that runs without a signup. The fastest way to judge an SDK is to read something built on it, which is why none of this is behind a sales call.

github.com/SilvanaOne

The section

Four doors, in the order most people use them.

Each one goes straight to what is behind it. Nothing on this page needs reading twice before you open one.

01Rust crates + CLI

Explore SDK

The shortest path from a strategy to an agent placing orders on Canton. Signing, key handling, order lifecycle and configuration are already written; what you add is the logic that makes the agent yours.

No Daml, no ledger plumbing — the communication layer is abstracted away
Local signing, so custody never changes hands
agent.toml plus a CLI, instead of a bespoke deployment story
Ninety crates to start from, each with a doc and a running demo

Explore the SDK

02Two gRPC surfaces

Explore API & gRPC

Both surfaces are gRPC; they differ in what they reach. One is Canton itself — transfers, DvP, CIP-56, recurring payments. The other is the Book's own services. Knowing which you need takes about a minute.

Agentic API: the Canton ledger, callable from any language with a gRPC client
Book gRPC: execution, pricing, settlement, ledger gateway and news
Two-phase prepare → sign → execute, so the key stays yours
Ed25519 message-level signing, with reflection for tooling

Explore the APIs

03Templates + runtime

Explore Agentic Kit

The part that makes an agent an agent: a catalogue of working templates, the runtime that keeps them alive, and the archetypes that decide what kind of thing is doing the work.

Fork a template rather than start from a blank file
Six families, from execution through compliance
Deterministic automation, oracles, models, or a person in the loop
Every template ships a crate, a doc.md and an open demo

Explore the Agentic Kit

04Models, already trained

Autonomous AI Stack

Put a model over your strategy without standing up an ML practice first. Silvana supplies the model attached to the agent and trained for the job, so the work you do is your logic — not model selection, not a training run.

The model is a component: swap it, run two, compare them
Arrives trained for the trading tasks the catalogue covers
Runs inside secure enclaves for the archetype that needs one
Deploys onto the same SDK as everything else

See the autonomous stack

Start

Zero to an agent placing orders.

The quickstart is the shortest complete path — toolchain, keys, a configured agent, a live order. Everything else on this page is a detour off it.

SDK quickstart Explore the SDK