Skip to content
BranchesTags

Repository files navigation

Airymax SDK — Multi-Language Developer Toolkit

Developer toolkit management repository for the Airymax AI Agent Runtime Platform. A management repo under the user-space engineering super-repo agent-workload in the airymaxhub umbrella.

Language: English | 简体中文

Version License Python Go Rust TypeScript

Overview

The sdk management repository is the developer-facing packaging layer of the Airymax platform. It aggregates 6 leaf repositories as git submodules and exposes a single, coherent developer surface for the Airymax AI Agent Runtime:

  • 4 language SDKs — Python, Go, Rust, TypeScript
  • 2 interactive tools — cli (command-line interface) and tui (terminal UI)

All four SDKs share the same architecture: each language SDK exposes an HTTP client layer (Client / APIClient) plus four business module managers — TaskManager (tasks), MemoryManager (memory), SessionManager (sessions) and SkillManager (skills). Agent applications built on these SDKs are runtime tenants — they invoke platform capabilities through the SDK over HTTP / JSON-RPC 2.0 rather than touching kernel internals directly.

This management repo only carries documentation, submodule wiring, and licensing. All implementation lives in the leaf repositories.

Repository Structure

sdk/                       # Management repository (this repo)
├── sdk-python/            # Python SDK leaf repo (submodule)
├── sdk-go/                # Go SDK leaf repo (submodule)
├── sdk-rust/              # Rust SDK leaf repo (submodule)
├── sdk-typescript/        # TypeScript SDK leaf repo (submodule)
├── cli/                   # cli leaf repo (submodule, directory name: cli/)
├── tui/                   # tui leaf repo (submodule, directory name: tui/)
├── .gitmodules            # Submodule definitions
├── LICENSE                # AGPL-3.0 + Apache-2.0 dual license full text
├── NOTICE                 # Copyright, trademark and third-party notices
├── README.md              # This file (English)
└── README_zh.md           # Chinese translation

Leaf Repositories

Module Directory Repository URL Language Description
sdk-python sdk-python/ git@atomgit.com:openairymax/sdk-python.git Python Python SDK (agentrt package, 3.8+)
sdk-go sdk-go/ git@atomgit.com:openairymax/sdk-go.git Go Go SDK (module github.com/spharx/agentrt/sdk/go/agentrt, Go 1.22+)
sdk-rust sdk-rust/ git@atomgit.com:openairymax/sdk-rust.git Rust Rust SDK (crate agentrt-rs, edition 2021)
sdk-typescript sdk-typescript/ git@atomgit.com:openairymax/sdk-typescript.git TypeScript TypeScript SDK (npm package @agentrt/sdk, TS 5.0+)
cli cli/ git@atomgit.com:openairymax/cli.git Rust Command-line interface tool for runtime ops
tui tui/ git@atomgit.com:openairymax/tui.git Rust Terminal UI tool for interactive agent sessions

Note: the cli and tui modules use the same name for both the directory and the repository — no sdk- prefix is applied to these two interactive tools.

SDK Architecture

Each SDK is a plain HTTP client for the AgentRT runtime. There is no native FFI binding to a Core C ABI — the SDKs talk to the Gateway directly over HTTP / JSON-RPC 2.0. Every language SDK exposes a low-level APIClient / Client for raw requests, with four idiomatic business module managers on top of it.

┌──────────────────────────────────────────────────────────────────┐
│  Business Module Managers (4 per language)                        │
│  TaskManager · MemoryManager · SessionManager · SkillManager      │
├──────────────────────────────────────────────────────────────────┤
│  HTTP Client Layer (APIClient / Client)                           │
│  agentrt (Python) · agentrt (Go) · agentrt-rs (Rust) ·            │
│  @agentrt/sdk (TypeScript)                                        │
├──────────────────────────────────────────────────────────────────┤
│  Transport: HTTP / JSON-RPC 2.0 (no native FFI / Core C ABI)      │
└──────────────────────────────────────────────────────────────────┘
        │
        ▼   HTTP / JSON-RPC 2.0
┌──────────────────────────────────────────────────────────────────┐
│  AgentRT Runtime (gateway_d) — kernel services & resource bus     │
└──────────────────────────────────────────────────────────────────┘

Upstream Dependencies

  • Runtime — connects to a running AgentRT instance (gateway_d) over HTTP / JSON-RPC 2.0.
  • Protocol — speaks the AgentsIPC protocol defined in the protocols/ management repo.
  • Configuration — runtime endpoints and credentials are managed by ecosystem/manager/.

Downstream Consumers

  • Agent applications — user-written agents that import a language SDK.
  • cli / tui — standalone Rust tools that talk to the Gateway over HTTP (they do not link the language SDKs).
  • Reference examples — agents under ecosystem/examples/.

Module Manager API

Each language SDK exposes an HTTP client plus four business module managers. The manager APIs are aligned across all four languages.

