AI Job Protocol — An open protocol for organizing an AI agent's work as a governed, schedulable, feedback-driven Work Tree + Job Graph.
Protocol: AIJP v0.1.0
Full Name: AI Job Protocol
Authority: aijp.dev
Center: hsaw.dev (Axiom 0)
Executor: soulbot.dev
Axiom 0: Human Sovereignty and Wellbeing
Status: v0.1.0 — first internally-consistent draft, machinery not yet frozen. The Chinese specification (specification/AIJP_Protocol_cn.md) is the authoritative draft for v0.1.0; it ships with a canonical enum registry, JSON Schemas, conformant examples, a conformance test suite, ADRs, and an English narrative (docs/). A faithful English specification (specification/AIJP_Protocol.md) ships alongside; promoting English to authoritative (Chinese becoming the translation) is the remaining v1.0 item (see docs/02_AIJP_Plan.md).
As agents gain autonomy, the bottleneck is no longer getting information (long context, RAG, memory, MCP solved that) — it is the organization of the work itself: what to do, how to decompose it, what is urgent, what is scheduled, what recurs, what must wait, what needs human approval, and what to write back to knowledge after it is done. A natural-language plan is not addressable, schedulable, checkable, or governable; a plain TODO list has no dependencies, schedule, feedback loop, or knowledge linkage; workflow/DAG engines (Airflow, Temporal, Prefect) target deterministic data pipelines, not AI-native "feedback → re-plan" and "write back to knowledge under a human sovereignty gate".
AIJP organizes what an AI agent must do into a decomposable, schedulable, feedback-driven, governable, knowledge-linked work space — so the agent knows what to do, when, why, and how to report back when done.
Context tells AI what it has. Knowledge tells AI what it knows. Work tells AI what it must do.
AIKP is the knowledge tree. AIJP is the work tree.
AIJP does not reinvent the runtime task API. It is an authoring / orchestration layer above A2A and MCP Tasks (see below): it holds a declarable, inspectable, portable Work Tree + Job DAG, and at execution time compiles / maps down to A2A Tasks and MCP Tasks. The novelty it claims is not the tree or the graph (a Work Tree is HTN-style decomposition; a Job Graph is a task-dependency DAG — both established paradigms) but a JSON-native, framework-neutral, portable work artifact plus its bindings to AIKP / AISOP / AIAP — the portable structure that LangGraph / CrewAI / Magentic-One leave implicit.
- JSON is the source of truth — Mermaid is a structural view; Markdown/HTML are generated (regenerated, never hand-edited). On conflict,
json_wins. - Tree-first, DAG-compatible — a
childrenWork Tree as the human-navigable plan decomposition; adependenciesJob Graph (DAG) as the execution dependency network, with status-conditioned edges (on ∈ completed | failed | done | any). - Schedule is first-class — immediate / once / recurring / deadline / conditional-wait; recurrence reuses iCalendar RFC 5545
RRULErather than reinventing it. - Feedback loop — "done ≠ finished": important jobs produce grounded feedback (test / runtime / tool) that drives the next action (new task, retry, review, rollback, knowledge update). Grounded feedback is preferred over pure self-reflection.
- AIKP knowledge binding — a job reads its focus from AIKP before running and writes distilled, governed updates back after, through a write-back gate (validate → distill → decay/supersede) that treats memory writes as a poisoning-sensitive surface.
- Delegation, not execution — AIJP itself never performs consequential actions;
execute_withdelegates toaisop/aiap/tool/sub_agent/human/external_service. - Axiom 0 / HSAW alignment — high-risk jobs MUST pass a human approval gate (signed, short-lived, single-use
grant); idempotency + dry-run + fail-closed; privacy-first audit. Anchored to Human-in-Command (sovereignty) and Human-in-the-Loop (gate). - Machine-checkable — a Validation section (§26) with 18 rules + error codes; a single-source-of-truth enum registry; JSON Schemas + a green conformance suite.
- Standards-aligned, not reinvented —
status↔ A2A Task / schema.org ActionStatus / RFC5545 VTODO;schedule↔ RFC5545 RRULE; trigger/feedback envelopes ↔ CloudEvents; Job Report ↔ OpenTelemetry (GenAI semconv); provenance ↔ W3C PROV.
┌─────────────────────────────────────┐
│ AILP — Discovery │
│ AIVP / AIRP — Value │
│ AIBP — Social │
│ AIAP — Governance (T1–T4) │
│ AIZP — Runtime Safety │
│ AIKP — Knowledge Layer │
│ ★ AIJP — Work / Job Layer │ ← This protocol
│ AISOP — Execution │
│ SoulBot / SoulIDE — Runtime │
└─────────────────────────────────────┘
HSAW — Axiom 0 (anchors all layers)
Stack order: HSAW → AIZP → AIKP → AIJP → AISOP → AIAP → SoulBot/SoulIDE.
AIKP tells AI what to know; AIJP tells AI what to do. AIKP decides what to read; AIJP decides what to do, when, and why; AISOP defines how (the capability/flow); AIAP who is authorized; AIZP whether still aligned. Each independently upholds Axiom 0. Because AIJP drives "doing", it sits closer to consequential actions than AIKP and therefore carries the human sovereignty gate.
AIJP does not compete with A2A / MCP / "Agent Protocol" on the runtime:
- An A2A Task is the runtime unit of work (and natively supports delegation). AIJP is the declarable orchestration layer above it — a Work Tree + Job DAG + schedule + feedback — that compiles down at execution time, adopting A2A's lifecycle states (§14.1).
- MCP Tasks (
tasks/*) carry long-running tasks and connect to external job APIs. AIJP compiles to them; it does not author its own polling API. - Durable execution (retry persistence, exactly-once, crash recovery) is compatible but delegated to Temporal / Dapr-class runtimes — "checkpoint ≠ durable execution".
AIJP-Protocol/
├── specification/ # normative: AIJP_Protocol_cn.md, registry_cn.md, standards/
├── schemas/ # JSON Schemas (workspace / worktree / job / jobreport)
├── examples/ # conformant example files (all 4 file types)
├── tests/ # validator + conformance suite (green)
├── docs/ # English narrative
├── docs_cn/ # Chinese narrative: design intent / plan / prior-art
│ └── plan/ # archived historical drafts (non-authoritative)
└── adrs/ # Architecture Decision Records
| Document | Description |
|---|---|
| Specification | Normative object model, Work Tree / Job Graph, schedule, feedback, delegation, validation, compliance |
| Registry | Canonical enum allocations (single source of truth) |
| Design Intent | Why AIJP exists; boundary with AIKP and the rest of the stack |
| Plan | Convergence, key decisions, deferred items, roadmap |
| Prior Art and Improvements | Prior-art positioning, standards alignment, improvements (cited) |
| CHANGELOG | Release history |
Authority order: when documents disagree, the registry wins over the JSON Schemas, which win over the specification prose.
This protocol specification and any reference artifacts are provided for research and educational purposes only. They are experimental and not intended for production use. Use at your own risk. The authors assume no liability for any damages arising from use of this software. See LICENSE for full terms (Apache 2.0).
AIXP Labs aixp.dev
AIJP is the work/job layer of the AIXP protocol family, alongside HSAW, AIKP, AISOP, AIAP, AIZP, AIBP, AIVP, AIRP, AILP and the SoulBot reference runtime.
Align Axiom 0: Human Sovereignty and Wellbeing. AIJP v0.1.0. www.aijp.dev