SDK

Build Directly on the Kernel

HexaKernel is not only a runtime to execute domain-native software. It is also a platform developers can build on.

The SDK provides the tools, libraries and interfaces developers need to create applications, capabilities and extensions that run on top of the HexaKernel execution layer.

Where APIs make the domain accessible from outside, the SDK gives developers a direct way to build within the HexaKernel ecosystem.

The API exposes the domain.
The SDK lets you build on it.

From Using the Platform to Building on It

An API allows an application, service or agent to interact with capabilities exposed by HexaKernel.

The SDK goes one step further.

It provides a development-oriented interface for creating software that uses the Kernel as its foundation.

Developers can work with domain capabilities, operations, events, resources and execution contexts without having to reconstruct the infrastructure underneath them.

The goal is simple:

Build your application around the domain, while HexaKernel provides the execution foundation.

A Developer Interface to the Kernel

The SDK becomes the practical bridge between application code and the Kernel.

It can provide consistent interfaces for:

• Domain resources

• Operations and commands

• Events and event handling

• Domain state and transitions

• Authentication and authorization

• Execution contexts

• Integrations

• Observability

• Error handling

• Testing and validation

These capabilities are exposed through developer-oriented abstractions rather than forcing every application to understand the underlying runtime mechanisms.

The result is a development experience aligned with the architecture itself.

Build Capabilities, Not Infrastructure

Traditional application development often requires teams to repeatedly implement the same foundations:

authentication, authorization, permissions, event handling, auditing, integrations, execution patterns and operational infrastructure.

HexaKernel moves those concerns into the Kernel.

The SDK lets developers focus on the capabilities that make their application unique.

Instead of rebuilding the foundation, developers extend it.

Instead of reproducing infrastructure, they build domain capabilities.

Instead of making every application responsible for its own runtime model, they build on a shared execution layer.

The Kernel provides the foundation.
The SDK provides the means to build on it.

Domain-Native Development

The SDK is designed around the same principle that defines HexaKernel:

the domain comes first.

Developers should be able to work with concepts that correspond to the business domain rather than forcing those concepts into infrastructure-specific abstractions.

A marketplace developer works with offers, participants, availability, matching and transactions.

A logistics developer works with shipments, routes, resources, constraints and operational events.

A financial developer works with accounts, transactions, products, policies and controls.

The SDK provides the developer interface through which these domain capabilities can become executable software.

Extend the Kernel

The SDK is not limited to consuming existing functionality.

It is the foundation for extending the platform.

Developers can build new capabilities that operate within the HexaKernel execution model while inheriting the foundations already provided by the Kernel.

This creates a layered development model:

Domain → Specification → Kernel → SDK → Application Capabilities

Each layer has a clear responsibility.

The specification defines what the domain means.

The Kernel provides the execution foundation.

The SDK gives developers the tools to build.

The application provides the domain-specific capabilities.

Build for Humans and Agents

HexaKernel is designed for a world where software is increasingly built and operated by both humans and AI agents.

The SDK provides a structured development surface that can be used by developers directly and can also serve as a foundation for AI-assisted development.

Because the underlying domain and execution model remain explicit, AI systems do not have to infer the entire application architecture from source code alone.

They can build against known domain capabilities and Kernel primitives.

Developers build with the SDK.
Agents can build with the same foundation.

Designed to Evolve

The SDK sits above the Kernel, which means applications can evolve without having to recreate the underlying execution foundation.

As the domain specification evolves, new capabilities can be introduced.

As the Kernel evolves, developers gain new platform capabilities.

As AI development tools evolve, they can operate against the same underlying system.

This separation allows the development experience to evolve without making the domain dependent on a particular development model.

From SDK to Documentation

The SDK is where developers build.

Documentation is where they understand how to build.

The next layer of the developer experience explains the concepts, interfaces, workflows and examples that make the SDK usable — from the first experiment to production development.

The SDK provides the tools.

Documentation provides the knowledge.

Together, they turn HexaKernel from an execution platform into a platform developers can understand, use and extend.

The Developer Platform

HexaKernel provides more than an API for accessing software.

It provides an execution foundation developers can build upon.

The SDK connects that foundation with the developer.

Build directly on the Kernel.

The SDK turns the Kernel into a developer platform.