Quick Summary

JAM turns the Polkadot relay chain into a modular, scalable blockchain computer built for developers.

• Instead of deploying parachains, you deploy services that handle logic, state, and messaging.
• Work items replace transactions, eliminating mempools, gas bidding, and congestion.
• The RISC-V-based Polkadot Virtual Machine delivers high performance, easy customization, and hardware flexibility.

‍

Polkadot’s next major evolution, JAM, gives developers full control by reimagining the relay chain as a modular, scalable, and transactionless blockchain.

For developers working on dApps, parachains, rollups, or custom blockchain logic, JAM offers a permissionless and developer-friendly platform that simplifies and speeds up app deployment. It limits on-chain activity to only what's absolutely necessary to avoid bottlenecks. This makes JAM leaner, faster, and easier to scale, without losing the ability to support complex computation and applications.

JAM’s modular approach replaces rigid chain design with flexible, service-based computing. It offers developers the following:

• Full access to compute and state 
• No need for governance approval
• A virtual machine optimized for blockchain 
• Built-in support for rollups and cross-chain messaging 
• Scalable execution via coretime 

‍

Services: The Core Building Blocks

Instead of deploying parachains, JAM introduces the concept of services. Each service is a self-contained module that includes executable code, internal state, account balance, and defined entry points for execution. A service behaves like a smart contract, rollup, or custom runtime depending on what you build. You can launch services to handle application logic, run computation, process rollup data, manage state machines, or govern protocol rules.

Services interact with the JAM chain through three main entry points:

1. Refine is the first step. It’s fast, stateless, and runs in parallel, which means it doesn’t store any data between runs and can process many tasks at the same time. Refine is where most of the heavy lifting happens—it takes up to 15MB of input data per time slot, processes it, and reduces it down to a lightweight 90KB result. This makes it incredibly efficient for computation-heavy tasks.
2. Accumulate comes next. It’s slower, but it's where all the state changes happen—meaning it remembers, stores, and updates the blockchain’s data. This layer writes results to storage, transfers funds, creates new services, or even upgrades code. In other words, this is where JAM finalizes and locks in the changes from Refine.
3. onTransfer is a special system that acts like a mailbox for services. It handles delayed or scheduled communication between services—letting them send and receive messages or value, even if they’re not interacting at the same moment.

By splitting these responsibilities, JAM keeps execution clean and efficient. Refine handles fast, stateless processing; Accumulate takes care of important state updates; and onTransfer ensures services can talk to each other when needed. This modular structure not only boosts performance but also ensures each service runs independently, without interfering with others.

Anyone can permissionlessly add services to the chain by specifying these three entry points. Together, they allow for parallel execution, high throughput, and greater design flexibility.

Image Source: Polkadot Wiki

Transactionless Architecture

Unlike most blockchains, JAM does not use transactions as its primary input. Instead, it processes work items, which are structured units of computation that are grouped into work packages. These packages are then refined off-chain and committed on-chain. Just as parachains are now called services, what used to be called a block or transaction is now called a work-item or work-package.

This shift to a transactionless model eliminates many of the problems seen in traditional chains. There’s no mempool, no fee bidding, no front-running, and no global congestion from unrelated apps. Your service processes its own workload independently.

Image Source: Parity.io

The Polkadot Virtual Machine

To support this new computation model, JAM introduces the Polkadot Virtual Machine (PVM), a purpose-built execution environment based on RISC-V, a modern, open-source instruction set architecture. JAM shifts away from WebAssembly (WASM), which has been the standard virtual machine for blockchain platforms.

While WASM is fast, secure, and widely adopted, it was originally designed for the web, not blockchain. Because of that origin, it carries certain architectural assumptions and constraints that don’t always align with the needs of decentralized, multi-core blockchain systems. For example, WASM's stack-based model makes handling asynchronous tasks like continuations more complex. It also lacks the low-level extensibility that developers often need when building cryptographic functions.

In contrast, RISC-V was created to be minimal, modular, and highly extensible. It’s open for anyone to use or modify, making it ideal for blockchain environments that demand both flexibility and performance. With RISC-V, the PVM can be tailored to suit JAM’s unique architecture. This allows developers to build more complex programs that aren’t limited by WASM’s design and validators to execute that code more efficiently across a wide range of hardware.

 This makes JAM’s PVM:

• Hardware-friendly: JAM can run on a wide variety of devices, encouraging greater decentralization and diverse validator participation.
• Efficient: With fewer layers and cleaner design, RISC-V enables faster execution and better performance, especially in computation-heavy workloads like rollups.
• Customizable: Because it’s modular, you can tailor the PVM to the needs of decentralized systems without being locked into outdated or rigid VM standards.
  
  

Built-In Support for Messaging and Interoperability

To allow services to send data  and communicate between chains, JAM offers full XCMP (Cross-Chain Message Passing) support. It also introduces Accords, which are multi-shard smart contracts designed for shared state and coordination across parachains and services.

You can say that JAM represents a major turning point for Polkadot. It shifts the architecture away from slot-based governance toward a modular, service-oriented model that can support any type of blockchain workload.  For developers, it offers full control over the execution environment through a streamlined foundation where innovation can scale without friction and where any blockchain application can be deployed with ease.

‍