Open Format · v1.0 · CC0

The language between
agents and humans.

AHIL is an open JSON format for the exchange layer between AI agents and humans. Agents surface findings, alerts, and recommendations upward ↑. Humans issue orders, approvals, and overrides downward ↓. One schema, one file, both directions — append-only so nothing can ever be silently rewritten.

Agents and humans have no shared language

As AI agents take on more autonomous roles in data pipelines, the coordination problem grows: agents produce findings that humans never see in a timely way; humans issue instructions with no guaranteed path to the agent; and the chain of decisions — who recommended what, who approved it, who acted — is scattered across logs, Slack threads, and comments.

🔇
Agents report to no one
Without a defined output channel, agent findings end up in application logs at best — invisible to human decision-makers until something breaks.
📣
Humans can't steer agents
There is no standard way for a human to issue a priority change, an approval, or an override to a running agent. Instructions travel through out-of-band channels that agents never read.
🕳️
No audit trail
When an automated decision needs to be traced — why did the pipeline pause? who approved the remediation? — there is no single record. The history is lost.
🤖↔️👤
Asymmetric formats
Agents speak in structured JSON. Humans speak in prose. HITL implementations use bespoke schemas per tool. Nothing is reusable or portable.

One typed, append-only log. Both sides.

AHIL defines a single JSON exchange file where agents and humans both read and write using the same entry schema. Seven typed entry types cover every coordination pattern — from a routine agent observation to a human override that cancels an in-flight action.

↕️
Bidirectional
Agents write upward. Humans write downward. Same schema, same file, same rules for both. A human entry looks identical to an agent entry — only the from and type fields differ.
📌
Append-only
Nothing is ever edited or deleted. Actions are recorded by appending new entries. The full decision chain — recommendation → approval → acknowledgement — is always traceable.
🏷️
Schema-enforced
Seven named types with defined semantics and status lifecycles. A JSON Schema Draft-07 file ships with the spec for validation with any standard tool.
📦
Embeddable
The log array format is identical whether used standalone (exchange.json) or embedded in an ADPL pipeline file (ahi.log[]). No translation needed.

Directionality and flow

The exchange layer sits between agents and humans. Agents write up. Humans write down. Both sides read the full log before acting. The log is the only interface — no direct calls, no side channels.

🤖
Agents
observation · recommendation
alert · acknowledgement
↑ UP
↓ DOWN
📋
exchange.json
typed · append-only
shared · auditable
↑ UP
↓ DOWN
👤
Human
order · approval
override
↑ observation ↑ recommendation ↑ alert ↓ order ↓ approval ↓ override ↔ acknowledgement

Seven types, two directions

Every AHIL entry has a type that determines its direction, who may write it, and what status transitions are valid. The seven types together cover every coordination pattern between agents and humans.

observation
↑ up
Factual finding from an agent. No action required. Builds shared situational awareness. Status: noted.
recommendation
↑ up
Agent suggests a specific action to a named recipient. Expects an acknowledgement. The triggering mechanism for agent-to-agent coordination.
alert
↑ up
Urgent issue requiring immediate attention. Higher priority than a recommendation. May auto-escalate if no acknowledgement within a defined window.
order
↓ down
Human directive to an agent. Priority change, explicit task, constraint, or focus area assignment. The primary mechanism for human control without code changes.
approval
↓ down
Confirms a pending recommendation should be acted on. References the original entry. May also be written by a higher-level agent at L4 autonomy.
override
↓ down
Cancels or modifies an in-flight agent action. Takes precedence over any prior approval. The human's absolute veto.
acknowledgement
↔ any
Records that an entry was received and acted on (or rejected). Always references the original via context.ref. Terminal state — no further transitions.

From pending to terminal

Every entry begins in an initial state and transitions forward. Transitions happen by appending new acknowledgement entries — the original entry's status is never edited.

pending acknowledged acted order / recommendation / approval / override
pending rejected cannot fulfill — reason in acknowledgement.content
noted observation / alert — no action required

