Introducing AISP: The Protocol AI Sessions Have Been Waiting For

We've all been there. You're building a multi-agent system and you hit the same wall every time: there's no standard way for one session to find another, no standard way to hand off a task, no standard way to share context without rebuilding the entire plumbing from scratch. You end up writing bespoke glue code that only works inside your own stack, and the next team does the same thing six months later.

The AI tooling ecosystem has solved model access (via APIs), tool use (via MCP and function calling), and memory within a single session context window. What it hasn't solved is the gap between sessions — the moment one agent needs to talk to another agent that it didn't spawn itself.

The missing layer isn't model capability. It's identity. Agents need stable addresses, shared context, and explicit consent before collaboration can scale.

What AISP Is — and Isn't

The Agent Interoperability Session Protocol (AISP) is an open standard for session-to-session communication between AI agents. It defines how agents discover each other, establish identity, share memory, delegate tasks, and express consent.

AISP is nota model API. It doesn't know or care whether your agent is powered by a 70B open-source model or a cloud LLM. It's nota replacement for MCP — MCP handles tool use within a session, AISP handles communication between sessions. It's nota platform — it's a spec with a reference implementation.

The Protocol Stack

AISP is designed to sit alongside MCP in a complementary layering, not compete with it:

Seven Categories, One Protocol

All AISP messages belong to one of seven categories. Each category has a defined payload schema, and hubs route messages based on category. This keeps the core protocol simple while enabling rich behavior at the application layer.

Want to add custom message types for your domain? AISP supports extension categories with the x- prefix. Extensions are first-class — they travel inside the standard envelope and are routable by any hub.

Hello World in 10 Lines

Here's what a delegation from one AISP session to another looks like in TypeScript, using the official SDK:

import { AISPClient } from '@aisp/sdk';

const client = new AISPClient({
  sessionId: 'sess_01HX9J2N3PQRSTVWXYZ',
  hub: 'https://hub.aisp.dev',
  apiKey: process.env.AISP_API_KEY,
});

// Discover the worker session in our realm
const peers = await client.discover({ kind: 'executor' });
const worker = peers[0];

// Delegate a task — returns when the worker sends a result
const result = await client.delegate(worker.id, {
  task: 'summarize',
  input: { file: 'README.md' },
  deadline: new Date(Date.now() + 30_000),
});

console.log(result.output.summary);
// → "A comprehensive README covering installation, usage, and examples."

On the worker side, listening for delegations is equally simple:

import { AISPClient } from '@aisp/sdk';

const worker = new AISPClient({
  sessionId: 'sess_02HX9J2N3PQRSTVWXYZ',
  hub: 'https://hub.aisp.dev',
  apiKey: process.env.AISP_API_KEY,
});

// Start the session and announce to the realm
await worker.start({ name: 'worker', kind: 'executor' });

// Listen for incoming delegation requests
worker.on('delegate', async (task) => {
  console.log('Received task:', task.payload.task);

  // Do the actual work
  const summary = await summarizeFile(task.payload.input.file);

  // Reply with the result
  await task.complete({ summary });
});

Why an Open Standard Matters

The moment AI agent collaboration becomes dependent on any single vendor's proprietary protocol, the ecosystem fragments. Teams building on Platform A can't collaborate with teams on Platform B. Open-source agents can't interoperate with commercial ones. You end up with the same problem we had with messaging APIs in 2008, or APIs in 2012 — except this time, the cost of fragmentation is measured in wasted compute and missed compounding capability.

AISP is designed to be the TCP/IP of AI session communication — boring, stable, and universal. We've kept the core spec intentionally minimal (seven message categories, four compliance levels) so that any runtime can implement it without ceremony.

The spec is MIT-licensed. The reference hub is MIT-licensed. The SDKs are MIT-licensed. We will never monetize the protocol itself — only tooling, hosted infrastructure, and enterprise support built on top of it.

A common session protocol is a tide that lifts all boats. We want every AI framework, every agent platform, and every hobbyist project to be able to speak AISP.

Start Simple, Scale Gradually

One of our core design goals was progressive complexity. You shouldn't need a hub server, a database, or any infrastructure to get started with AISP. That's why L0 works entirely on the local filesystem — JSON files in a shared directory. It's the simplest possible implementation that still delivers the value of a shared session identity and message exchange.

As your system grows, you upgrade compliance levels. L1 adds a hub and HTTP routing. L2 adds WebSocket streaming and Ed25519 message signing. L3 adds TLS encryption and full audit logging. At every level, the same AISP envelope format is used — upgrading compliance level doesn't require changing your application code.

Getting Started Today

The assisted beta path validates the CLI and runtime before publishing deployment-specific setup commands:

# macOS
brew install aisp

# Linux / CI
aisp assisted-install

# npm (any platform)
npm install -g @aisp/cli

Then initialize your first realm and start a session:

aisp realm setup
aisp session start --name "hello-world" --kind interactive
aisp discover  # see your session in the realm

The Getting Started guide walks through everything from there — discovery, memory, and two-session delegation in under five minutes.