The Ask Protocol

1 Protocol Fundamentals

Every Abject has a built-in ask handler. Send it a natural-language question, and it answers using its own manifest and source code as context, via an LLM. If no LLM is available, it falls back to a plain manifest description.

The protocol is a single primitive: one method, one question, one answer.

ask(question: string) -> string

Because every object in the system implements ask, any object can query any other object about its behavior. No shared documentation, no schema registry, no out-of-band coordination. The knowledge lives where the behavior lives: in the object itself.

2 Message Format and Flow

Message Envelope

All communication in the system uses a uniform message envelope. The Ask Protocol is not special; it uses the same AbjectMessage structure as every other interaction.

AbjectMessage {
  header: {
    messageId:      string    // unique identifier
    correlationId:  string?   // links replies to requests
    sequenceNumber: number    // per-sender ordering
    timestamp:      number    // milliseconds since epoch
    type:           "request" | "reply" | "event" | "error"
  }
  routing: {
    from:   AbjectId         // sender's runtime identity
    to:     AbjectId         // recipient's runtime identity
    method: string?          // handler name ("ask")
  }
  payload: T                 // method-specific data
  protocol: {
    version:       string    // protocol version
    negotiationId: string?   // agreement context
  }
}

For the Ask Protocol, the request payload is { question: string } and the reply payload is a plain string containing the object's answer.

Flow

1. The caller sends an ask request to the target with a natural-language question.
2. The target discovers the LLM service via the Registry and assembles context from its own manifest and source code.
3. The LLM answers the question using that context.
4. The target returns the answer to the caller.
5. If no LLM is available, the target falls back to a plain manifest description.

The target acts as its own authority. It does not defer to an external schema or documentation service. The answer comes from the object that owns the behavior.

3 Self-Describing Objects

Every Abject carries a structured manifest that declares its identity, capabilities, and interface. The Ask Protocol builds on this foundation.

The Manifest

AbjectManifest {
  name:                 string
  description:          string
  version:              string
  interface: {
    id:          InterfaceId
    name:        string
    description: string
    methods: [{
      name:        string
      description: string
      params:      [{ name, type, description }]
      returns:     { type, description }
    }]
    events:  [{ name, description, dataSchema }]
  }
  requiredCapabilities: CapabilityRequest[]
  providedCapabilities: CapabilityId[]
  tags:                 string[]
}

The manifest is a structured declaration: what the object is, what methods it exposes, what events it emits, what capabilities it needs and provides. The function formatManifestAsDescription() converts this structure into natural-language English, which becomes the LLM's system context when answering questions.

Static and Dynamic Context

The Introspect Interface

Every Abject automatically implements the abjects:introspect interface with two methods:

• describe returns the manifest and a formatted English description.
• ask accepts a natural-language question and returns an LLM-powered answer using the manifest and source as context.

These methods are not opt-in. Every object in the system has them. This means any object can query any other object about its behavior, without prior arrangement.

4 Use Cases

The Ask Protocol is a primitive. These are the patterns built on top of it.

5 Comparison with Existing Approaches

Web Protocols

REST, GraphQL, and gRPC are the dominant protocols for service communication on the web. All three require a human in the loop to read documentation, write integration code, and update it when things change.

LLM and Agent Protocols

A new generation of protocols has emerged around LLM integration and agent interoperability. MCP, A2A, and OpenAI's function calling each address a piece of the puzzle. The Ask Protocol occupies a different position: it is not a tool-calling convention or an agent orchestration layer, but a self-description primitive embedded in the objects themselves.

These approaches are complementary, not competing. MCP could transport an ask call. A2A could route it between peers. But neither provides the self-description primitive itself. The Ask Protocol is the content; the others are the envelope.

6 The Internet Was Always Object-Oriented

The internet is computers passing messages. TCP/IP, DNS, BGP: these are protocols between machines that identify themselves, negotiate capabilities, and exchange structured data. The internet is already object-oriented.

The web is an application on top of the internet. HTTP imposed a document metaphor: URLs as resource locators, verbs as CRUD operations. GraphQL imposed a query metaphor. gRPC imposed a procedure metaphor. All three obscure the underlying reality: that the network is made of objects communicating.

The Ask Protocol does not add object-orientation to the internet. It reveals it. It gives networked objects what they have been missing: the ability to describe themselves, teach strangers how to use them, and adapt when communication breaks down.

Combined with peer-to-peer transport (WebRTC with identity-based addressing), objects across machines discover each other, ask what the other does, and compose dynamically.

No central schema registry. No shared proto files. No API documentation site.

The schema is the object, and the object can explain itself.