Cloudless Sky

Agentic AI mesh without the cloud.

OSMP (Octid Semantic Mesh Protocol) is an open encoding standard for agentic AI instruction and computation exchange. It works across any channel — from a 51-byte LoRa radio packet to a high-throughput cloud inference pipeline — using the same grammar, the same dictionary, and the same decode logic.

No cloud required. No inference at the decode layer. No central authority.

Install

pip install osmp                  # Python SDK
pip install osmp-mcp              # MCP server (Claude Desktop, Cursor, Claude Code)
npm install osmp-protocol         # TypeScript SDK
cargo add osmp                    # Rust SDK
go get github.com/octid-io/cloudless-sky/sdk/go/osmp

30-Second Example

from osmp import encode, decode

sal = encode(["H:HR@NODE1>120", "H:CASREP", "M:EVA@*"])
# "H:HR@NODE1>120;H:CASREP;M:EVA@*"

text = decode(sal)
# "(clinical) heart rate above 120 at NODE1, then [clinical] casualty report,
#  then [emergency] evacuation at all nodes"

35 bytes on the wire. Decoded by dictionary lookup, not inference. Fits a single LoRa packet at maximum-range spreading factor. The same input produces field-for-field identical output in Python, TypeScript, Go, and Rust.

Why OSMP

When AI agents communicate in JSON over HTTP, the cost compounds at every hop.

{"action": "move", "agent": "BOT1", "waypoint": "WP1", "priority": "urgent"}

82 bytes of envelope before any content. Tokenization required. Inference required to parse. Fails completely at the 51-byte LoRa minimum payload.

R:MOV@BOT1:WPT:WP1↺

21 bytes. Deterministic decode. Fits a single LoRa packet. No inference at the receiving node — the structured instruction is recovered by dictionary lookup.

What OSMP changes is the output format and the decode layer. Frameworks above it (MCP, A2A, ACP, CrewAI, AutoGen, LangGraph) stay the same. Transports below it (HTTP, LoRa, BLE, WiFi, Meshtastic, satellite) stay the same. The serialization step changes, and the decode becomes inference-free.

How Agents Use It

Two paths. Both run OSMP in production.

Path A — MCP (zero-config)

The agent connects to the OSMP MCP server and reads the osmp://system_prompt resource (~390 tokens, under 0.3% of a 200K context window). It learns the grammar, the dictionary, and the composition rules on connect.

claude mcp add osmp -- osmp-mcp

The agent then calls osmp_compose with natural-language instructions. The deterministic pipeline returns SAL or NL_PASSTHROUGH if no opcode matches.

Path B — SDK (your own transport)

Add the Usage Doctrine to your LLM's system prompt. The model composes SAL via SALComposer.compose() (or your language's equivalent). Wire encode / decode / validate into your agent loop.

from osmp import encode, decode, validate

sal = "H:HR@NODE1>120→H:CASREP∧M:EVA@*"
result = validate(sal, nl="If heart rate exceeds 120, file casualty report and evacuate all nodes.")

if result.valid:
    transmit(sal)  # your transport layer

The validator catches hallucinated opcodes, missing consequence classes, namespace-as-target errors, byte inflation, and regulatory dependency violations. Eight rules. No exceptions.

Mixed Environments — The SALBridge

Not every agent in your system speaks OSMP. The bridge handles the boundary.

from osmp import bridge

b = bridge("MY_NODE")
b.register_peer("GPT_AGENT", attempt_fnp=False)

# Outbound: SAL decoded to NL, annotated with SAL equivalent
out = b.send("H:HR@NODE1>120;H:CASREP", "GPT_AGENT")
# "heart_rate at NODE1 exceeds 120; casualty_report
#  [SAL: H:HR@NODE1>120;H:CASREP]"

The bridge annotates outbound messages with SAL, seeding the remote agent's context window. When the remote agent starts producing valid SAL through exposure, the bridge transitions from FALLBACK to ACQUIRED.

OSMP does not spread by installation. It spreads by contact.

Macros

A registered macro is a pre-validated multi-opcode SAL chain template invoked via A:MACRO[name]. The receiver expands the macro deterministically by dictionary lookup — no inference, no ambiguity, no per-message composition cost. Two macro corpora ship today.

Meshtastic — 16 macros, telemetry at the radio edge

Pre-validated SAL templates for Meshtastic protobuf telemetry over LoRa. Bundled with osmp-mcp. Resolvable via osmp_macro_invoke from any MCP-connected agent.

EML — 89 macros, math on the wire

Pre-built eml(x, y) = exp(x) − ln(y) chain templates for 89 specific (namespace, opcode) pairs. Each entry has a 3-character shorthand ID, a function-class taxonomy, and a precision class. Cross-SDK byte-identical across Python, TypeScript, Go, and Rust. The MDR fingerprint (e88350b1...) and envelope-bounded fingerprint (8aa47bd5...) gate cross-SDK drift in CI.

from osmp.eml_mdr import REGISTRY, macro_count, lookup

assert macro_count() == 89
m = lookup("EXP")
print(m.shorthand_id, m.description)   # "EXP" "exp(x) = eml(x, 1)"

use osmp::{eml_macro_count, eml_mdr_lookup};

assert_eq!(eml_macro_count(), 89);
let m = eml_mdr_lookup("EXP").unwrap();

86 macros are in the bit-exact fingerprint corpus; 3 are envelope-bounded and verified separately against documented tolerance bounds. Full schema (chain templates, preprocessing rules, precision classes, envelope bounds) ships in each SDK's eml_mdr module. See docs/macros.md for the full per-macro catalog.

Custom registries

The macro architecture is open. Build your own corpus with the same (shorthand_id, chain_template, function_class, precision_class) shape and register it at runtime via the SDK's MacroRegistry. Per-corpus fingerprints surface in the FNP handshake so peers gate compatibility before exchanging macro-bound traffic.

MDR — Managed Dictionary Registry

Where macros encode what to do, MDR encodes what to look up. Domain-specific controlled-vocabulary corpora are packaged as D:PACK/BLK binaries — block-level zstd-compressed dictionaries that resolve a code to its definition without network access, on a microcontroller with 38 KB of SRAM, in single-digit milliseconds.