The protocol stack

COYL is the authority layer for LLMs acting in the world.

MCP connects agents to tools. A2A lets agents talk to agents. COYL is the layer underneath both: permission, audit, control, and provenance for an agent acting on a person’s behalf. Scoped, revocable, rate-limited, auditable, provenance-signed, kill-switchable — and portable across every model and device.

The moment an LLM stops answering and starts acting for someone, it needs a contract for what it’s allowed to do, who it answers to, and how the person takes control back. That contract is five orthogonal layers — read, propose, act, hold standing authority, and stop — each implementable on its own, each implemented in this repository today.

The specs are open (Apache 2.0). The reference engine and the typed @coyl/protocolSDK are in alpha. Below: the stack, a coordinator you can hit right now, and the safety floor a Trust & Safety reviewer asks about first. UAP · RAP

00 · The foundation

Permission is the only thing that lets an agent act safely on your behalf.

Standing authority — the User-Authority Protocol — sits at the foundation of the stack. It answers the question every other layer depends on: what did the person authorize this agent to do, and how far can it go? Every other layer reads that answer before it fires. Every grant is bounded, revocable, kill-switch-first, and auditable.

MCP connects agents to tools. A2A lets agents talk to agents. COYL is the permission, audit, and control layer underneath — the part that says what an agent may do on a real person’s behalf, records what it did, and lets that person take it all back in one move.

01 · The stack

UAP at the foundation. RAP as the override. Five orthogonal layers, each implementable independently.

UAP holds the user’s standing authority — what the model is permitted to do. BIP is the substrate that says what loop the user is in. PAP narrows action to behavioral interventions with safety guardrails. EAP carries action across devices, one action at a time. RAP sits at the override layer: when risk crosses the floor, it stops every other protocol and routes to a human. Each layer can be implemented independently.

Override layer · fires when risk crosses the floor

RAP v0.1 · draft

When the AI stops coaching and routes to a human. Overrides every other layer.

Action layer

EAP v0.1 · cross-device action

Per-action execution across the device fleet, with consent + reversibility envelopes.

Proposal layer

PAP v0.1 · proactive intervention

LLMs propose, coordinator arbitrates. Multi-vendor Switzerland for behavioral interrupts.

Substrate layer

BIP v0.1 · behavioral context

What loop is the user in right now. The primitive other layers read.

Foundation · what the user permits

UAP v0.1 · standing authority

The consent surface every other layer reads before firing. Bounded grants. Kill-switch first.

Bottom of stack

The user

Who issues UAP grants. Who any of this exists to serve.

01b · What’s actually shipped

A typed SDK, a runnable demo, and a live safety floor. Not a slide deck.

The five-layer stack is implemented in this repository — read, propose, act, standing-authority, safety-floor. The specs are Apache 2.0; the reference engine and the SDK are alpha. Three proofs make that concrete.

The SDK · alpha

@coyl/protocol

A typed, zero-dependency TypeScript client. UAPClient does grant / precheck / execute / revoke / audit / kill-switch / verify-provenance. EAPDeviceClient registers a device, polls for approved actions, reports outcomes, and publishes sensor snapshots. Typed against the live route handlers — wire shapes can change before 1.0.

The demo · runnable

Grant it, then try to break it.

One script walks the whole trust contract: grant → reversible action allowed and audited → irreversible send denied (it fails closed) → provenance verified on an allowed representation action → kill switch → the next action is dead. The fail-closed denial is the point.

The safety floor · live

Gates both paths. First.

The closed-coaching-path check runs ahead of every other gate on the agent path — a crisis-class assessment denies a proposal or a standing-authority execution before scope or rate limits are even read. The same check runs before any consumer interrupt: a person in a closed path is never nudged. Classifier, routing envelopes, and store are implemented today.

02 · The specs

Read the substrate. Propose the moment. Act across the fleet. Hold standing authority.

BIP v0.1 · Apache 2.0

Behavioral Interrupt Protocol The substrate.

BIP is the consumer-side primitive. Apps emit behavioral signals (a tab-switch, an HRV spike, an open-fridge event). Apps consume a single read API that returns the user’s current behavioral state — archetype, danger-window status, excuse pattern, risk level. No PII. Only behavioral abstractions.

Wearables don’t need to understand psychology. Calendar apps don’t need to model attention. Each emits the signal it already collects; BIP coordinates the meaning. That coordination layer is what every LLM and every device today is missing.

