Deployment Scales

Monolith → containers → Dapr → agent system. Same components, different deployment.

Reading order: Bridging External Systems -> You are here (last concepts page).

Scale 1: Monolith

One kernel, all in-process. @requires + direct method calls. Zero serialization.

┌─────────────────────────────────────┐
│              Kernel                 │
│                                     │
│  ConfigProvider  LoggingProvider     │
│  SplunkApp       SystemApp          │
│  RESTTransport   MCPTransport       │
│  APIGateway                         │
│                                     │
│  @requires + direct calls = zero    │
│  serialization, type-safe           │
└─────────────────────────────────────┘

Scale 2: Containers

Each container runs a kernel. RemoteTransport (JSON-RPC + mDNS) for cross-process.

┌──────────────────┐    ┌──────────────────┐
│ Container A      │    │ Container B      │
│ Kernel           │    │ Kernel           │
│  SplunkApp       │    │  SystemApp       │
│  RemoteTransport │◄──►│  RemoteTransport │
│  (JSON-RPC)      │    │  (JSON-RPC)      │
└──────────────────┘    └──────────────────┘
         │ mDNS discovery │
         └────────────────┘

Consumer just @requires the contract – kernel finds it via discovery, injects a proxy. Code is identical whether local or remote. Contracts hide location.

Scale 3: Dapr

Polyglot. DaprTransport replaces RemoteTransport. Python + Node.js + Go.

┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│ Python App   │  │ Node.js App  │  │ Go App       │
│ Kernel       │  │ (native)     │  │ (native)     │
│ DaprTransport│  │              │  │              │
└──────┬───────┘  └──────┬───────┘  └──────┬───────┘
       │                 │                 │
┌──────▼───────┐  ┌──────▼───────┐  ┌──────▼───────┐
│ Dapr Sidecar │◄►│ Dapr Sidecar │◄►│ Dapr Sidecar │
└──────────────┘  └──────────────┘  └──────────────┘

Scale 4: Agent System

Kernel = agent’s tool provider. MCPTransport exposes runnables as MCP tools.

┌─────────────────────────────────────┐
│              AI Agent               │
│  (Claude, GPT, local LLM)          │
│                                     │
│  MCP client ──► MCPTransport        │
│                    │                │
│              ┌─────▼─────┐          │
│              │  Kernel    │          │
│              │  SplunkApp │          │
│              │  GitLabApp │          │
│              │  SystemApp │          │
│              └───────────┘          │
│                                     │
│  Agent calls tools via MCP.         │
│  Each tool = a runnable.            │
│  Kernel manages auth, lifecycle,    │
│  credentials — agent just calls.    │
└─────────────────────────────────────┘

Cross-Process Communication

Distribution transparency comes from contracts, not the bus. A consumer uses @requires(search=ISearch) and calls self.rt.search.query(params) – the same code whether the provider is in-process or remote. For remote providers, the registry injects a proxy that handles serialization and network transport. The component code on both sides remains identical – contracts hide location.

The framework for remote proxies is designed but not yet implemented. A remote registry adapter would need to provide proxy objects that implement the contract Protocol and forward method calls over a wire protocol (JSON-RPC, gRPC, etc.).