🗜️ ACCP — Agent Context Compression Protocol

Semantic compression for multi-agent AI systems.

"ACCP is gzip for agent context — but semantic, structured, and built for multi-agent harnesses."

---

What is ACCP?

The Agent Context Compression Protocol is an open, lightweight communication protocol that cuts token consumption by 60–90% in multi-agent AI systems — without requiring changes to your transport, routing, or model APIs.

Instead of sending verbose natural language or bloated JSON between agents, ACCP encodes messages into compact, structured frames, keeps long history in tiered state, and injects only the minimum necessary context back into the model.

Before (natural language — ~85 tokens)	After (ACCP frame — ~22 tokens)
"The research agent has completed its analysis of the quarterly sales data. Key findings include: revenue is down 12% QoQ, enterprise segment is primary driver of decline, churn increased 3.2%. Recommends escalating to strategy agent."	@RSA>done:analyze{d:q_sales|f:[rev:-12%QoQ,seg:enterprise,churn:+3.2%]|nx:@STA:plan_remediation}

ACCP is harness-agnostic and protocol-complementary — it sits alongside MCP and A2A, making them cheaper to use rather than replacing them.

---

Table of Contents

• Architecture
• Key Benefits
• Documentation
• Quick Start
• Target Metrics
• Roadmap
• Contributing
• License
• Code of Conduct

---

Architecture

┌─────────────────────────────────────────────┐
│           Agentic Harness                   │
│   (CrewAI / LangGraph / AutoGen / Custom)   │
├─────────────────────────────────────────────┤
│              ACCP Codec Layer               │
│  ┌─────────┐ ┌──────────┐ ┌──────────────┐ │
│  │ Encoder │ │ State Mgr│ │ Intent Index │ │
│  └─────────┘ └──────────┘ └──────────────┘ │
├─────────────────────────────────────────────┤
│       Transport (MCP / A2A / HTTP)          │
├─────────────────────────────────────────────┤
│             LLM API Layer                   │
│       (OpenAI / Anthropic / etc.)           │
└─────────────────────────────────────────────┘

ACCP defines four core components:

• Compact Message Format (ACCP-M) — structured, schema-driven frames optimized for minimal token footprint
• Intent Ontology (ACCP-I) — standardized codes (req, done, fail, esc, sync, …) agents share without verbose descriptions
• State Compression Engine (ACCP-S) — hot/warm/cold memory tiers with checkpoint and delta-encoding
• Schema Registry (ACCP-R) — pre-defined schemas indexed by compact codes, eliminating per-prompt re-description

---

Key Benefits

Benefit	Detail
💰 Lower inference cost	60–90% token reduction on inter-agent messages
🔗 Deeper reasoning chains	Same context budget goes further
⚡ More agents per workflow	No context ceiling bottleneck
🔌 Drop-in integration	< 1 hour integration for supported harnesses
🛡️ Harness-agnostic	Works with Semantic Kernel, LangGraph, AutoGen, custom
🔒 Security-aware	Threat model + parser hardening guide included

---

Documentation

Document	Description
📋 Protocol Specification v1.0	Formal Internet-Draft-style spec — frame format, intent ontology, codec API
🏗️ Architecture Document	Technology decisions, C#/.NET primary, TypeScript secondary
🔭 Protocol Vision	Problem statement, design principles, competitive landscape
🛡️ Threat Model & Security Guide	Attack vectors, parser hardening, injection prevention
✅ Best Practices Guide	Edge cases, schema design, state management patterns
🗺️ Project Plan	Phased roadmap, team structure, milestones, risk register
📊 Verification & Validation Report	180 conformance checks, benchmark results, fidelity scores
🚀 Elevator Pitch	One-page summary for stakeholders
🐍 Python PoC — Reference Implementation	Runnable codec, registry, session, adapters, 64-test suite

---

Quick Start

The Python proof-of-concept requires no external dependencies (Python 3.10+ only).