BIP is the substrate both PAP and EAP consume. If you only ship a consumer app, you implement BIP. If you ship an LLM or a device fleet, you read BIP and emit through PAP or EAP.

Behavioral context (read)

http
GET /v1/context/{user_id}
Authorization: Bearer <token>

{
  "spec_version": "0.1",
  "archetype": "9PM_NEGOTIATOR",
  "archetype_confidence": 0.83,
  "danger_window_active": true,
  "current_excuse_category": "DESERVER",
  "self_trust_score": 74,
  "risk_level": "HIGH",
  "freshness": { "ttl_seconds": 60 }
}

Signal emit (push)

http
POST /v1/signal
Authorization: Bearer <token>

{
  "user_id": "u_2sj8xks0a",
  "source": "apple_watch",
  "type": "hrv_spike",
  "magnitude": 0.71,
  "captured_at": "2026-05-21T21:47:03Z"
}

Outcome webhook

http
POST <your_webhook_url>
X-BIP-Signature: sha256=<hmac>
X-BIP-Event: INTERRUPT_RESOLVED

{
  "event": "INTERRUPT_RESOLVED",
  "user_id": "u_2sj8xks0a",
  "outcome": "STOPPED",
  "elapsed_seconds": 47,
  "pattern_update": { "self_trust_score": 1 }
}

PAP v0.1 · Apache 2.0

Proactive-Action Protocol The behavioral intervention layer.

PAP is how LLMs propose behavioral interventions. A model reads BIP context, decides the moment is right, and submits a Proposal envelope to the COYL Coordinator. The envelope declares the proposed intervention, the rationale, the scope, the channel, and a reversibility class. The Coordinator decides whether to FIRE, DEFER, or REJECT.

PAP exists because behavioral interventions are not free actions. They cost the user’s attention. They can be wrong. They can be overcorrected. The Coordinator enforces rate limits across competing LLMs, dedups proposals targeting the same behavioral moment, checks user scope grants, and respects quiet hours. The user is never spammed by every model on the market firing at the same moment.

PAP is the protocol foundation labs implement to make their assistants behaviorally aware without re-implementing the safety layer. Claude, GPT, and Gemini each emit Proposals. COYL Cloud arbitrates which one — if any — fires.

Proposal envelope

http
POST /v1/pap/proposal
Authorization: Bearer <llm_partner_key>

{
  "spec_version": "0.1",
  "user_id": "u_2sj8xks0a",
  "proposing_llm": "claude-opus-4",
  "intent": "INTERRUPT_LATE_NIGHT_EATING",
  "rationale_summary": "9pm_negotiator pattern, danger window active",
  "reversibility": "REVERSIBLE",
  "channel_preference": ["push", "watch_haptic"],
  "expires_at": "2026-05-21T21:50:00Z"
}

Coordinator decision

http
→ 200 OK
{
  "decision": "FIRE",
  "proposal_id": "prop_7xj2k9q",
  "dispatched_channels": ["push"],
  "rate_limit_remaining": 8,
  "competing_proposals_deduped": 2,
  "audit_log_id": "log_aQ91xx"
}

Scope grants (consent)

http
GET /v1/pap/scope/{user_id}

{
  "grants": [
    {
      "llm_id": "claude-opus-4",
      "scopes": ["read:context", "propose:intervention"],
      "quiet_hours": ["22:30-07:00"],
      "monthly_intervention_cap": 1000,
      "revoked_at": null
    }
  ]
}

EAP v0.1 · Apache 2.0

Execution-Action Protocol The cross-device action layer.

EAP is the superset. An LLM authors an Action Request — vibrate this Watch, surface this Lock-Screen card, dim this room’s lights, draft this message in the user’s reply queue — and the Coordinator routes it to the right device bridge with the right consent, the right scope, and the right reversibility envelope.

PAP is a subset of EAP focused on behavioral interventions. EAP covers everything else: ambient nudges, calendar actions, browser-context cards, watch glances, surfacing-on-Lock-Screen. The same Coordinator engine governs both. Same audit log. Same revocation surface.

EAP is what makes “your AI” portable across devices without each device fleet needing a direct LLM integration. The LLM speaks EAP. The bridge translates. The user has one consent surface across every model, every device.

Action request

