A protocol standard for autonomous, composable, and continuously-improving agentic systems.
HCA combines two powerful ideas:
- Holonic Architecture: Agents that are both autonomous wholes AND cooperative parts of a larger system
- Compound Engineering: Mandatory iteration loops where each task improves future tasks
The result: agent systems that are governable without being rigid, autonomous without being chaotic, and get better over time.
| I want to... | Start here |
|---|---|
| Understand HCA in 3 minutes | QUICK-REFERENCE |
| Read the full specification | SPEC |
| See the architecture visually | ARCHITECTURE-DIAGRAM |
| Implement HCA | HCA-EXTENSIONS → STATE-MACHINES |
| Certify compliance | CONFORMANCE-CRITERIA |
Current agent architectures have fundamental limitations:
| Approach | What Happens |
|---|---|
| Hub-and-spoke | Central orchestrator becomes a bottleneck. Agents have fake autonomy. |
| Pure swarm | Emergent chaos. Unreproducible results. Ungovernable. |
| One-shot agents | No iteration. No learning. Same mistakes repeated forever. |
HCA solves this by combining structured hierarchy (holons) with mandatory improvement loops (compound engineering).
A holon is an agent that is:
- Autonomous: Makes its own decisions within constraints
- Embedded: Operates as part of a larger goal structure
Root Holon (Mission Control)
│
├── Domain Holon (Engineering)
│ ├── Leaf Holon (Dev Agent)
│ └── Leaf Holon (Refactor Agent)
│
├── Domain Holon (QA)
│ ├── Leaf Holon (Test Agent)
│ └── Leaf Holon (Verifier Agent)
│
└── Domain Holon (Data)
└── Leaf Holon (Research Agent)
Authority flows down (constraints, goals, budgets). Results flow up (artifacts, verdicts, status).
Every task follows this pattern:
┌────────┐ ┌────────┐ ┌────────┐ ┌─────────────┐
│ PLAN │ ──► │ WORK │ ──► │ REVIEW │ ──► │REVISE/ACCEPT│
└────────┘ └────────┘ └────────┘ └─────────────┘
▲ │
└──────────────── (on failure) ◄───────────────┘
Plus an outer loop that extracts lessons:
COMPOUND: What worked? What failed? → Knowledge Base → Future PLANs
This is the compound principle: each task makes the next task easier.
HCA uses standard protocols at each boundary:
| Boundary | What It's For | Protocol |
|---|---|---|
| Northbound | Human/IDE ↔ System | ACP |
| Coordination | Holon ↔ Holon | A2A |
| Tools | Holon → External tools | MCP |
| Runtime | Holon → Sandbox | OpenHands/Docker |
Parents don't command; they constrain.
Parent provides: Child decides:
├── Goals ├── How to achieve goals
├── Acceptance criteria ├── When to delegate
├── Budgets (time/tokens) ├── Implementation approach
└── Policies └── Whether to accept/negotiate
Agents can:
- Accept tasks as specified
- Reject tasks (with reason)
- Counter with modified constraints
This isn't insubordination—it's the protocol.
The agent that writes code cannot be the agent that reviews it.
This prevents self-approval and forces genuine evaluation.
Every completed task (success or failure) produces lessons that go into a shared knowledge base. Future PLAN phases query this knowledge.
hca/
├── README.md ← You are here
├── DOCUMENT-INDEX.md ← Navigation & reading paths
│
├── spec/ ← Normative specification (THE RULES)
│ ├── SPEC.md Core specification
│ ├── GLOSSARY.md Term definitions
│ ├── HCA-EXTENSIONS.md JSON-RPC schemas
│ └── STATE-MACHINES.md Formal state diagrams
│
├── reference/ ← Reference materials (Informative)
│ ├── QUICK-REFERENCE.md 1-page cheat sheet
│ ├── ARCHITECTURE-DIAGRAM.md Visual architecture
│ ├── BUILDING-BLOCKS.md Protocol rationale
│ └── CONFORMANCE-CRITERIA.md Certification requirements
│
├── guidance/ ← Implementation guidance
│ └── SECURITY-CONSIDERATIONS.md Security patterns
│
└── working/ ← Working documents (not part of spec)
├── ANALYSIS-SUMMARY.md Validation executive summary
├── PROTOCOL-GAP-ANALYSIS.md Detailed gap analysis
└── CRITICAL-FIXES-REQUIRED.md Action items
| Type | Folder | Description |
|---|---|---|
| Normative | spec/ |
The rules (MUST implement) |
| Reference | reference/ |
Explains & guides |
| Guidance | guidance/ |
Implementation patterns |
| Working | working/ |
Project management (not part of spec) |
See DOCUMENT-INDEX.md for complete navigation and reading paths.
Adopt HCA incrementally:
| Level | What You Need | Use Case |
|---|---|---|
| 1 - Minimal | Holons + delegation + artifacts + review | Proof of concept |
| 2 - Standard | + Full compound loop + iteration + negotiation | Production pilot |
| 3 - Full | + Knowledge base + cross-task learning | Production system |
See CONFORMANCE-CRITERIA for detailed certification requirements.
HCA builds on proven foundations:
| Component | Purpose | Source |
|---|---|---|
| LSP Pattern | JSON-RPC + capabilities | Microsoft |
| A2A | Agent-to-agent coordination | Google/Linux Foundation |
| MCP | Tool invocation | Anthropic |
| ACP | Client interface | Community |
| OpenHands | Runtime substrate | OpenHands |
| ADK | Agent framework |
HCA references these; it doesn't require specific implementations.
See BUILDING-BLOCKS for detailed rationale.
The term comes from Compound Engineering by Dan Shipper (Every, 2025):
"Compound engineering creates a learning loop for your agents and team, so that each bug, failed test, or problem-solving insight gets documented and used by future agents."
Without compound loops, agent systems don't improve. Each task is isolated. The same mistakes repeat.
With compound loops, each task makes the next task easier.
Version: 0.1.0 (Draft)
This is an initial specification. Future versions will add:
- v0.2: Security model, extension mechanisms
- v0.3: Conformance test suite
- v1.0: Stable specification
This specification is open for feedback. Please open issues for:
- Clarifications needed
- Inconsistencies found
- Use cases not covered
- Implementation experience
- A2A Protocol - Agent-to-Agent communication
- MCP - Model Context Protocol
- ACP - Agent Client Protocol
- OpenHands - Agent runtime
- ADK - Agent Development Kit
- Compound Engineering - Every/Dan Shipper
- Arthur Koestler, The Ghost in the Machine (1967) - Holon concept origin
HCA: Autonomous agents that learn. Governed systems that flex. Architecture that compounds.
This document is part of the Holonic Compound Architecture (HCA) Specification v0.1