Intelligence Above the API

01Three planes, one architecture

Each plane answers a different question, and none substitutes for another:

The compact forms, stated once for the record: IPI is the programming interface for intelligence that acts. OPI is the programming interface for intelligence that coordinates. PAP is the communication protocol for intelligences that work together.

02The interface layer mirrors the model layer

The published research established a duality above these planes: STA decides what the surface does; STO decides which intelligence does it. The interface layer now extends that sentence downward — IPI exposes what the surface can do. OPI exposes how intelligence can be coordinated. The symmetry runs the full height of the stack:

The spoken-unit row deserves its definition here, since every LabsAI surface runs on it: throughout this platform, STA and STO work arrives as voice commands — Speech‑to‑Action Voice Commands, the unit of spoken work an STA Model interprets and executes against a surface, and Speech‑to‑Orchestration Voice Commands, the unit of spoken coordination an STO Model interprets and runs as policy. One sentence from a visitor is one or several voice commands; the planes below decide where each one lands.

03What an IPI is

An Interactive Programming Interface is a programmable interface through which intelligence perceives, addresses, manipulates and verifies actions against an interactive environment. The emphasis lands on the last verb. Tool calling, as commonly practiced, is an open loop: emit the call, hope. An IPI is a closed one — Observe → Reference → Act → Verify → Update state — and each stage is part of the interface, not an implementation courtesy. The surface exposes its objects with stable identity, its capabilities with their risk and whether they verify, its state as something queryable, its reference space (how spoken and written names resolve to things), its events (including changes the human made directly), its permissions (what must be held for confirmation), and its receipts — the record, as data, of what was attempted and what landed. The Interactive Intelligence Benchmark weights verification heaviest among the action tracks for exactly this reason: issuing an action and knowing the world changed are different competences, and only the second closes the loop.

04What an OPI is

An Orchestration Programming Interface is a programmable interface through which intelligence creates, modifies, governs and observes orchestration. Its verb set is not invented — it is the AI Orch lifecycle made callable: create, addParticipant, delegate, parallelize, sequence, branch, requireApproval, retry, escalate, pause, resume, fork, observe, reconcile, terminate. An Octra does not need to know the implementation beneath those operations; it generates orchestration policy, the OPI turns policy into programmable operations, and the resulting live object is the AI Orch. Three roles, cleanly cut: the Octra predicts orchestration; the OPI expresses it; the AI Orch executes it. Governance is not an afterthought at this plane — every operation passes the same capability, budget and policy gates as live tool use, and approval is a first-class orchestration state rather than an interruption.

05What PAP is — and what it is not

The Parallel Agent Protocol is deliberately not a third member of the interface pair. IPI and OPI are programming interfaces; PAP is a communication protocol — the same relationship HTTP bears to the applications above it, except its primitive is not a document or a procedure but an agent operation. A PAP request targets an invokable agent resource by URI — pap://, or paps:// for operations involving execution, secrets, payments or identity — names one of three ops (describe, invoke, stream), and returns structured results carrying execution metadata: timing, confidence, status, typed errors. And “parallel” names parallel intelligences — autonomous actors existing alongside one another — never concurrency: PAP enables parallel agents; OPI determines parallel execution.

OPI governs the work. PAP moves the work. IPI performs the work.

The three compose without touching: an orchestration decides that agent D should find a report; the delegation travels to D over PAP; and D, arriving at a browser, works it through the IPI that browser exposes. Each plane can be replaced, versioned or measured without renegotiating the other two.

06The full stack

Read top to bottom, this is the published hierarchy — models reason, agents act, Orchs coordinate — with the infrastructure that makes those verbs programmable now drawn in. Nothing above replaces anything below; each layer gives the one beneath it an addressable form.

07Above the API

The claim in this note’s title is an anti-claim: intelligence does not replace the API. A tool an agent uses is, very often, an API with an IPI wrapped around it; a service an orchestration consumes is an API with an OPI above it and PAP carrying the invocation. The resolution ladder runs Octra → OPI → AI Orch → agent → IPI → tool → API → service — every rung still there, every rung still necessary. What changes is where programming happens: not against endpoints, but against environments and coordination. That is what “AI‑native” means at the interface layer, and it is a far stronger statement than “AI replaces APIs” — because it survives contact with how systems are actually built.

08The sphere all three serve

The published IPS line — STA decides what the surface does; STO decides which intelligence does it; an IPS is the sphere both act inside — gains its architectural reading here without changing a word. An Interactive Perspective Sphere is the experience space; the IPI is the programmable interaction layer of that space; the OPI is the programmable orchestration layer behind it; and PAP connects the intelligences operating through it. A sphere is not merely an interface a person steps into — it is an environment whose affordances are exposed, whose intelligence is coordinated, and whose distributed participants communicate, each through its own plane.

09What runs today

Stated with the same discipline as the rest of this series. The first-generation IPI runs in LabsAI Studio: a live capability catalog scoped to object lifetime, spoken reference resolution with an explicit ambiguity band, DOM‑verified action outcomes returned as receipts, confirmation holds on destructive actions, and a queryable surface state. The first-generation OPI runs there too: all fifteen lifecycle verbs callable over the Studio’s governed coordination substrate, orchestrations addressable by id with receipts on every transition, approval and pause as real states, persistence across sessions, forks running independently. pap/1.0 is published as a specification with its reference implementation live inside the Studio — the Studio speaks its own protocol for delegated work, within a single node today. The agent network those URIs are written for is the road ahead; the internals of the composed system remain unpublished, as a standing policy stated once.

10The taxonomy, extended

Each Labs concept answers one question, and the interface layer completes the set: