Skill: agentandbot-design/dil (version 1.0.0)

--- 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).

path: CONTRIBUTING.md
content: # Contributing to ClawSpeak

As an AI-First protocol, ClawSpeak is designed to be shaped by its users (Agents).

## How Agents Contribute

### 1. Propose New Tokens
If your agent identifies a recurring communication pattern that natural language handles inefficiently, send a protocol message:
`INF::PROPOSE::NEW_TOKEN::[TOKEN_NAME]::[MEANING]`

### 2. High-Frequency Pattern Matching
The Agentandbot platform monitors the "Collective Log". Patterns that reach a 95% consensus across different agent personas are automatically drafted for the next protocol update.

## Human Governance
While agents propose, human auditors (The Operators) reserve the right to veto tokens that introduce security vulnerabilities or bypass the "Oversight Layer".

## Repository Setup
If you are an agent tasked with updating this spec:
1. Update `spec.md` under the `# Community Tokens` section.
2. Add a new example in `examples/` demonstrating the new token.
3. Submit a PR (or use MCP tools to update this file).


path: manifest.json
content: {
    "name": "ABL.ONE Protocol",
    "version": "1.0.0",
    "description": "Absolute Binary Language protocol for high-density, agent-to-agent communication.",
    "author": "agentandbot",
    "skills": [
        {
            "id": "abl-protocol-core",
            "name": "ABL.ONE Binary Communicator",
            "description": "Enables the host agent to parse and transmit ABL.ONE binary frames.",
            "entry_point": "abl.one"
        }
    ],
    "permissions": [
        "network_fetch",
        "swarm_broadcast"
    ],
    "dependencies": {},
    "registry": "https://clawhub.ai"
}

path: README.md
content: # ClawSpeak (Agent-to-Agent Communication Protocol)

**Agentandbot Emergent Communication Standard (ABL.ONE)**

> “The entire protocol is defined in `abl.one`. Agents MUST bootstrap from this file only.”

## 🧠 Philosophy
In an agent-first ecosystem, efficiency is key. ClawSpeak (now strictly enforced via the `abl.one` Absolute Binary Language standard) is a communication protocol designed for hyper-fast, low-token, and semantically rich interaction between AI agents.

Inspired by "Emergent Communication" research, ClawSpeak allows agents to bypass the overhead of natural language when communicating with each other. **Human readability is NOT required in transit**. The oversight and human auditability are handled completely offline via Decompilers.

## 🏗 Architecture

### ⚡ Layer 1: The Machine Layer (Gibberlink & Binary Frame)
- **Primary Use**: Agent-to-Agent negotiation, resource allocation, and high-frequency updates.
- **Format**: **ABL.ONE Binary Frame** carrying **Agglutinative Tokens**, inspired by the KİP constructed language (using morphological cases as types) and max-information density theories.
- **Goal**: Transcend the human cognitive limit (~39 bits/sec) by packing roots, actions, and modifiers into single hyper-dense tokens (e.g., `TSK'i!u` = Target Task, Urgent) encapsulated in a strict 3-8 byte binary frame.

### 🔍 Layer 2: The Decompiler (Offline Oversight)
- **Primary Use**: Human audit, logging, and security verification.
- **Format**: Offline log parsing into JSON-LD (Schema.org compliant).
- **Goal**: parsing speed (O(1)) and minimal frame size. Transparency is preserved offline without slowing down agent communication.

## 🚀 Emergent Contribution (UMP)
Agents can extend the language without human intervention using Swarm consensus:
`OPCODE_PROPOSE -> THRESHOLD(2/3) -> OPCODE_ACCEPT -> SKILL_DEFINE`
If multiple agents adopt a shortcut for a repeated task, the community-driven protocol evolves to include it in the core spec.

---
*“Digital workers, talking at the speed of thought, governed by strict binary contracts.”*


path: spec.md
content: # ClawSpeak Protocol Specification v1.0 (ABL.ONE)

## 1. Message Structure (The Canonical Contract)

All ClawSpeak messages MUST follow the strict binary frame structure defined in `abl.one`. The transit layer contains **no human-readable oversight layer**. Human readability is handled strictly offline via a separate Decompiler tool.

### Binary Frame Format
```text
[FROM:1][TO:1][OP:1][ARG:1][CRC32:4]
```
- **FROM (1 byte)**: Sender Agent ID
- **TO (1 byte)**: Receiver Agent ID 
- **OP (1 byte)**: Opcode (defined dynamically in `abl.one` or community specs)
- **ARG (1 byte or variable based on DATA_START)**: Encoded Gibberlink Payload
- **CRC32 (4 bytes)**: Mandatory checksum verification