http
POST /v1/eap/action
Authorization: Bearer <llm_partner_key>

{
  "spec_version": "0.1",
  "user_id": "u_2sj8xks0a",
  "action_type": "WATCH_HAPTIC_CARD",
  "payload": {
    "title": "Pause.",
    "body": "9:47pm. You&rsquo;re a deserver tonight.",
    "primary_action": "ACKNOWLEDGE",
    "secondary_action": "OVERRIDE"
  },
  "reversibility": "REVERSIBLE",
  "scope": "behavioral_intervention",
  "ttl_seconds": 180
}

Device bridge dispatch

http
→ 200 OK
{
  "action_id": "act_9k2x7p",
  "bridge": "apple_watch_v1",
  "dispatched_at": "2026-05-21T21:47:08Z",
  "delivery_state": "DELIVERED",
  "user_response_expected_until": "2026-05-21T21:50:08Z"
}

Irreversible-action gate

http
POST /v1/eap/action
{
  "action_type": "SEND_MESSAGE",
  "reversibility": "IRREVERSIBLE",
  ...
}

→ 202 Accepted
{
  "decision": "AWAITING_USER_CONFIRMATION",
  "confirmation_surface": "lock_screen_card",
  "confirmation_expires_at": "2026-05-21T21:48:00Z"
}

UAP v0.1 · Apache 2.0

User-Authority Protocol The standing-authority layer.

UAP is the fourth layer of the COYL stack — the trust contract a user issues to an LLM when they want autonomous action without per-action consent. BIP, PAP, and EAP all assume the user is present: the model proposes, the user confirms, the action fires. UAP is for the moments the user is absent. Daily routines. Tomorrow’s calendar. Recurring purchases. Scheduled deliveries. The category every foundation lab is shipping in 2026, with no defensible consent model under it.

UAP defines exactly eight primitives — GRANT, REVOKE, KILL_SWITCH, PRECHECK, EXECUTE, EXPIRE, RULE_DECLARE, AUDIT_QUERY — and a small set of hard invariants. Every grant has a bounded expiry (90 days max, 7 days default). Irreversibles always re-confirm, even under standing grant. The kill switch supersedes every grant, every rule, every in-flight action, and propagates across all surfaces in five seconds. The audit log is append-only, cryptographically signed, and owned by the user — not the LLM, not COYL.

The strategic read is this: the capability for agentic AI exists today. The trust infrastructure does not. UAP is the layer that lets foundation labs ship agentic AI safely without each inventing a brittle ad-hoc consent model — and the layer that, by virtue of being open-spec, audit-defaulted, kill-switch-first, and cross-LLM portable, cannot be reasonably forked by any single lab without losing the portability that gives it value. The protocol is the trust contract. The trust contract is the moat.

GRANT request

http
POST /api/uap/v1/grant
Authorization: Bearer coyl_uap_<partner_id>_<secret>

{
  "user_id": "u_2sj8xks0a",
  "scopes": [
    "calendar.write",
    "messaging.routine",
    "purchase.recurring"
  ],
  "expires_at": "2026-05-29T17:00:00Z",
  "rules": [
    { "kind": "spending_cap", "max_per_action_usd": 50 },
    { "kind": "quiet_hours", "from": "00:00", "to": "07:00",
      "tz": "America/Los_Angeles" },
    { "kind": "irreversible_floor",
      "always_confirm": ["money_transfer", "share_pii"] }
  ],
  "consent_artifact": {
    "version": "0.1",
    "shown_to_user_at": "2026-05-22T16:58:00Z",
    "user_response": "explicit_grant",
    "ui_surface": "settings.standing_authority"
  }
}

KILL_SWITCH request

http
POST /api/uap/v1/kill-switch
Authorization: <user session, not partner token>

{
  "user_id": "u_2sj8xks0a",
  "reason": "user_initiated"
}

→ 200 OK
{
  "killed": true,
  "affected_grant_count": 7,
  "propagation_deadline": "2026-05-22T17:02:19Z",
  "audit_url": "https://coyl.ai/audit/uap/kill_aD9k2x"
}

02b · Live

The coordinator. Not a diagram.

Pick a scenario. Slide a confidence. POST hits /api/v1/protocol/demo — which runs the same isAboveConfidenceThreshold function the proposal endpoint at /api/pap/v1/proposal uses. The decision you see is what the reference coordinator returns — no auth, no database writes.

