Something caught my attention this week. JJHub launched a version control platform built on Jujutsu instead of Git, designed specifically for agentic engineering teams. The premise: Git's data model breaks under the commit volume that agents produce.
That observation is narrowly about version control. But the pattern it reveals is much broader.
Tim O'Reilly posted something this week about craftsmanship in the AI age. The question he was circling: how do you maintain quality standards when agents are doing the work?
The default answer in the industry is: keep the human in the loop. For every meaningful decision, have a human review before proceeding.
That model contains a fatal flaw.
Something felt off.
I'd been using the Task tool heavily — delegating research tasks to Claude subagents, letting them explore codebases, map dependencies, surface patterns. The results coming back were good. But when I'd start a new session and ask about the same topic, there was no trace of that prior investigation. The context window had reset, and the episodic memory layer — kcp-memory — wasn't helping.
Here's what that looked like in practice: I'd asked a subagent to map the co-events repository ecosystem earlier this week. It came back with a clear picture — co-events is the CatalystOne HRIS event-sourcing platform, seven repos, with a dependency chain running from co-event-typelib through co-event-sdk into co-analytics-vanilla (which, by the way, uses Neo4j with APOC, not SQL — a non-obvious choice). Two days later, I started a new session, asked about co-events architecture, and got a blank stare. The agent had no idea any of this had been mapped. It treated the question as entirely novel.
My first hypothesis was handover loss. Maybe something was being compressed or summarized too aggressively when agents returned their findings. Maybe the model transition (often Opus for the delegated tasks, Sonnet for the orchestrating session) was dropping context. That felt plausible, and a little unsettling.
The real cause was more concrete — and more fixable.
Something is being assembled right now, mostly without a name for it.
Production pipelines where agents write code, run tests, and open pull requests. Compliance workflows where agents check controls, gather evidence, and escalate to humans when something needs a decision. Developer rigs where an agent calls a tool, the tool delegates to a sub-agent, the sub-agent calls an API, and the result flows back up the chain.
The models are capable. The tooling is solid. The use cases are real.
What we are building — collectively, across hundreds of teams and projects — is an autonomous agentic web. And like the original web, it will only become useful when the pieces can talk to each other reliably. We are not there yet. The reason is interesting.
An agent is about to call a knowledge server. It has no idea what that server knows, how sensitive the content is, or whether the answer will fit in its remaining context window. So it calls blindly and hopes for the best.
v0.10 fixes that with RFC-0007: a normative query vocabulary that lets agents ask before they invoke.
Multi-agent systems need two kinds of identity. The first answers "who is this agent and how do I call it." The second answers "what knowledge does this agent have and who is allowed to see each piece of it." Google's A2A protocol handles the first. KCP handles the second. They are not competitors. They are different layers of the same stack.
This post started as that explanation. Then, the same day it was published, we built four simulators and 150 adversarial tests against the spec. The tests found 8 concrete gaps. Those gaps are now driving KCP v0.7. The full story follows.
A few days ago we prepared a roadmap for bringing KCP to GitHub Copilot users. Three phases, estimated ten days. This is the post where I explain that we shipped all three phases today — and then shipped a fourth: a complete zero-MCP path for enterprises that cannot run MCP servers.
Most AI productivity discussion asks the wrong question. "How much faster?" assumes the difference is speed. It is not. Two developers using the same model, the same IDE integration, the same subscription tier -- one of them starts every session cold and the other does not. The gap between them is not the engine. It is the transmission. But the transmission alone is not the full story either. There is a third variable: how the driver was trained.
Written the day both came online.
Every token Claude Code's context window can hold is an opportunity — a tool call result that stays in scope, a file that does not need to be re-read, a decision that does not need to be recapped. Wasting those tokens on noise is a quiet tax on every session.
Today we are releasing kcp-commands: a Claude Code hook that recovers 33.7% of a 200K context window in a typical agentic coding session by intercepting Bash tool calls at two critical points.
The full number across our benchmark session: 67,352 tokens saved.
Update (March 3, 2026 — v0.9.0): kcp-commands now writes a JSON event to
~/.kcp/events.jsonl on every Phase A Bash hook call. kcp-memory v0.4.0
ingests that stream to provide tool-level episodic memory — kcp-memory events search
"kubectl apply" returns every time Claude ran that command across all your projects.
Phase A gives Claude vocabulary. Phase B cleans output. Phase C remembers what ran.