Introduction: Seeing What Is Missing
In our previous post, The Pathway to AGI Isn’t Intelligence, It’s Shared Cognition,we argued that the real bottleneck in human-AI collaboration isn't model intelligence—it's the Amnesia Problem: AI doesn't remember what matters, can't evolve context across sessions, and has no structured way to reason with humans over time. The solution is what we call the Cortex Layer.
This post examines where the Cortex Layer fits in today's agent infrastructure—what existing protocols enable, what they lack, and why persistent, human-centered context remains missing. We'll then show what's required to close that gap.
Current protocols solve important pieces of the puzzle: MCP provides plugin and tool access, A2A/ACP/ANP enable agent messaging, and RAG pipelines fetch information. But none provide persistent, human-aligned memory where context can live, evolve, and be jointly shaped by humans and agents across tools and time.
The table below makes this gap clear:
| Layer | Purpose | Human-in-loop? | Persistent context? |
|---|---|---|---|
| MCP | Plugin & tool access | ❌ | ❌ |
| A2A / ACP / ANP | Agent messaging | ❌ | ❌ |
| Cortex Layer (ASCP) |
Shared memory & context for reasoning | ✅ | ✅ |
We believe humans must be at the center—defining goals, making decisions, and shaping context over time. That requires durable infrastructure built around human mental models and workflows, not just stateless protocols for agent coordination. The sections below examine each layer in detail, showing exactly why existing protocols, while valuable, cannot provide what the Cortex Layer offers.
The Existing Stack
Agent Plugin Layer (MCP)
The Model Context Protocol (MCP) standardizes how agents access tools and data through a clean JSON-RPC interface. It excels at exposing capabilities—plugin discovery, invocation, and schema sharing.
What MCP doesn't provide is memory. It encodes no record of how, when, or why tools were used. There's no persistent trace of project reasoning or task evolution. Even when a plugin writes to a database, that structure remains opaque to other agents unless specifically configured.
This is the crucial distinction: MCP is a plugin architecture, not a memory architecture.
The Cortex Layer is meant to sit alongside MCP, not replace it — giving agents the persistent, human-centered context that MCP, by design, leaves out.
Agent Messenger Layer (A2A, ACP, ANP)
Protocols like Agent-to-Agent (A2A), Agent Communication Protocol (ACP), and Agent Network Protocol (ANP) enable agent-based task negotiation, coordination, and execution. Agents can prompt one another, assign subtasks, and share intermediate results—essentially functioning as chat protocols between autonomous processes.
This is powerful for microservice-like composition or agent networks, but it reduces humans to prompt engineers rather than true collaborators. This isn't a failure of these protocols—they're built for messaging and orchestration, not for preserving shared context across time. The Cortex Layer works alongside them, providing the persistent, human-centered substrate they deliberately do not define.
Enter the Cortex Layer
In practical terms, this means teams shouldn’t have to re-explain context every time they switch tools, and agents shouldn’t forget the decisions they helped make nor trap humans in trial-and-error loops trying to steer agent behavior. The solution is true shared cognition—which is precisely what a Cortex Layer unlocks.
What a complete solution must provide
Before introducing the protocol, it’s helpful to define what the missing layer must deliver:
persistent: context that survives across sessions
collaborative: designed for both humans and agents
structured: with a common grammar for expressing meaning
interoperable: able to span tools, platforms, and ecosystems
vendor-neutral: controlled by open standards, not platforms
Surprisingly, no protocol currently solves for this. That's why we created the Agents Shared Cognition Protocol (ASCP).
How ASCP Delivers the Cortex Layer
ASCP introduces a structured, distributed, and secure substrate that provides the missing Cortex Layer—not with more text chat or better plugins, but with shared cognition infrastructure.
At its core are two novel elements: Artipoints and Articulation Statements:
Artipoints represent addressable references to content and context — like bookmarks, but with additional semantics.
Articulation Statements are immutable, timestamped statements about context — e.g., “this document is relevant to this stream” or “this task is deprioritized.”
Together, these elements turn human intent, context, decisions, and milestones into first-class digital artifacts. ASCP then builds on this foundation with three core technical principles:
Verifiable and tamper-proof context
Every articulation is cryptographically signed and stored in an append-only log, ensuring no participant can retroactively alter statements or impersonate other contributors—all without the complexity or overhead of blockchain.
Privacy-preserving collaboration
ASCP Channels use JOSE (JWS/JWE) to encrypt statements with symmetric ciphers like AES to ensure only authorized participants can read shared context — while still allowing flexible access control as projects evolve.
True local-first operation
Using CRDT-inspired synchronization, participants can work offline or across devices without sacrificing consistency or requiring a central authority.
Human-Centered organization
Work is organized into Streams (context-switchable threads of work) and Spaces (collections of Streams for broader outcomes). These are how humans encounter the Cortex Layer, even though underlying applications manipulate Artipoints and logs.
ASCP is built around human mental models first. Instead of asking humans to adapt to AI-native structures, it creates a substrate that reflects how people naturally think, plan, and coordinate.
And because ASCP is open and standard-based, context remains portable, inspectable, and user-controlled, not trapped inside proprietary agent memory systems.
Why the Cortex Layer Matters
The Cortex Layer establishes the foundational layer for coordinated intelligences undertaking shared cognition that specifically favors human agency.
Instead of humans becoming better prompt engineers, AI becomes a better collaborative partner.
ASCP allows human intent, context, and decisions to become first-class digital artifacts and provides the substrate for collaboration that compounds rather than resets.
Conclusion
If shared cognition is the pathway to AGI, the Cortex Layer is the roadbed: a structured, durable substrate that makes that path real.
It gives us the continuity modern agents lack and a way for teams and tools to build understanding that compounds instead of resets.
In the next post, Introduction to ASCP, we’ll lift the hood on the protocol that makes this possible.
ASCP turns shared context into a formal, open standard: cryptographically anchored, interoperable, and designed for persistent, collaborative memory across every agent, tool, and device.If you’re working on agent frameworks or collaborative AI and want a preview (or a role in shaping the spec), reach out to us anytime.
.png)
%20(2).png)