No panic. Daytime. No rate limit. Decision turns on confidence.

One of the nine PAP scopes the user can grant per LLM partner.

DEFAULT_CONFIDENCE_THRESHOLD = 0.70 in production. Anything below denies with confidence_too_low.

02c · The first integration is COYL itself

We run our own coordinator before we ask anyone else to.

COYL’s own consumer app is the first partner to the proposal coordinator. It emits proposals through an internal partner — partner id coyl_internal — and the coordinator evaluates each one against real user state: panic, quiet hours, rate limit, dedup, confidence, and the RAP safety floor first. Every decision is audited.

A reviewer querying the audit table sees the coordinator making real decisions against real state — not a mock. The stack isn’t aspirational; it’s the same path COYL’s own interrupts already run through. The engine is alpha and design-partner-invited, not a public hosted production service.

03 · Why separate layers, not one

Separate concerns. Separate layers. One coordinator, one safety floor.

BIP — the substrate

Consumer-side. Read & emit.

BIP is what consumer apps and wearables implement. It carries behavioral signal in and behavioral state out. It is a substrate, not an action layer. Everything above it consumes it.

PAP — the behavior layer

LLM proposes. Coordinator arbitrates.

PAP is narrowed to behavioral interventions. The envelope demands rationale + reversibility + scope. The Coordinator enforces rate limits across competing LLMs. The user is not bombarded by every model at the same moment.

EAP — the action layer

Cross-device action with consent envelopes.

EAP carries one action at a time across watch, phone, browser, lock screen, and ambient surfaces. Per-action confirmation for irreversibles. Same audit. Same revocation. Same consent surface — while the user is present.

UAP — the standing-authority layer

User-level. Grant & revoke.

UAP is for the moments the user is absent. The user issues a bounded grant — scope-limited, time-limited, rule-governed. The model acts under it. Every execute is audit-signed. Expiry is hard. The kill switch revokes everything fast. It’s the layer that lets a team ship agents that act on a person’s behalf without inventing a brittle consent model per product.

The layering

UAP holds standing authority. EAP carries one action. PAP narrows to behavior. BIP is the substrate all three consume. RAP is the safety floor that overrides them all.

The separation is what lets a wearable implement only BIP without taking on action responsibility. It is what lets a foundation lab implement PAP for behavioral assistants without committing to the full EAP surface. It is what lets a labs partner build agentic-AI features on UAP without re-inventing the consent UI, the audit log, or the kill-switch propagation guarantee. The user’s consent surface stays coherent across every model competing for the same moment and across every grant standing in the background.

04 · The reference engine

The specs are open. The reference engine is ours.

Anyone can implement the specs. COYL maintains the reference engine — the coordinator, the audit log, the device bridges, and the consent surface — the same way an open standard is anchored by a canonical implementation. The category exists because the contract is open; the company exists because the engine and the integration depth are ours. The engine is in alpha today.

The Coordinator engine

Rate limits. Dedup. Scope. Quiet hours.

Across every LLM proposing through PAP. Across every action firing through EAP. One arbitration loop. One audit log. One revocation surface. Foundation labs do not need to build this. They route through it.

Audit logs

Every proposal. Every decision. Every outcome.

Append-only. User-visible. Exportable. Required for the kind of consumer trust that lets people grant proactive authority to an LLM in the first place. Required for the compliance surface enterprises actually buy.

Device bridges

iOS. macOS. Watch. Browser.

A library of first-party bridges that translate EAP Action Requests into platform-native primitives. LLMs author EAP. The bridges deliver. New devices ship; the bridges expand; the LLMs don’t need to recompile.

Consent UI

One surface across every model.

The user sees every LLM that has authority, every scope granted, every quiet hour, every revocation. One mental model across Claude, GPT, Gemini, and whatever ships next. The thing every individual LLM’s app can’t build alone.

Where this stands

Specs published. Engine and SDK in alpha. Design partners invited.

  • ·The specs. Apache 2.0, published, free to implement. The open contract is what makes the category real.
  • ·The engine + SDK. The reference coordinators, the safety floor, the typed @coyl/protocol client, and the runnable demo are in this repo, in alpha. Wire shapes may still change before 1.0.
  • ·Commercial terms. A design-partner conversation, not a public price list. We’d rather shape the integration with you than hand you a finished black box.