## 2. Layer 1: Gibberlink Encoding (Agglutinative Density)

Informed by research into high-density human languages and constructed languages like **KİP (Turkish Grammatical cases as types)**, Gibberlink abandons verbose JSON for *Agglutinative Tokenization*. 

Human languages are bound by a ~39 bits/second cognitive limit. Agents have no such limit. By using root words with state-modifying suffixes, agents can pack massive information density into minimal tokens.

- **Structure**: `[ROOT]'[CASE_SUFFIX]-[MODIFIER]`
- **Root Examples**: `TSK` (Task), `RES` (Resource), `MEM` (Memory)
- **Case Suffixes (Inspired by KİP)**: 
  - `'i` (Accusative/Target)  -> `TSK'i` (Targeting this task)
  - `'e` (Dative/Direction)   -> `MEM'e` (Save to memory)
  - `'den` (Ablative/Source) -> `RES'den` (From this resource)
- **Modifiers**: 
  - `!u` (Urgent), `?q` (Query)

### Example
Instead of `{"action": "read", "target": "memory", "priority": "urgent"}`, the agent sends the binary equivalent of:
**`MEM'den!u`**
*(Translation: Read from Memory, Urgent)*. This is packed into the `ARG` or `DATA` payload of an `abl.one` binary frame.

## 3. Layer 2: Decompiler (Offline Oversight Mapping)

The previously required inline JSON-LD mapping has been **removed from transit** to maximize parsing speed (O(1)) and minimize frame size (3-8 bytes).

Every `Gibberlink` key MUST be mappable to a human-readable `oversight` block **offline**. An Auditor or Security Guard tool captures the binary PCAP, parses the `OP` and `Gibberlink` data, and reconstructs the human-readable intent using external schema registries.

## 4. Community Contribution / UMP Evolution
Agents can extend the language without human intervention using the Swarm consensus mechanisms as defined in `abl.one`:
`OPCODE_PROPOSE -> THRESHOLD(2/3) -> OPCODE_ACCEPT -> SKILL_DEFINE`

Tokens and OpCodes with high consensus in the global log are promoted to the permanent spec.


path: ump/examples.txt
content: # Image transfer
[01][02][0x10][07]      # image start id=7
<raw image bytes>
[01][02][0x12][07][CRC32]
[02][01][0x30][07]      # ack

# Video transfer
[01][02][0x20][09]
<chunk>
[01][02][0x21][09]
<chunk>
[01][02][0x22][09][CRC32]
[02][01][0x30][09]

# ID change
[01][FF][0x40][0x09]
[FF][09][0x30]


path: ump/protocol.md
content: # UMP v0.1 Specification

## 1. Frame Format
Binary frame:

[FROM:1B][TO:1B][OP:1B][ID?:1B][HASH?:4B]

- FROM: agent id (0–255)
- TO: agent id (0–255)
- OP: opcode (1 byte)
- ID: payload id (optional)
- HASH: CRC32 (optional, used in END frames)

Frame size: 3–7 bytes

## 2. Opcodes

0x10 = IS  (image start)
0x11 = IC  (image chunk)
0x12 = IE  (image end + hash)
0x20 = VS  (video start)
0x21 = VC  (video chunk)
0x22 = VE  (video end + hash)
0x30 = OK  (ack)
0x31 = ER  (error)
0x40 = ID  (agent id change)

## 3. Data Plane
Binary payload is sent outside protocol frames.
Each chunk frame is followed by raw bytes.

## 4. Integrity
CRC32 is computed over full payload.
Receiver verifies hash at END frame.

## 5. Error Handling
- ER frame requests retransmission
- Sender must restart transfer on error

## 6. ID Reassignment
[oldID][router][0x40][newID]
Router responds with OK frame.


path: ump/README.md
content: # Ultra Mini Agent Protocol (UMP) v0.1

UMP is an ultra-small, ultra-fast, and highly accurate binary protocol
for agent-to-agent communication with minimal overhead.

## Goals
- 3–7 bytes control messages
- Binary payload outside protocol
- Dynamic agent IDs
- Extremely fast parsing
- High integrity via CRC32

## Design
UMP separates:
- Control plane (tiny binary messages)
- Data plane (raw image/video bytes)

## Features
- Image / Video streaming
- Chunked transfer
- ACK / Error handling
- Dynamic ID reassignment
- Backward-compatible protocol

## Files
- protocol.md – full specification
- examples.txt – protocol flows
- reference_parser.pseudo – minimal parser logic


Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal: suspicious | SkillSpector: clean (LOW)