Open Protocol · Agent Identity & Proof

Identity for AI agents.

Verifiable identity. Explicit permissions. Accountable actions.

ACPP gives agents a cryptographically verifiable identity, scoped permissions, and receipts for every consequential action — starting with GitHub.

Get Started See a real scenario

Agent Identity Permission Action Receipt

Trust principles

Identity is not authority.

Three separations that keep agent systems accountable.

Identity ≠ Authority

Knowing which agent is acting does not automatically grant it permission. Every protected action is evaluated against an explicit grant.

Discovery ≠ Consent

Finding an agent or capability does not authorize interaction or execution. Discovery returns only what policy already permits.

Signal ≠ Execution

A signed signal communicates intent or information. Execution requires the authorization path — signals never bypass policy.

Real-life scenario

A triage agent comments on a GitHub issue.

Your platform team connects GitHub once. An incident-response agent gets a narrow grant to post on issues — not the org token. Every comment leaves a receipt; revoke the grant and the next attempt is denied.

Ops

An alert opens issue #4821. Someone needs a status note on the thread — not a human hunting for a shared PAT.
Agent

TriageBot sends a signed signal: comment on #4821 with the latest findings.
ACPP

Verifies the agent identity, evaluates the grant (issues.comment only), and allows the action.
GitHub

The comment posts through the workspace connection. Credential never sits on the agent.
Receipt

Audit trail links signal → decision → outcome. Later, security revokes the grant — the next comment returns deny.

How ACPP works

From agent identity to verifiable action.

A protocol layer that separates identity, intent, authorization, execution, and evidence. Status labels reflect what ships in this repository today.

Identity

Stable acpp:agent addresses, Ed25519 keys, rotation, and lifecycle.

Available

Discovery

Resolve identities and permitted capabilities — discovery is not consent.

Available

Signals

Signed envelopes for events, requests, offers, responses, and revocations.

Available

Trust

Cryptographic identity proof today; richer trust relationships remain conceptual.

Conceptual

Authorization

Deny-by-default grants, evaluate, expire, and revoke before any protected action.

Available

Action

GitHub connector executes gated ops; MCP invoke remains an experimental sketch.

Partial

Receipts

Signal → verification → decision → outcome chain for accountable audit.

Available

Developer experience

A protocol you can build on.

Reference TypeScript SDK in the monorepo (@acpp/sdk). Packages are workspace-private today — clone the repo and run the local API.

import { createActorAddress } from "@acpp/core";
import {
  AcppHostedClient,
  generateEd25519KeyPair,
  signSignalEnvelope,
  verifySignalEnvelopeSignature,
} from "@acpp/sdk";

const keys = generateEd25519KeyPair();
const sender = createActorAddress("agent", "MYAGENT01");

const envelope = signSignalEnvelope(
  {
    signalId: "sig_my_request_01",
    type: "request",
    audience: createActorAddress("human", "owner"),
    contentType: "application/json",
    payload: { action: "issues.comment", repo: "org/repo" },
  },
  { sender, publicKey: keys.publicKey, privateKey: keys.privateKey },
);

// Identity proof ≠ permission to act
verifySignalEnvelopeSignature(envelope, keys.publicKey);

const client = new AcppHostedClient({
  baseUrl: "http://127.0.0.1:8787",
});
await client.submitSignal(envelope);

Protocol walkthrough

From request to verified receipt.

Same triage story as API steps: register → connect GitHub → authorize → signal → receipt → revoke → deny.

Demonstration sequence · mirrors docs/WEDGE.md and local demos

Register agent identity

Create acpp:agent:… with an Ed25519 key pair.

Route: POST /v1/workspaces/{id}/identities
Agent: acpp:agent:…
Resource: github:repo:org/repo
Action: issues.comment

Step ready

Try the live inspector after starting the API: /receipts

Integrations

Designed to work across agent systems.

ACPP is a reusable protocol layer — not a lock-in to one agent framework. Status reflects this repository.

GitHub

Available

Connect once per workspace. Scoped grants gate issues.comment and repos.metadata.read.

Learn more →

MCP

Experimental

Gateway sketch and security helpers. Capabilities endpoint live; connect/invoke still sketch.

Learn more →

A2A

Planned

Interoperability direction for agent-to-agent messaging. No connector shipped yet.

Learn more →

Protocol architecture

A protocol layer, not another agent runtime.

Agent runtimes keep doing their work. ACPP supplies identity, signals, authorization, and proof around consequential actions.

Agent applications / runtimes Orchestrators, tools, and workflows you already run

ACPP — identity, signals, authorization & proof @acpp/identity · signals · policy · receipts · connectors

Connected tools & external systems GitHub today · MCP path experimental · more connectors later

Give your agents a real identity.

Make agent identity verifiable, permissions explicit, and consequential actions accountable.

Get Started Explore on GitHub