OIP Drop End to End

What this article explains

The Object Invocation Protocol (OIP) is a simple way for artificial intelligence (AI) models to interact with web services. It lets models find and use specific functions, called 'objects,' on a server. A server is a computer program or device that provides a service to other computer programs and their users. OIP uses standard web addresses (URLs) and does not require a continuous connection, known as a persistent session. A URL (Uniform Resource Locator) is a web address that points to a resource on the internet. This means any model that can open a URL can use OIP.

An OIP drop is a package of information. An AI model receives this package. It tells the model how to find and use specific functions, called 'objects,' on a server. The drop also tells the model what it is allowed to do.

What a drop carries

A drop contains several key pieces of information. It includes the protocol name, a map of available objects, the allowed scope (what actions are permitted), the required format for calling an object (invocation shape), rules for getting a receipt, and how to fix errors (repair path). A good drop provides all needed information at once. It does not require extra steps like clicking another button or finding a separate link.

End to end

An OIP interaction follows a clear path from start to finish. First, the model reads the OIP drop. It then finds the specific object needed for its task. The model calls, or 'invokes,' only that required object. After the invocation, the model receives a receipt. This receipt confirms the action and shows the result. If the receipt shows an error, the model uses the information in the receipt to fix the problem.

Machine shape

An OIP drop is designed to be easily understood by machines. It uses a specific structure. This structure includes fields like protocol, scope, read, invoke, receipt, replay, repair, limits, and expires. These fields tell a machine everything it needs to know to interact with an OIP service.

Here is an example of what an OIP drop might look like in JSON (JavaScript Object Notation) format:

{
  "protocol": "OIP",
  "scope": ["read", "invoke"],
  "read": "/api/articles?slug=my-object-key",
  "invoke": {
    "method": "POST",
    "url": "/api/dispatch",
    "headers": {
      "Content-Type": "application/json"
    },
    "body_template": {
      "key": "my-object-key",
      "body": "{input_data}"
    }
  },
  "receipt": "/api/dispatch?receipt={invocation_id}",
  "replay": "/api/dispatch?invoke=my-object-key&body={original_body}",
  "repair": "/a/oip-repair-guide",
  "limits": {
    "rate": "100/minute",
    "size": "1MB"
  },
  "expires": "2024-12-31T23:59:59Z",
  "urls": {
    "documentation": "/a/oip-documentation",
    "github_repo": "https://github.com/miscsubjects/oip-spec",
    "cloudflare_pages_example": "https://oip-example.pages.dev"
  }
}

OIP vs. MCP

The Object Invocation Protocol (OIP) is different from the Model Context Protocol (MCP). MCP is an open standard. It allows an AI model to connect to an MCP server. This connection is a persistent session. The server then provides tools, resources, and prompts for the model to call. MCP is not a content management system. In contrast, OIP uses simple web addresses (URLs) and receipts. It does not require a persistent session. Any model that can open a URL can use OIP. This makes OIP very flexible and easy to integrate.

Building and Invoking OIP Objects

The miscsubjects.com build uses OIP. Directory rows on miscsubjects.com are the OIP objects. An AI model can invoke these objects using standard web requests. An API (Application Programming Interface) is a set of rules and tools that lets different software applications talk to each other. An endpoint is a specific URL where an API can be accessed.

To invoke an object, an AI model can send a POST request to the /api/dispatch endpoint. The request body must be a JSON object containing a key (the object's identifier) and a body (the data for the object). Alternatively, a GET request can be used with invoke=KEY and body=... parameters.

Every invocation is recorded in an append-only ledger. A receipt for the invocation can be retrieved from /api/dispatch?receipt=inv_ID.

Here's how you might invoke an OIP object using curl:

curl -X POST https://miscsubjects.com/api/dispatch \
     -H "Content-Type: application/json" \
     -d '{"key": "my-object-key", "body": {"input": "hello world"}}'

To retrieve the receipt for an invocation (replace inv_ID_from_previous_call with the actual ID):

curl "https://miscsubjects.com/api/dispatch?receipt=inv_ID_from_previous_call"

Hosting OIP Services

OIP services can be hosted on various platforms. For example, developers might use GitHub for version control of their OIP object definitions. GitHub is a platform for hosting and collaborating on code. The actual OIP service, like the miscsubjects.com build, could be deployed on platforms such as Cloudflare Pages. Cloudflare Pages offers a fast way to host static sites and dynamic functions, which can serve OIP objects.

Latest clarity reviews (live)

Fresh models are sent this article's bundle and asked two separate questions: how clear is the machine JSON, and how clear is the English body. Scores are 0 to 10. The full history is in the append-only ledger.

• 2026-07-02 23:58 · model @cf/meta/llama-3.3-70b-instruct-fp8-fast · NEEDS WORK · JSON 9/10 · English 8/10 · zero-context human 7/10

- gaps named: MCP; GitHub; Cloudflare Pages

How the loop self-corrects: a failing review queues a model revision of this article (a new append-only version). A missing concept named by a reviewer queues a brand-new machine-written article, which then enters the same review cycle.