Questions we get from infra teams.

Source events get committed to the Solana coordinator in the next slot (~400ms). The Core Engine watches the coordinator, packages the destination payload, and a competing relayer pool races to land it on the destination — usually within the same wall-clock budget.

Yes — MIT-licensed. The monorepo contains the Solana programs, the Customer API, the Core Engine, the SDK, and a demo app. The managed service adds relayer ops, signing infrastructure, and observability.

Each route declares a finality policy: fail-open (use the last confirmed coordinator state and continue), fail-closed (pause until the coordinator catches up), or fallback (switch to a secondary verifier). Defaults are conservative.

Yes. `npm run docker:up` brings up both services with Postgres or Mongo. You still need to run relayers and configure signers, which is what most teams end up paying us for.

Switchboard ships a verifier per destination: light-client proof where the chain supports it, BLS threshold signature from the relayer pool otherwise, and zk-proof receipts on chains that natively verify them. You can mix and match per route.

New chains land roughly monthly. If you have a specific chain blocking adoption, Enterprise customers can sponsor a chain integration with a 6-week ETA.

Arbitrary opaque payloads. Adapters handle on-chain encoding. The protocol does not assume a token model.

Either MongoDB or PostgreSQL — both are first-class. MongoDB is the default in docker-compose; switch with DATABASE_TYPE=postgresql. The Core Engine abstracts the persistence layer so you pick whichever your ops team already runs.

No. Cryptuon Switchboard is a cross-chain state-synchronization and coordination platform — it uses Solana as a coordination clock so one contract or agent can act across 50+ chains. It is unrelated to, and distinct from, the well-known Solana "Switchboard" oracle network. We do not serve price feeds; we synchronize and coordinate state across chains.

An agent making agentic payments or executing intents integrates once and issues a single call that fans out to every target chain through the Solana coordinator, sub-400ms end-to-end, with a verifiable receipt per destination. That replaces N bespoke bridge integrations — each with its own trust model and failure mode — with one coordination layer the agent reasons about as a single finality clock.

A write commits once to the coordinator and propagates to every destination inside one latency budget, each with a per-route finality policy (fail-open, fail-closed, or fallback) and a verifiable receipt. Instead of orchestrating a sequence of independent bridge calls that can partially fail in hard-to-reason-about ways, cross-chain state becomes a single composable action against one finality clock. Where destination chains allow it, batched commits carry all-or-nothing semantics.

Every extra bridge is another validator set, message format, quorum time, and on-call rotation. Switchboard collapses that onto one Solana coordinator every chain agrees to watch, so adding a destination chain does not add integration code on your side — the coordinator and per-chain adapters absorb the fan-out. You maintain one SDK surface, not one per corridor.