Skip to content

Knowledge Infrastructure

The KCP Universe: Everything, and What July Changed

In July 2026, twelve repositories in the Knowledge Context Protocol ecosystem took 1,012 commits and shipped 88 releases. The specification went from v0.22 to v0.30.3 — sixteen releases in a single month.

That is either a lot of noise or a lot of signal, and the only honest way to tell you which is to show you the whole thing.

This is the complete map. If you have never heard of KCP, start at the top and it will make sense. If you have been following since February, skip to July in focus — that is where everything new is.

Same Blueprint, Different Doors

Same Blueprint, Different Doors — the convergent evolution of governed AI agents, rendered as an engineering blueprint

Anthropic published a long, careful writeup of how they built self-service data analytics on Claude internally — the system that lets anyone at the company ask a business question in plain English and get back a governed, provenance-tracked answer. 95% of their analytics queries are now automated this way, at roughly 95% aggregate accuracy.

We read it the way we read anything that touches how agents know things: looking for where we were wrong.

We found something else instead. Strip away the domain — theirs is a data warehouse, ours is a codebase and a governance practice — and the architecture underneath is close enough to feel less like inspiration and more like recognition. Two teams, no contact, building the same shape from opposite doors.

From Pasted Prompts to Signed Charters: A Short History of the Agentic Skill

From Pasted Prompts to Signed Charters — the evolution from a pasted release prompt to a signed, enforceable skill charter

In 2023, if you wanted an AI to help you cut a release, you typed a small prayer into a chat window and pasted the answer into your terminal.

This morning, an agent in my toolchain was offered a release skill by a deterministic planner, which noted — in writing, in a receipt — that the skill was relevant to the task but not eligible to run, because no human had granted it enactment rights. The skill itself declared, in a signed manifest, exactly which tools it may invoke and which files it may touch. A linter had checked that declaration. A different program stood ready to block any tool call that reached outside it.

Same workflow. Same twenty lines of playbook. Completely different kind of object.

The distance between those two moments is about three and a half years, and almost nobody noticed the transitions while they happened — each one looked like a small quality-of-life improvement at the time. Told end to end, they form one story: the agentic skill slowly acquiring the properties of a charter — a scoped, reviewable, revocable grant of authority. This post walks that history with one deliberately boring running example, because boring examples keep us honest: how does the AI help you cut a release?

The Agent That Knows What It Knows

The Agent That Knows What It Knows — moving AI procedural memory from flat grep to a living protocol

Here is a confession. Our AI development rig — the one we call ExoCortex — has 644 skills: little packets of procedural memory that tell it how we deploy, how we review, how a specific client's CI is wired, how to publish to this very blog. And until this week, the way it found the right one, out of 644, was grep.

Keyword match against a flat index. No ranking. No freshness. When a query touched a common word, it got back a pile of candidates and had to read through them to guess. We only really noticed the cost the day we discovered that one of the skills it leans on daily had sat three weeks stale — describing a system four pull-requests out of date — and nothing, anywhere, had flagged it.

An agent that can't tell which of its own memories is rotting is not, in any deep sense, remembering. It's hoarding.

Defensible Agents: When Every Gate Writes Its Verdict

Two weeks ago we shipped an agent that plans deterministically and told the vibes-based era to end. The argument was real — a pure-function planner, zero-token navigation, scored reasons for every unit selected or skipped. But one question kept coming up, and it was fair:

"The plan says it skipped something. But why did gate 3 reject it and not gate 7? What was the actual decision path?"

The plan was evidence. But it was a verdict without a trial transcript.

Today kcp-agent 0.10.0 ships the trial transcript.

Six Months Down the Rabbit Hole

On January 15th I published a blog post about parsing semiconductor part numbers. I thought I was building a PCB component library. I was wrong about what I was building in the most productive way I have ever been wrong about anything.

Six months later there is a knowledge protocol with nineteen releases, a deterministic reference agent, an episodic memory system that indexed this very retrospective's sources, five toolchain products, thirty-one new repositories, and a family vacation that an AI agent can defend to a regulator.

It is time to stop, sit by the fjord, and look back down the hole.

Getting Into the Phone Book of the Agentic Internet Took an Afternoon. Here's Why.

The Phone Book of the Agentic Internet: Beyond Discovery to Verifiability. An iceberg: above the waterline, the afternoon — 16,500+ servers already registered, cryptographic proof of ownership via DNS TXT ed25519, a minimal engineering gap. Below the waterline, the months — the signed knowledge web, deterministic planning as a pure function, infrastructure built for agents rather than eyeballs. At the base, the trust layer: Discovery (AEO) tells an agent you exist; Provenance tells it exactly what it was given and who vouched for it.

This morning Thomas Anglero published a piece called "The phone book of the agentic internet is being written — and I am the first speaker in it". His argument: the MCP registry — the official directory that tells AI agents which services they can interact with, not merely read — is being written right now, and the window between "technically possible" and "everyone does it" is where positions are won. He registered himself as the first professional keynote speaker in it.

175 Posts, No Map

I have spent six months writing about one idea: AI made creating easy but understanding harder. Output outruns navigation. Every jump in creation speed eventually produces a library with no catalog.

Last week I looked at this site and laughed. One hundred and seventy-five posts. Six series. Tens of thousands of words about knowledge infrastructure — organized as a reverse-chronological feed, which is to say, organized by the only dimension nobody searches by. The site about the comprehension bottleneck had hit its own comprehension bottleneck. If you arrived here from a search result, your options were the newest post and archaeology.

So the past week was a renovation — done the way the posts themselves argue it should be done.

Three Memory Schemes for Agents That Ship

Beyond the vector store: three memory schemes for production AI agents — moving from approximated embedding blobs to verifiable knowledge coordinates, covering session memory (kcp-memory), semantic memory (Synthesis), and claim memory (kcp-agent), with the convergence principle: memory is a coordinate, not a blob

Every agent framework ships a memory module. Almost all of them work the same way: embed the interaction, store the vector, retrieve by similarity. It works for demos. It does not survive contact with production — where "the agent remembered the wrong thing" is a bug report, not a philosophy seminar.

We have been shipping agents for six months across three codebases — kcp-memory (a session-indexing daemon), Synthesis (a codebase-aware semantic index and MCP server), and kcp-agent (a deterministic knowledge navigator). Each one needed memory. Each one built it independently, for different reasons, with different schemas. None of them use embeddings.

That is not a coincidence. It is a pattern worth examining.