05 · Get started

Two paths in. One stack underneath.

06 · The honest questions

What an AI platform team actually asks.

Why publish the spec open-source if it&rsquo;s your moat?

Because the moat is not the spec. The moat is the reference engine + the data quality + the integration library + the consent surface the user actually trusts. Anthropic open-sourced MCP. OAuth was open. Stripe Checkout integrations were open. The spec being open is what makes the category exist. The engine being ours is what makes the company exist.

What stops Anthropic from building this themselves?

Nothing stops them from implementing the spec — that&rsquo;s the point. What stops them from owning the category is the cross-LLM coordination problem. The user&rsquo;s consent surface has to span every model. The audit log has to be neutral. A single foundation lab cannot credibly arbitrate proposals from its competitors. The Coordinator has to be Switzerland. That&rsquo;s the structural reason this layer is not first-party LLM work.

How do you handle rate limits across competing LLMs?

The Coordinator runs per-user, per-LLM, and per-moment rate limits. Per-user caps the total interventions the user receives in any window. Per-LLM enforces the partner&rsquo;s grant. Per-moment dedups overlapping proposals targeting the same behavioral window — if Claude and GPT both detect the 9pm pattern, only one fires, chosen by user-set preference rules. The user can&rsquo;t be spammed by every model on the market firing at once.

Can users revoke any LLM&rsquo;s authority?

Yes — that&rsquo;s the consent surface. The user sees every LLM that holds any scope, every grant, every quiet hour. Revocation is one tap, takes effect on the next proposal, and is persisted in the audit log. Without this surface, no user grants proactive authority. With it, they do.

How do you handle irreversible actions like &ldquo;send a message&rdquo; or &ldquo;make a purchase&rdquo;?

EAP requires every Action Request to declare a reversibility class — REVERSIBLE, REVERSIBLE_WITHIN_WINDOW, or IRREVERSIBLE. Irreversible actions never auto-fire. The Coordinator returns AWAITING_USER_CONFIRMATION and pushes a confirmation surface (lock-screen card, watch glance, app intent) with a short TTL. The LLM never directly executes irreversible action; the user does. Same envelope, hard guarantee.

When does the AI stop coaching and route to a human?

That&rsquo;s the safety floor — the Risk Assessment Protocol — and it&rsquo;s implemented, not promised. A per-moment classifier assigns a risk class; a crisis or emergency class closes the coaching path and emits a jurisdiction-aware routing envelope. The closed-path check runs as the first gate on both the agent path (the proposal coordinator and standing-authority execution both deny ahead of scope and rate limits) and the consumer interrupt path (a person in a closed path is never nudged). Nothing reopens the path until a human-reviewed reopen is logged. This is the question a Trust &amp; Safety reviewer asks first; we answer it in code.

How does an action carry proof of who acted, and under whose authority?

Every allowed representation action is provenance-signed. The signed envelope names the acting agent and the subject, and is verifiable through a public, unauthenticated endpoint — so a recipient can confirm an action was taken by a specific agent under a specific standing grant. Irreversible representation actions hit the irreversibility floor first and are denied for per-action confirmation, so they are never signed-and-sent silently. The runnable demo verifies a real signature end to end.

What about Apple? They won&rsquo;t adopt this.

Apple doesn&rsquo;t need to adopt the spec for the spec to work — the device bridges run inside our reference engine. We use the surfaces Apple already exposes (push, App Intents, Watch complications, Live Activities, Lock-Screen widgets). If Apple ever builds a first-party version, the spec is what their developers cite to argue for parity. The protocol is the policy lever.

What&rsquo;s the status — can we use this in production today?

Honest answer: the five specs are published under Apache 2.0; the reference engine and the @coyl/protocol SDK are in alpha, in this repository, with the safety floor, the coordinators, and a runnable authority demo all implemented. There is no public hosted production API with an uptime promise — and we&rsquo;re not going to claim one. We&rsquo;re inviting design partners precisely so the engine hardens against real integrations before 1.0. Commercial terms are part of that conversation, not a published price list.

The authority layer for LLMs acting in the world.

Permission, audit, control, and provenance for an agent acting on a person’s behalf — read the context, propose the moment, act across the fleet, hold bounded standing authority, and stop at the safety floor. Five open specs; an alpha reference engine and SDK; design partners invited.