Blog
Product Releases
October 14, 2025
3 min read

Introducing the Volcano SDK to Build AI Agents in a Few Lines of Code 🌋

Marco Palladino
CTO and Co-Founder of Kong

Today, we're open-sourcing Volcano SDK, a TypeScript SDK for building AI agents that combines LLM reasoning with real-world actions through MCP tools.

Why Volcano SDK? One reason: because 9 lines of code are faster to write and easier to manage than 100+.

Without Volcano SDK? You'd need 100+ lines handling tool schemas, context management, provider switching, error handling, and HTTP clients. 

With Volcano SDK: 9 lines.

Look how we compress 100+ lines with the following example:

import { agent, llmOpenAI, llmAnthropic, mcp } from "volcano-ai";


// Setup: two LLMs, two MCP servers
const planner = llmOpenAI({ model: "gpt-5-mini", apiKey: process.env.OPENAI_API_KEY! });
const executor = llmAnthropic({ model: "claude-4.5-sonnet", apiKey: process.env.ANTHROPIC_API_KEY! });
const database = mcp("https://api.company.com/database/mcp");
const slack = mcp("https://api.company.com/slack/mcp");


// One workflow
await agent({ llm: planner })
 .then({
   prompt: "Analyze last week's sales data",
   mcps: [database]  // Auto-discovers and calls the right tools
 })
 .then({
   llm: executor,  // Switch to Claude
   prompt: "Write an executive summary"
 })
 .then({
   prompt: "Post the summary to #executives",
   mcps: [slack]
 })
 .run();

That's it. GPT-5 queries the database, Claude writes the summary, and it posts to Slack. Context flows automatically between steps. Tool schemas are discovered automatically. Errors are retried. All in 9 lines of actual workflow code.

✅ 4 lines of setup — Two LLMs, two MCP servers

✅ Multi-LLM workflow — GPT-5 analyzes, Claude writes

✅ Automatic tool selection — SDK picks the right tools

✅ Chainable steps — Read like a story

✅ Context flows automatically — Each step sees previous results

✅ Production-ready — Built-in retries, timeouts, telemetry

Start building AI agents at volcano.dev.

Why we created Volcano SDK

At Kong, we build a lot of AI agents. Each time, we ended up writing the same code: managing conversation history, handling tool schemas, switching providers, implementing retries, connecting to MCP servers.

We looked at existing options:

  • LangChain: Powerful, but heavy. Too many abstractions between us and what we wanted to do.
  • Provider SDKs (OpenAI, Anthropic): Great for single calls, but no help chaining steps or managing context across providers.
  • Other agent frameworks: Either too opinionated or missing basic features like streaming and proper error handling.

We just wanted to chain LLM calls with different providers and use MCP tools without writing infrastructure code every time. It should be simple:

  1. Call an LLM 
  2. Maybe use some tools 
  3. Call another LLM with different strengths 
  4. Chain it all together without losing context

So, we built Volcano SDK. And now you can start building with it.

What makes Volcano SDK different?

There are a few core concepts that you will find across Volcano that separate it from the pack:

  • MCP is a first-class citizen: Tools are as natural as prompts. Pass an array of MCP servers, and the LLM automatically discovers and calls the right tools.
  • Volcano SDK is multi-provider by design: Use GPT-5 for planning, Claude for writing, Llama for classification — all in the same workflow. Context flows automatically between them.
  • Volcano prioritizes chainable simplicity: Our code reads like your intent. No state machines. No middleware hell. Just .then() your way to production. 
  • It’s production-ready out of the box: OpenTelemetry tracing, automatic retries, configurable timeouts, connection pooling, OAuth support — the boring stuff you need, built in.

We wanted to write agents like we write promises: one elegant chain that does exactly what it says, with the right tool for each job:

wait agent({ llm: planner })
 .then({ prompt: "Analyze data", mcps: [db] })
 .then({ llm: executor, prompt: "Write summary" })
 .then({ prompt: "Post to Slack", mcps: [slack] })
 .run();

Volcano is focused on one thing: multi-step workflows that mix different LLMs and MCP tools. It's TypeScript-first, type-safe, and small enough to understand in an afternoon, and it comes packed with easy-to-use features and multi-LLM support.

Get started building AI agents with Volcano SDK

It’s time to start delivering on the agentic promise. It’s time to start building powerful AI agents with the Volcano SDK at volcano.dev. We can’t wait to see what you build.

Topics:Agentic AI
|
LLM
|
AI
|
Open Source