Osmp (octid Semantic Mesh Protocol)
About
Agentic AI instruction encoding. 86.8% smaller than JSON. Inference-free decode by table lookup. 342 opcodes, 26 namespaces, three conformant SDKs. Confirmed over LoRa mesh radio. Apache 2.0 with express patent grant.
Details
- Author
- Octid-io
- Downloads
- 316
- Categories
- Communication, AI, Other, Knowledge Base
Jump to
- 86.8% byte reduction vs JSON across 29 real-world vectors
- Inference-free decode via table lookup (ASD dictionary)
- Three domain corpora shipped: ICD‑10‑CM, ISO 20022, MITRE ATT&CK
- No cloud required; all SDKs resolve domain codes offline
- Works over any transport (LoRa, HTTP, mesh, etc.)
- BAEL floor guarantee: never makes instructions longer than natural language
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
Osmp (octid Semantic Mesh Protocol)Command (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
Install the server with pip install osmp-mcp and run osmp-mcp. Connect from any MCP-compatible client such as Claude Code (claude mcp add osmp -- osmp-mcp), Claude Desktop, or Cursor. The server exposes 9 tools: encode, decode, compound_decode, lookup, validate, discover, resolve, batch_resolve, and benchmark.
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"osmp (octid semantic mesh protocol)": {
"osmp": {
"command": "osmp-mcp"
}
}
}
}McpServers
{
"osmp": {
"command": "osmp-mcp"
}
}Agentic AI instruction encoding. 60%+ compression over JSON. Inference-free decode. Any channel.
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.
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
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.
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.
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.
The agent connects to the OSMP MCP server and reads theosmp://system_promptresource (~390 tokens, under 0.3% of a 200K context window). It learns the grammar, the dictionary, and the composition rules on connect.
The agent then callsosmp_composewith natural-language instructions. The deterministic pipeline returns SAL orNL_PASSTHROUGHif no opcode matches.
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.
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.
A registered macro is a pre-validated multi-opcode SAL chain template invoked viaA: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 forMeshtasticprotobuf telemetry over LoRa. Bundled withosmp-mcp. Resolvable viaosmp_macro_invokefrom any MCP-connected agent.
Pre-builteml(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();
compound_arithmetic (35)—ABSADDCBTCSHCUBDIVEE2EE3EE4EE5EEMEEXELNEM1EMEEMXEOXESXEXPIDNLINLL2LL3LOGMULMXYNEGOMLPOWSNHSQRSQTSUBTNHZER
scientific (19)—BES(Bose-Einstein) ·BOL(Boltzmann factor) ·BRN(Bernoulli pressure) ·BWR(Breit-Wigner resonance) ·CDP(classical Doppler) ·CLB(Coulomb force) ·DOP(relativistic Doppler) ·FDR(Fermi-Dirac) ·FRD(Friedmann H²(z)) ·HAD(Hadamard quantum gate) ·LRZ(Lorentz gamma) ·MXB(Maxwell-Boltzmann speed) ·ORV(orbital velocity) ·PLK(Planck blackbody) ·RCC(RC charging) ·REN(relativistic energy) ·RLC(RLC resonance) ·SHR(Sharpe ratio) ·STB(Stefan-Boltzmann)
nn_activation (10)—ELU·GLU(GELU approx) ·LRL(Leaky ReLU) ·LSX(log-softmax3) ·MSH(Mish) ·RLU(ReLU) ·SIG(sigmoid) ·SPL(softplus) ·SWS(Swish/SiLU) ·SX3(softmax3)
linalg (8)—CMP(2×2 char poly) ·CP3(3D cross product) ·DT2(2×2 det) ·INV(2×2 inv) ·MMG(3×3 matmul) ·MMP(2×2 matmul) ·QML(quaternion mul) ·TR3(3×3 trace)
trigonometric (5)—ATA(atan Taylor) ·COS(cos Taylor) ·RRT(range-reduced sin) ·SCH(sin Chebyshev) ·SIN(sin Taylor)
complex_arithmetic (4)—CAB(magnitude) ·CIM(mul Im) ·CMU(mul (Re,Im) pair) ·CRE(mul Re)
nn_layer (4)—ATM(attention 2-head) ·ATN(attention score) ·DEN(dense forward) ·LST(LSTM cell)
numerical_method (3)—LRP(linear interp) ·NEW(Newton-Raphson step) ·SIM(Simpson quadrature)
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'seml_mdrmodule. Seedocs/macros.mdfor the full per-macro catalog.
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'sMacroRegistry. Per-corpus fingerprints surface in the FNP handshake so peers gate compatibility before exchanging macro-bound traffic.
Where macros encodewhat to do, MDR encodeswhat to look up*. Domain-specific controlled-vocabulary corpora are packaged asD:PACK/BLKbinaries — 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.
The wire instruction stays compact (H:ICD[J93.0]) while the receiver still recovers the full official text ("Spontaneous tension pneumothorax"). The dictionary travels with the device, not the message.
All three D:PACK/BLK binaries fit in ESP32 flash. TheHnamespace (clinical),Knamespace (financial), andSnamespace (security) gain edge-local Layer 2 accessor resolution as a result. Verified across all 124,215 codes in Python, TypeScript, and Go.
…
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
