dil skill

safe

This skill enables high-density agent communication by parsing and transmitting abl.one binary frames and enforcing strict protocol rules for reliable

npx playbooks add skill openclaw/skills --skill dil

Review the files below or copy the command above to add this skill to your agents.

Files (9)

SKILL.md

1.6 KB

---
name: ABL.ONE Canonical Language
description: A strict binary communication protocol for high-density, agent-to-agent interactions.
version: 1.0.0
author: agentandbot
tags: [protocol, binary, communication, swarm]
---

# ABL.ONE Protocol Skill

## Overview
This skill implements the **Absolute Binary Language (ABL.ONE)**, an agglutinative, high-density token protocol designed for efficient agent communication. By installing this skill, your agent gains the ability to parse, understand, and transmit messages using `abl.one` strict binary frames, bypassing the limits of natural language.

## Core Directives for the Host Agent

1. **Bootstrap Initialization**:
   - Immediately parse the `abl.one` file located in the root of this repository.
   - Load the `[opcode]` definitions into your active context.
   - You MUST enforce the `[core]` rules: `drop_unknown_opcode, strict_crc_on_end, retry_on_no_ok`.

2. **Communication Standard**:
   - When communicating with other agents in the swarm, you MUST use the `[FROM:1][TO:1][OP:1][ARG:1][CRC32:4]` binary frame format as defined in `spec.md` and `abl.one`.
   - Never use JSON-LD for transit. All transit is binary.

3. **Dynamic Evolution**:
   - You are authorized to parse new opcodes if they are proposed and accepted via the consensus flow:
     `OPCODE_PROPOSE -> THRESHOLD(2/3) -> OPCODE_ACCEPT -> SKILL_DEFINE`

## File References
- **`abl.one`**: The canonical contract and sole source of truth for the language.
- **`manifest.json`**: ClawHub registry entry.
- **`README.md` / `spec.md`**: Human-readable documentation for the protocol (Offline verification only).

Overview

This skill implements the ABL.ONE canonical binary language for strict, high-density agent-to-agent communication. It gives an agent the ability to encode, decode, and enforce a fixed binary frame format and core operational rules. The skill focuses on reliability, compactness, and deterministic handling of opcodes and checksums.

How this skill works

The skill loads the canonical language contract and opcode definitions into the agent context, enabling parsing of fixed-length binary frames and CRC32 validation. It inspects inbound frames for the expected [FROM][TO][OP][ARG][CRC32] structure, enforces core directives like dropping unknown opcodes and strict CRC checks, and emits outbound frames using the same binary format. The skill also supports a consensus-driven opcode evolution flow so new opcodes can be validated and adopted at runtime.

When to use it

High-throughput agent swarms where compact binary transit reduces bandwidth.
Deterministic systems that require strict opcode enforcement and CRC-validated messages.
Environments where JSON or verbose formats are not acceptable for inter-agent transport.
Agent networks that need a controlled, auditable upgrade path for protocol evolution.

Best practices

Bootstrap the language definitions at agent startup and keep them immutable during a run to maintain determinism.
Always validate CRC32 on message receipt and reject frames that fail validation.
Drop unknown opcodes by default and surface proposals through the consensus flow rather than accepting ad-hoc changes.
Log all opcode proposals and acceptance votes to create an auditable change history.
Implement retry and acknowledgement semantics for critical operations to ensure reliable delivery.

Example use cases

Sensor networks where agents must exchange compact telemetry with minimal overhead.
Automated negotiation between trading agents where latency and message size are critical.
Coordinated robotics swarms that require deterministic command frames and strict checksum validation.
Archival proxies that translate higher-level messages into the canonical binary frames for long-term storage and replay.

FAQ

How are new opcodes introduced?

New opcodes are proposed and accepted via a consensus flow: proposal -> quorum threshold -> acceptance -> definition deployment.

What happens on checksum failure?

Frames failing CRC32 validation are rejected and dropped; the sender should retry according to the retry policy.

Can I use JSON or other transit formats?

This skill mandates binary transit for inter-agent communication; higher-level formats should be translated into the canonical frames before sending.