Modular Runtime Specification¶

This section turns the Modular Runtime Architecture into an implementation-oriented specification that another team can use to build a protocol module in Rust, Go, or Python.

The intent is not to freeze every future protobuf field today. The intent is to define the minimum contract surface clearly enough that:

• the existing Rust MCP module can be understood as the reference implementation
• a Rust A2A module can be implemented without re-designing the trust model
• a Go LLM proxy module can be implemented without guessing where policy lives
• a REST or gRPC module can be implemented without inventing a different lifecycle or error model

Reading Order¶

1. Core SPI
2. Module Descriptor
3. Module Lifecycle
4. Error Model
5. Conformance
6. the protocol profile that matches the module being implemented
7. MCP Module Profile
8. A2A Module Profile
9. LLM Module Profile
10. REST/gRPC Module Profile

Contract Status¶

This spec set is normative at the architecture level:

• the boundaries are intended
• the ownership rules are intended
• the lifecycle and required fields are intended

It is illustrative at the wire-schema level:

• example JSON and proto-like structures define the required information model
• final generated bindings can still evolve as long as they preserve those semantics

Implemented Precedent¶

The first implemented precedent is the Rust MCP Runtime.

That precedent proves:

• a protocol runtime can move out of Python
• a module can own direct public ingress
• the core can remain authoritative for auth, token scoping, and RBAC
• plugin parity and rollback can still be preserved

It does not mean that every future module must copy the exact current Rust MCP seam. The target-state contracts in this section are slightly more generic than the current implementation.

Status by Protocol Family¶