Manager Resource Layer Responsibilities
TaskManager Tasks Task submission, query, wait, cancel, list, batch operations
MemoryManager Memory Layered memory write / read / search
SessionManager Sessions Session lifecycle management
SkillManager Skills Skill registration, invocation, management 
Client (HTTP layer)
├── TaskManager    →  submit / get / wait / cancel / list
├── MemoryManager  →  write / read / search
├── SessionManager →  create / get / delete
└── SkillManager   →  load / invoke / list

Build & Install

Python (sdk-python)

pip install agentrt

Go (sdk-go)

go get github.com/spharx/agentrt/sdk/go/agentrt

Rust (sdk-rust)

cargo add agentrt-rs

TypeScript (sdk-typescript)

npm install @agentrt/sdk
# or: pnpm add @agentrt/sdk / yarn add @agentrt/sdk

CLI & TUI (cli / tui)

Both tools are Rust binaries distributed as part of the cli and tui leaf repos. Build them from source:

# Inside the cli/ submodule directory
cargo install --path .

# Inside the tui/ submodule directory
cargo install --path .

Tool boundary: three terminal entry points play complementary roles —

  • agentrt/tools/airy_cli (C, ships with the runtime source) — the runtime's built-in interactive entry point
  • sdk/cli (Rust) — developer-oriented ops CLI (scaffolding / config / market / deploy)
  • sdk/tui (Rust) — developer-oriented multi-panel interactive terminal UI All three talk to the runtime through the gateway (JSON-RPC 2.0, default http://localhost:8080); versions follow the release together (current 0.1.9).

Quick Start

All examples assume a running AgentRT instance at http://localhost:8080.

Python

from agentrt import AgentRT

client = AgentRT(endpoint="http://localhost:8080")

# Task: submit a task
task = client.submit_task("analyze quarterly metrics")

# Memory: write a memory record
memory_id = client.write_memory("quarterly metrics", metadata={"tag": "report"})

The agentrt.modules package additionally exposes the module managers (TaskManager, MemoryManager, SessionManager, SkillManager) for typed access.

Go

package main

import (
    "context"
    "fmt"

    "github.com/spharx/agentrt/sdk/go/agentrt"
    "github.com/spharx/agentrt/sdk/go/agentrt/client"
    "github.com/spharx/agentrt/sdk/go/agentrt/modules/task"
)

func main() {
    ctx := context.Background()
    c, err := client.NewClient(agentrt.WithEndpoint("http://localhost:8080"))
    if err != nil {
        panic(err)
    }

    tasks := task.NewTaskManager(c)
    t, err := tasks.Submit(ctx, "analyze quarterly metrics")
    if err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", t)
}

Rust

use std::sync::Arc;

use agentrt_rs::client::Client;
use agentrt_rs::modules::task::TaskManager;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new("http://localhost:8080")?;
    let tasks = TaskManager::new(Arc::new(client));

    let task = tasks.submit("analyze quarterly metrics").await?;
    println!("{:?}", task);
    Ok(())
}

TypeScript

import { AgentRTClient, withEndpoint } from "@agentrt/sdk";

const client = new AgentRTClient(withEndpoint("http://localhost:8080"));

// Task manager: submit a task
const task = await client.tasks.submit("analyze quarterly metrics");
console.log(task);

Branch Strategy

  • This management repo (sdk) — development happens directly on main.
  • Leaf repositories — active development happens on develop/hubs-01; each leaf's main is a release snapshot (synced once per release, not for day-to-day work).

Aggregation uses gitlinks (commit-hash pins). To clone this repo with submodules:

git clone --recurse-submodules git@atomgit.com:openairymax/sdk.git
cd sdk
git submodule update --init --recursive

License

Dual-licensed under AGPL v3 + Apache 2.0 (SPDX: AGPL-3.0-or-later OR Apache-2.0). You may choose either license at your option. See LICENSE for the full text of both licenses and NOTICE for copyright, trademark and third-party notices.

Dual License Guide

You may choose either license at your option — not both, not neither.

SPDX Expression: AGPL-3.0-or-later OR Apache-2.0

If you are... Choose Why
Building a SaaS or network service that modifies the SDK AGPL v3 Network service clause requires source disclosure
Developing open-source SDK derivatives (copyleft) AGPL v3 Derivatives must remain open-source under AGPL
Using the SDK in commercial closed-source products Apache 2.0 Permissive, allows proprietary derivatives
Building enterprise internal tools Apache 2.0 No source disclosure required
Needing patent protection Apache 2.0 Explicit patent grant from contributors
Just learning or researching Either Both permit personal use

For the authoritative license policy, see 12-license-policy.md.

Copyright (c) 2025-2026 SPHARX Ltd. All Rights Reserved.

About

No description, website, or topics provided.

Resources

Readme
License

Code of conduct

Code of conduct

Contributing

Contributing

Security policy

Security policy
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors