Devkit Pte. Ltd. · agent-first infrastructure

Describe the task.
Get a typed SDK.
Skip the plumbing.

Stop rebuilding program context, account layouts, IDL handling and data-access boilerplate for every project. A developer — or an AI agent — states the intent. solanasdk.com provisions the backend infrastructure and emits a small, strongly typed SDK shaped to exactly that task.

npx solanasdk init --intent "top Raydium pools by 24h volume"
solanasdk · intent → infrastructure

The tax nobody budgets for

Every team rebuilds the same
chain-specific plumbing.

Shipping anything real means understanding dozens of individual programs, deriving accounts and seeds correctly, decoding raw RPC responses, joining state across programs, and then maintaining the retrieval pipeline forever. It is weeks of work that produces no product differentiation.

Without a data layer~3 weeks
  1. Read each program's source or reverse-engineer its layout
  2. Track down a current IDL — or hand-write the struct
  3. Derive PDAs, seeds and bump values by trial and error
  4. Decode base64 account data into usable types
  5. Write cross-program joins for anything non-trivial
  6. Build caching, backfill and reconnect logic for RPC
  7. Re-do all of it when a program upgrades
Result: brittle pipeline, unowned maintenance, no types.
With solanasdk.com~15 minutes
  1. State the task in plain language or a CLI flag
  2. Platform selects the relevant programs and decoders
  3. Backend retrieval and transform services are provisioned
  4. A minimal typed SDK is generated for your stack
  5. Schema-validated streams keep data flowing
  6. Program upgrades are absorbed by the maintained layer
  7. You write product code, not decoders
Result: typed surface, hosted retrieval, one dependency.

Platform

Infrastructure that understands
the programs you build on.

Generic RPC gives you bytes. We give you meaning — program-aware decoding, validated schemas and hosted execution, all behind one typed interface.

01 — CORE

Intent-driven provisioning

Describe the product or data task and the platform decides what infrastructure it needs: which programs to index, which accounts to watch, what transforms to run and what shape the returned data should take. The generated SDK exposes only that surface — no thousand-method client to read through.

02

Program-aware decoders

Maintained decoders for major venues turn raw account and instruction data into typed structures, including nested and versioned layouts.

03

IDL search & upload

Search a growing registry of interface definitions, or upload your own program's IDL and get the same decoding, typing and query support instantly.

04

Cross-program queries

Join state that spans multiple programs in a single request — a position, its market, its oracle and its vault — without orchestrating calls yourself.

05

Schema-validated streams

Subscribe to changes with a guaranteed shape. Malformed or unexpected payloads are caught at the boundary instead of crashing your consumer.

06

Hosted retrieval & transformation

Fetching, normalisation, aggregation and caching run as managed services. Backfills, reconnects and rate-limit handling are our problem, not something you rediscover in production at 3am.

07

Built for autonomous callers

Machine-readable capability descriptions, deterministic typed responses and predictable errors make the platform safe for AI agents to call directly — the generated SDK is small enough to fit in a model's working context.

Generated output

One intent. Your stack.

The same task description produces idiomatic output for TypeScript, Rust and React — distributed through npm, npx and Cargo.

intent.txtinput
# plain language, no schema required
"Track every Kamino lending reserve,
 expose current supply APY and
 utilisation, and stream updates
 when a rate moves more than 5 bps."
reserves.tsgenerated
import { createClient } from "@solanasdk/kamino-reserves";

const sdk = createClient({ apiKey: process.env.SDK_KEY });

// fully typed — no decoding, no PDAs
const reserves = await sdk.listReserves();

reserves.forEach(r => {
  console.log(r.symbol, r.supplyApy, r.utilization);
});

// schema-validated stream
sdk.onRateChange({ minBps: 5 }, e => {
  alert(`${e.symbol}: ${e.from} → ${e.to}`);
});

Program coverage

The venues people actually integrate.

Initial coverage targets the programs that appear in the majority of real integrations. Anything else can be added by uploading an IDL.

Raydium AMM · CLMM Meteora DLMM Orca Whirlpools Jupiter routing Kamino lending · vaults MarginFi lending Drift perps Tensor NFT markets Metaplex metadata SPL Token core Your program upload IDL

Who it serves

Humans and agents, same interface.

01

Application developers

Ship a feature that needs on-chain data without becoming an expert in six programs first.

02

Protocol teams

Publish your IDL and give integrators a typed, documented surface on day one.

03

AI-agent builders

Give an agent a compact, deterministic tool surface it can call reliably and reason about.

04

Analytics products

Backfilled, normalised, validated data instead of a fragile scraper and a spreadsheet of edge cases.

05

Trading systems

Low-latency streams with a guaranteed schema, so a payload change never silently corrupts a signal.

06

Wallets & chat apps

Render positions, prices and history inside a wallet, a Telegram bot or any conversational surface.

Pricing

Usage-based. No seat tax.

You pay for hosted data access, generated SDKs, streaming and backend execution. Team and enterprise plans raise limits, extend retention and add private integrations.

Builder

Free / to start

  • Generate SDKs across all supported stacks
  • Hosted retrieval within starter limits
  • Public program coverage
  • Community support
Create a key

Scale

Metered / per request & stream

  • Everything in Builder
  • Higher throughput and concurrency
  • Schema-validated streaming
  • Extended history retention
  • Custom IDL uploads
  • Email support with response targets
Talk to engineering

Enterprise

Custom / annual

  • Dedicated capacity and regions
  • Private program integrations
  • Long-term retention
  • Direct support channel
  • Security and compliance review
Contact sales

FAQ

Engineering questions.

Is this a wrapper around an RPC provider?
No. RPC returns raw account bytes and leaves interpretation to you. We maintain program-aware decoders, run hosted retrieval and transformation, resolve cross-program relationships, and generate a typed client for the specific task you described.
What exactly does "generated SDK" mean?
A small package containing only the types and methods your task requires, published for your language. Because it is scoped, it stays readable by a human reviewer and small enough to sit inside an AI agent's context window.
What happens when a program upgrades its layout?
Decoders are versioned and maintained as part of the platform. Where a change is breaking, the schema layer surfaces it explicitly rather than returning quietly wrong values.
Can I use my own program?
Yes. Upload the IDL and your program receives the same decoding, cross-program query support and SDK generation as the built-in coverage.
Do I have to use the generated SDK?
No. Everything is available over the API directly. The SDK is a convenience layer for teams that want typing and ergonomics without writing the client themselves.
How do you handle keys and signing?
The platform is a read, transform and streaming layer. Transaction signing stays in your application or wallet — we never request or hold private keys.

Get started

From intent to integration
before your coffee cools.

Create a key, describe the task, install the generated package. If it takes longer than fifteen minutes, tell us and we will fix it.