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>Everything an AI team needs. Nothing it doesn't.
Eight file types define the complete operational model. Each primitive has a clear purpose, schema, and precedence rule.
Tools
tool.yaml
Typed integration surfaces with schema, auth, permissions, and runtime gating
Skills
SKILL.md
Reusable procedural knowledge in YAML frontmatter + Markdown
Capabilities
capability.yaml
Versioned compositions of tools + skills + policies + tests
Profiles
profile.yaml
Role configuration: model, budgets, concurrency, memory, capabilities
Heartbeats
HEARTBEAT.md
Run-loop checklists that prevent blank-slate drift
Souls
SOUL.md
Identity, values, and boundaries that change rarely
Policies
policy.yaml
Enforceable rules: permissions, approvals, network policy, data sensitivity
Artifacts
artifact.json
Immutable records of what was produced and how
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.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]---
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 emittedSkills 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.
From request to artifact
A deterministic flow that makes AI work predictable, auditable, and repeatable.
Load profile
Select the agent role, runtime, and budgets
Load soul & heartbeat
Restore identity, values, and operational routine
Resolve capabilities
Verify versions and compatibility of all packages
Load metadata only
Progressive disclosure — names and descriptions first
Apply policies
Compute effective allow/deny, approvals, network policy
Fetch next task
Check task queue with atomic checkout
Execute with engine
Tool calls, handoffs, approvals — until final output
Emit artefacts & traces
Immutable records with trace IDs and lineage
Deterministic conflict resolution
When instructions conflict, the protocol resolves them predictably. No ambiguity.
Explicit user/task input
Task payload + human steering notes (highest priority)
Task-local overrides
Task folder overlays and task-specific instructions
Profile overlays
Profile-specific heartbeat + soul + profile policy
Capability package content
capability.yaml → skills / tools / policies
Organisation global policy
Org-level AGENTS.md and baseline instructions
Runtime defaults
Engine defaults and safe baselines
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.yamlCapability 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.yamlPlatform 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.yamlBuilt 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.
Six load-bearing decisions
Structure how agents operate
Reproducible. Auditable. Governable.