ZeroHuman

ZEROHUMAN

The Open Protocol for Structured AI Operations

Define skills, tools, capabilities, profiles, policies, and artifacts in portable, auditable structures. One protocol. Every agent runtime.

$npx zerohuman init <owner/repo>
Try It Now

Simple by design

A ZeroHuman package is just a directory with structured files. Add a zerohuman.yaml manifest and your skill, tool, or capability files. That's it.

Like AGENTS.md, the format is obvious and easy to adopt. Unlike it, ZeroHuman extends into a full operational model with governance, artifacts, and runtime behavior.

zerohuman.yamlyaml
# zerohuman.yaml

protocol: zerohuman
protocol_version: 0.1.0
kind: capability_package
name: my-agent-pack
version: 1.0.0
summary: "A collection of production-ready agent capabilities"
license: MIT
repository:
  forge: github
  org: your-org
  repo: my-agent-pack

entrypoints:
  capabilities:
    - capabilities/frontend-dev/capability.yaml

trust:
  publisher: community
  signatures:
    required: true

indexing:
  discoverable: true
  tags: [frontend, react, deployment]
skill.mdmarkdown
---
name: react-performance-optimization
description: >
  Identify and fix React performance issues including
  unnecessary re-renders, missing memoization, and
  inefficient state management patterns.
metadata:
  semver: 1.0.0
---

# React Performance Optimization

## When to apply
- Component render time exceeds 16ms
- useEffect dependencies are missing or incorrect
- Large lists rendered without virtualization

## Steps
1) Profile with React DevTools Profiler
2) Identify components re-rendering unnecessarily
3) Apply React.memo where props are stable
4) Move expensive computations to useMemo
5) Verify improvement with before/after metrics

## Done when
- Render counts reduced AND metrics captured
  AND artifacts emitted
Procedural Knowledge

Skills that agents can follow

Skills are step-by-step procedures, not vague instructions. They tell agents exactly what to do, when to do it, and how to verify the result.

Think of them as runbooks that any AI agent can execute — portable across tools, teams, and platforms.

How It Works

From request to artifact

A deterministic flow that makes AI work predictable, auditable, and repeatable.

01

Load profile

Select the agent role, runtime, and budgets

02

Load soul & heartbeat

Restore identity, values, and operational routine

03

Resolve capabilities

Verify versions and compatibility of all packages

04

Load metadata only

Progressive disclosure — names and descriptions first

05

Apply policies

Compute effective allow/deny, approvals, network policy

06

Fetch next task

Check task queue with atomic checkout

07

Execute with engine

Tool calls, handoffs, approvals — until final output

08

Emit artefacts & traces

Immutable records with trace IDs and lineage

Precedence Model

Deterministic conflict resolution

When instructions conflict, the protocol resolves them predictably. No ambiguity.

1

Explicit user/task input

Task payload + human steering notes (highest priority)

2

Task-local overrides

Task folder overlays and task-specific instructions

3

Profile overlays

Profile-specific heartbeat + soul + profile policy

4

Capability package content

capability.yaml → skills / tools / policies

5

Organisation global policy

Org-level AGENTS.md and baseline instructions

6

Runtime defaults

Engine defaults and safe baselines

Get Started

Three ways to adopt

From a single file in one repo to a full orchestration platform.

Single Repo

Add protocol files to any project. Agents discover and follow them automatically.

my-project/
├── SKILL.md
├── tool.yaml
├── capability.yaml
└── policy.yaml

Capability Factory

Build an internal library of reusable skills, tools, and profiles for your organization.

capabilities/
├── frontend-dev/
│   ├── SKILL.md
│   └── tool.yaml
├── qa-review/
│   ├── profile.yaml
│   └── capability.yaml
└── zerohuman.yaml

Platform Runtime

Use as the runtime layer for platforms with full orchestration, budgets, and governance.

zerohuman.yaml
profiles/
  ├── crm-specialist.yaml
  └── qa-reviewer.yaml
capabilities/
  └── outbound-research.yaml
policies/
  └── api-security.yaml
Security & Governance

Built for production trust

Supply-chain security is part of the protocol, not an afterthought. Every layer is designed for auditability and least privilege.

Signed Releases

Cryptographic signing at the HumanGate stage. Trust tiers from unverified to publisher-verified.

Permission Manifests

Tools and policies declare outbound domains, data classification, and approval requirements upfront.

Sandbox Isolation

High-risk tools run in OCI-compliant containers or Wasm modules with network policies and allowlists.

"Most Restrictive Wins"

Lower scopes can never broaden permissions. Essential for safely installing third-party skills.

Deny-by-Default Network

Network egress is blocked unless explicitly allowlisted in policy.yaml. No silent outbound calls.

Correlated Observability

Three records per run: traces (end-to-end), artefacts (immutable outputs), and usage/cost accounting.

Design Principles

Six load-bearing decisions

01Progressive disclosure by default
02Typed tool surfaces + explicit approvals
03"Most restrictive wins" for permissions
04Everything is testable
05Every run is auditable
06Governance is part of the protocol

Structure how agents operate

Reproducible. Auditable. Governable.