Atomic Content Protocol

MCP is the pipe.
ACP is the payload.

MCP standardised how agents connect to data. ACP standardises what the data looks like when it arrives: Markdown with YAML frontmatter that carries its own identity, provenance, and relationships.

Read the spec See an ACO

Open standard. Readable by any LLM, any MCP server, any text editor. 

---
id: 01a03d62-f05a-7639-a015-be6d5d18218a
acp_version: "0.2"
object_type: aco
source_type: link
source_url: https://en.wikipedia.org/wiki/Knowledge_...
created: 2026-08-26T09:24:49Z
content_hash: sha256:c8dc3f6156b9a0bbf70a2ea468635356...
language: en
classification: reference
token_counts:
  cl100k: 9357
  approximate: 11643
tags: [knowledge-representation, ontologies, reasoning]
key_entities:
  - {type: person,  name: John McCarthy,  confidence: 0.95}
  - {type: concept, name: Semantic network, confidence: 0.90}
summary: >
  Knowledge representation and reasoning is a field of
  artificial intelligence focused on modelling information
  in structured formalisms so that computer systems can
  solve complex tasks.
provenance:
  summary: {model: claude-opus-4-6, confidence: 0.85}
visibility: private
agent_accessible: true
---

# Knowledge representation and reasoning

Knowledge representation and reasoning (KRR) is the field of
artificial intelligence dedicated to representing information...

A real ACO, returned by the Stacklist MCP server today. Not a mockup.

the problem

An agent can reach your content. It still has to read all of it.

MCP solved the connection. It did not change what arrives at the other end: a wall of text with no identity, no history, and no idea what it relates to. Every read pays full price, and every agent has to work it out again from scratch.

Full cost, every read

11,643 tokens. Then 11,643 again.

No provenance

Who made it, when, how sure.

No relationships

What it supersedes or contradicts.

No access rules

Private, public, agent-readable.

None of this is a model problem. It is a format problem.

the object

What an ACO carries.

Six required fields. Everything else optional. An ACO is a valid .md file that any text editor, static site generator, or LLM reads without special tooling.

Identity

id · acp_version · object_type

A UUID, the spec version, and what kind of object this is.

Provenance

source_type · source_url · author · created

Where it came from, who made it, and when.

Integrity

content_hash

SHA-256 of the body. Change the content, change the hash.

Economy

token_counts

Per-tokeniser counts, so an agent can budget before it reads.

Classification

tags · classification · key_entities · language

Machine-generated at enrichment, each entity confidence-scored.

Field provenance

provenance.<field>

Per field: which model produced it, when, and how confident.

Access

visibility · agent_accessible · status

Who may read it, and whether agents are among them.

relationships[] — typed, directional edges (references, derived-from, supersedes, contradicts) — is specified in the schema and not yet populated in production.

the token economy

11,643 tokens become 200.

Enrichment writes a summary, tags, entities and counts into the frontmatter once. After that an agent can decide whether to read the body at all — and usually does not need to.

Measured, not modelled: these are the figures the Stacklist MCP server returned for one Wikipedia article.

Raw page

11,643 tokens

As an ACO

~200 tokens

98%

fewer tokens per read

Break-even after one read. Every read after that is profit.

what is real

ACP v0.2 ships today.

Every capsule created in Stacklist is a real ACO, enriched at write time and readable over MCP. The protocol is not waiting on a launch: it is what the product already stores.

Source types, all live

link manual selected_text llm_capture uploaded_md converted_pdf converted_doc converted_video uploaded_image

MCP tools that read and write ACOs

enrich capsule save_markdown save_llm_output get_card_content search_semantic_similar

Verified against @stacklist/mcp-server 2.0.0 on 26 August 2026. The ACO in the hero came back from a live enrich call, not a design file.

the standard

Four primitives. Two levels. No more.

A tiny mandatory core keeps the spec implementable and the edge cases few. Containers do not nest. Collections do not recurse. That constraint is deliberate and can be relaxed later.

ACO

The unit. Markdown plus YAML frontmatter: self-describing, addressable, portable.

live today

Container

An ordered, addressable group of ACOs with its own metadata and access rules.

specified

Collection

A group of Containers with rollup counts. The second and final level.

specified

Owner

The identity anchor. The root of a knowledge graph, public or private.

specified

Core relationship edges

references derived-from supersedes supports contradicts part-of related x- extensions

Closed core set, extensible with an x- prefix. The edge vocabulary is specified and not yet populated in production. A public ACO registry — enrich once, everyone benefits — is the phase after that.

Read the spec. Then read an object.

ACP is an open standard. Stacklist is the first network built on it.

Read the spec Connect the MCP server

Markdown in, Markdown out. Your objects are portable by construction.