Stop Reading, Start Running: The Volt Developer Hub is Live

Introducing the Volt Active Data Developer Hub – three guided paths for Kafka, SQL, and AI-agent builders, a browser sandbox backed by a live cluster, and everything in between to take you from setup to a working real-time application in under five minutes.

I have sat in on a lot of Volt evaluations, and the pattern repeats: the teams that end up adopting are almost always the ones who stopped reading and ran something. A spec sheet cannot close the gap between “sounds fast” and “I watched it be fast.” Running something does.

The new Developer Hub at developers.voltactivedata.com is built around that observation. It is not a documentation portal. Everything on it is set up to get you from zero to a working example in under five minutes – and when you just want to poke at the platform, the sandbox runs in your browser against a live cluster, with no install and no credit card.

Pick your path

What you should run first depends on what you are building, so the Hub is organized as three guided paths:

1. Kafka Developer – connect Volt to your existing Kafka cluster and make real-time, transactional decisions on streaming data in under 10 ms. No re-architecting your pipeline.
2. Database Developer – microsecond-to-millisecond ACID transactions with the SQL and stored procedures you already know, replacing the PostgreSQL-plus-Redis stack and its cache-consistency bugs.
3. AI Agent Builder – connect any MCP-capable agent to Volt’s native MCP server in one command and ground it in live transactional state.

Each path pairs a quick start with real use cases, video tutorials, and the reference documentation for that workload – plus an interactive architecture explorer when you want to see how the engine is put together.

What the platform actually does

All three paths sit on the same foundation. Volt collapses ingestion, storage, and logic into one transactional layer: instead of a database plus a cache plus consumer-side state, one system reads, decides, and writes in a single atomic step. It is the same property that lets a fintech ledger trust it.

The numbers below are the platform’s published figures. You do not have to take the latency ones on faith – the Hub’s sandbox runs against a live cluster, so you can watch them yourself:

Against a PostgreSQL-plus-Redis stack, that means sub-millisecond reads and writes instead of the multi-millisecond floor of a database-plus-cache round trip, zero cache-invalidation bugs instead of stale reads and warm-up delays after failover, and roughly half the hardware footprint.

This is not a new engine with unproven internals. Volt was designed by Turing Award winner Dr. Michael Stonebraker on a shared-nothing, partition-per-core architecture. Partitioned stored procedures execute without contention – no locks, no latches – so serializable isolation is a property of the design, not a mode you switch on and pay for in latency.

Kafka: from pipe to decision point

For streaming teams, Volt turns Kafka from a pipe into a decision point. Map Kafka topics directly to Volt stored procedures and the read-modify-write cycle disappears: ingestion, storage, and decision happen in one place, atomically, at more than a million transactions per second with predictable sub-10 ms latency. You get exactly-once semantics and total consistency across your streams without external caches or manual offset juggling – and because ACID is enforced at the point of ingestion, race conditions like double-booking and over-provisioning are prevented by design rather than patched after the fact.

AI Agents: one command to a source of truth

The newest path exists because agents are starting to act – approve a transaction, release inventory, apply a charge – and an agent that acts on stale or inconsistent data turns a wrong read into a real commitment. “Usually correct” stops being good enough the moment the model can write.

Volt ships a native Model Context Protocol (MCP) server – it comes with Volt Enterprise as the Active(MCP) license feature. Point Claude Code, or any MCP-capable agent, at a running Volt database with a single command, and the agent gets eight built-in tools covering schema discovery, ad-hoc SQL, stored procedure calls, and cluster introspection. No glue code, no custom integration layer:

$ claude mcp add voltdb -- \
	java -jar ~/voltmcp/volt-mcp-server.jar \
         --servers vmcserver

Register it once and the tools are there in every later session: the agent discovers the schema, queries live state, and – because the same tools cover writes and stored procedures – acts on it, each action a serializable transaction your auditors can trace. You scope it like any other client: give it a dedicated role, start read-only, and widen permissions as you learn to trust its behavior. The AI path on the Hub walks through the whole setup, credentials included.

None of this replaces vector search. Embeddings are the right tool for semantic recall over documents – they just are not a system of record. The two are complementary, and the difference matters the moment an agent has to act:

Use both: embeddings for unstructured knowledge, Volt for live operational truth.

To make an agent fluent in Volt before it touches live data, we also publish Volt Agent Skills – free, MIT-licensed instruction sets, on GitHub today: voltdb-development, voltsp, and voltdb-kubernetes. Drop one into your agent’s skills directory and it writes Volt applications the way our engineers do: correctly partitioned schemas, single-partition procedures, tested clients.

Available now

Everything below is live today at developers.voltactivedata.com:

• Quick-start repos, sample apps, and SDKs on GitHub to star, fork, and build on.
• Three guided paths – Kafka Developer, Database Developer, and AI Agent Builder – each taking you from setup to a working application in under five minutes.
• A browser-based sandbox that runs against a live cluster – no install, no credit card.
• An interactive architecture explorer, video tutorials, and per-path reference documentation.
• The MCP quick start – one command to connect Claude Code or any MCP-capable agent to live Volt data.
• Volt Agent Skills – free and MIT-licensed, on GitHub.

If you are replacing a database or a stream stack, open the sandbox and watch the latency for yourself. If you are building agents, connect one to Volt and ask it a question about your live data. Either way, you will know whether Volt fits in minutes, not weeks.

Prefer to watch first?

See the 60-second tour of the Developer Hub

Start building at developers.voltactivedata.com