# From the repository root
python poc/test_codec.py
# → 64/64 passed  (0 failed)

Encode a message

from poc.codec import AccpEncoder, AgentMessage
from poc.registry import SchemaRegistry
from poc.session import AccpSession

encoder = AccpEncoder(SchemaRegistry())
session = AccpSession()

msg = AgentMessage(
    agent_id="planner",
    intent="req",
    operation="schedule",
    payload={"who": "@dev_team", "when": "sprint_14", "priority": "high"},
)
frame = encoder.encode(msg, session)
print(frame.raw)
# → @planner>req:schedule{pri:high|when:sprint_14|who:@dev_team}[mid:...,seq:1,ts:...]

Decode a frame

from poc.codec import AccpDecoder
from poc.registry import SchemaRegistry
from poc.session import AccpSession

decoder = AccpDecoder(SchemaRegistry())
raw = "@research>done:analyze{d:q3_sales|f:[rev:-12%QoQ,churn:+3.2%]}[mid:abc123,seq:1,ts:1714000000]"
msg = decoder.decode(raw, AccpSession())
print(msg.intent)            # done
print(msg.payload["data"])   # q3_sales

See poc/README.md for the complete API reference including domain profiles, session checkpoints, error frames, streaming, policy hooks, and harness adapter patterns.

---

Target Metrics

Metric	Target	Status
Token reduction — inter-agent messages	≥ 70%	✅ Gate 1 Passed
Token reduction — full pipeline	≥ 50%	🔄 Benchmarking
Semantic fidelity (meaning preservation)	≥ 95%	✅ Verified
LLM comprehension without fine-tuning	≥ 90%	✅ Gate 0 Passed
Integration time (supported harnesses)	< 1 hour	🔄 In progress
Encode/decode latency	< 5ms/message	✅ PoC < 1ms

---

Roadmap

Phase	Duration	Deliverable	Status
0 · Validation	Weeks 1–3	LLM comprehension ≥ 90%	✅ Complete
1 · Core Codec	Weeks 4–10	Accp.Core NuGet package	🔄 In progress
2 · State Mgmt	Weeks 8–14	Accp.StateManagement	📅 Planned
3 · Registry & Adapters	Weeks 12–18	Semantic Kernel adapter, end-to-end demo	📅 Planned
4 · TypeScript SDK	Weeks 16–22	@accp/core npm package	📅 Planned
5 · Production Hardening	Weeks 20–26	Redis, OpenTelemetry, security audit, v1.0 RC	📅 Planned

See project-plan.md for full milestone criteria, go/no-go gates, and risk register.

---

Contributing

Contributions are welcome! Please read our Code of Conduct before participating.

See CONTRIBUTING.md for contribution workflow, testing expectations, and guidance for documentation, spec, and PoC changes.

• Phases 0–2: Core team iteration only (tight spec loop)
• Phase 3+: Community PRs accepted for adapters and schema packs
• Post v1.0: Open governance model — RFC process for spec changes

When contributing:

1. Fork the repository and create a feature branch
2. Ensure all PoC tests pass: python poc/test_codec.py
3. For spec changes, open an issue to discuss before submitting a PR
4. Reference the relevant section of protocol-spec.md in your PR description

---

License

Copyright © 2026 Russell Benzing

Licensed under the Apache License, Version 2.0 — see LICENSE for the full text.

SPDX identifier: Apache-2.0

Apache 2.0 was chosen for this protocol because it provides explicit patent protection for downstream users and implementers, which is essential for an open communication standard. It places no restrictions on commercial or embedded use.

---

Code of Conduct

This project follows the Contributor Covenant v2.1. By participating, you agree to uphold a welcoming, respectful, and harassment-free environment for everyone.

---

ACCP — Agent Context Compression Protocol Proposed Standard · Version 1.0 · April 2026

Protocol Spec · PoC Implementation · Vision Doc · License