A modular microkernel platform for building thinking systems.
Compose intelligent agents from isolated, interchangeable modules.

Pons is a microkernel platform that runs intelligent modules as isolated processes, coordinated through a central kernel via IPC. Think of it as a minimal, composable OS for AI-powered systems — where every capability is a module, nothing is hardcoded, and the kernel stays thin.

"The smallest seed of a thinking system." Modules never import each other directly. All communication — events, RPC calls, config updates — flows through the kernel. This makes the system hot-swappable, observable, and easy to extend.

┌──────────────────────────────────────────────────────┐
│                        Kernel                        │
│                                                      │
│   ┌─────────────┐  ┌──────────────┐  ┌───────────┐  │
│   │  Message Bus │  │   Lifecycle  │  │ Service   │  │
│   │  (pub/sub)   │  │   Manager   │  │ Directory │  │
│   └──────┬──────┘  └──────┬───────┘  └─────┬─────┘  │
└──────────┼───────────────┼────────────────┼─────────┘
           │               │                │
      ┌────┴──┐       ┌────┴───┐      ┌────┴────┐
      │ Agent │       │  LLM   │      │ Gateway │  ...
      └───────┘       └────────┘      └─────────┘
       process          process         process

Modules communicate only through the kernel. Hot-swap, restart, and discovery are built in.

You can install Pons using the automated install scripts, which will handle Deno installation if needed:

For macOS and Linux:

curl -fsSL https://raw.githubusercontent.com/usepons/.github/main/install.sh | sh

For Windows (PowerShell):

irm https://raw.githubusercontent.com/usepons/.github/main/install.ps1 | iex

Alternatively, install Pons via the CLI directly (requires Deno):

deno install -gA -n pons jsr:@pons/cli

Once installed, start your Pons system:

pons install && pons onboard

To build your own module, use the SDK:

# deno.json
{
  "imports": {
    "@pons/sdk": "jsr:@pons/sdk@^0.2"
  }
}

import { ModuleRunner } from "@pons/sdk";
import type { ModuleManifest } from "@pons/sdk";

class MyModule extends ModuleRunner {
  readonly manifest: ModuleManifest = {
    id: "my-module",
    name: "My Module",
    description: "Does something useful",
    subscribes: ["some.topic"],
  };

  protected override async onMessage(topic: string, payload: unknown) {
    this.log("info", `Received: ${topic}`);
  }
}

new MyModule().start();

Message Bus — Modules publish and subscribe to topics. The kernel routes messages. No persistence, no retry — pure fire-and-forget.

RPC — Request/response calls between modules go through the kernel's service directory. The kernel resolves service names to module IDs and routes responses back with a 30s timeout.

Module Lifecycle — Each module runs as an isolated child process. The kernel handles spawn, kill, restart with exponential backoff, and hot-swap.

Service Directory — Modules declare what they provides and requires. The kernel ensures dependencies are satisfied before a module activates.

Configuration — Layered YAML config at ~/.pons/config.yaml. Modules own a config section. Hot-reload via SIGUSR1.

All repositories follow the same contribution guidelines. See CONTRIBUTING.md in the kernel repo to get started.

_{Built with 🖤 by CyberWolf.Studio · Powered by Deno · MIT Licensed
© 2026 Pons · github.com/usepons}