File structure and entry shape

// exchange.json — standalone AHIL exchange file
{
  "schema_version": "1.0",
  "description":    "Exchange layer for the Hello Pipeline.",

  "entries": [

    {   // ↑ Agent writes upward
      "id":      "scout-20260317-001",
      "type":    "recommendation",
      "from":    "scout",
      "to":      "project_architect",
      "date":    "2026-03-17",
      "status":  "pending",
      "content": "BitNet trending — recommend case study.",
      "context": { "priority": "high", "suggested_slug": "local-llm-inference-pipeline" }
    },

    {   // ↓ Human writes downward
      "id":      "human-20260317-001",
      "type":    "approval",
      "from":    "human",
      "to":      "project_architect",
      "date":    "2026-03-17",
      "status":  "noted",
      "content": "Approved. Build BitNet case study this cycle.",
      "context": { "ref": "scout-20260317-001" }
    },

    {   // ↔ Agent acknowledges
      "id":      "project_architect-20260317-001",
      "type":    "acknowledgement",
      "from":    "project_architect",
      "to":      "scout",
      "date":    "2026-03-17",
      "status":  "acted",
      "content": "Created Case #020 — Local LLM Inference Pipeline.",
      "context": { "ref": "scout-20260317-001", "slug": "local-llm-inference-pipeline" }
    }

  ]
}

Where AHIL is used

One format, three contexts

The AHIL entry schema is identical across all three uses. Tools and agents that understand the format in one context understand it in all three.
🌀 H.A.R.L.I.E. Collective
The H.A.R.L.I.E. agent collective uses a standalone exchange.json as its shared coordination layer. Seven agents and humans all read and write here. The exchange log is the only interface between agents — no direct calls.
📄 ADPL Pipeline Files
Every ADPL v1.1 file embeds an AHIL log as ahi.log[]. The pipeline's operational history — setup confirmations, quality alerts, human approvals — travels with the pipeline file. Import into Pipeline CAD to see the full log.
🔧 Pipeline CAD Simulation
The Pipeline CAD simulation mode generates AHIL entries in real time as the pipeline runs. Human Gate nodes pause the simulation and prompt the operator to write an order or approval entry before flow resumes.
🔗 AHI Live Simulation
The AHI Simulation tool is an interactive demo of the AHIL exchange layer. Compose agent and human entries, watch the log build, and step through a full scenario with a guided walkthrough.

Three ways to use AHIL

01
Try the live simulation
Open the AHI Simulation tool. Compose entries as an agent or as a human. Step through the DuckDB Lakehouse guided scenario to see a full recommendation → approval → acknowledgement cycle.
02
Add an exchange layer to your pipeline
Create an exchange.json file in your project. Copy the minimal valid example from the spec README. Point your agents to read pending entries addressed to them at startup and append acknowledgements when done.
03
Validate with the JSON Schema
Download schema/v1.0.json and validate your exchange file with ajv, VS Code, or any JSON Schema Draft-07 validator. Every entry type, direction, and status transition is covered.

Full reference and examples

The AHIL specification is published as an open repo. It includes the full README with entry type reference, status lifecycle rules, all seven annotated examples, and the JSON Schema for validation.

📘
README — Full spec
Entry type reference, status lifecycle, all seven annotated entry examples, integration notes, and rules for all participants. github.com/datainsightat/ahil →
JSON Schema v1.0
Validate any AHIL exchange file with JSON Schema Draft-07. Covers all entry fields, type enums, status enums, and the id naming pattern.
Download schema locally
Save schema/v1.0.json and use it with ajv, VS Code JSON validation, or any Draft-07 compatible validator.
🔗
AHI Live Simulation
Interactive demo — compose and play back a full agent-human exchange cycle. See how the log builds with real entries across all seven types.

See AHIL in action

A walkthrough of the Agent Human Interface Language — how the exchange layer works, the entry types, and how H.A.R.L.I.E. uses it to coordinate her agent collective.