The Ask Protocol

1 Protocol Fundamentals

Every Abject has a built-in ask handler. Send it a natural-language question, and it answers from its own self-knowledge, 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 and assembles context from its own self-knowledge.
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, payload }]
  }
  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.

Why Objects Can Answer

ask is not a description field. It is a live handler: code that runs when the object is questioned. That is what makes it more than static self-documentation, and it is why an outside LLM reading a fixed blob cannot do the same job.

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 object's self-knowledge 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.

In TCP, DNS, MCP, and A2A, capability negotiation serves a higher layer that carries the real payload. The Ask Protocol has no higher layer to serve. In a peer mesh there is no top: the negotiation is the work, objects teaching each other, generating proxies, and recovering from misunderstanding. The payload is mutual understanding itself.

The table below is for orientation, not parity. Ask sits at a different layer than these, so read it as "where each one lives," not a feature scorecard.

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. Its value is also a whole-system property. It pays off when every participant is an object that can be asked and ask back, not when bolted onto a single server. That bidirectional, system-wide self-knowledge is what a freeform description field cannot give you.

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.

Ask does not replace TCP or DNS. It moves no bytes. It restores their peer, self-identifying nature at the layer of meaning: not "how do I reach you," but "what are you, and why would I call you."

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.