Runtime

TCP/AP is often mistaken for a rule engine because of its deterministic logic. It is not a scheduler, a rule engine, or a traditional workflow. It is a governed decision execution environment: every outcome is verified before the next action is permitted.

The runtime consists of five explicit components with distinct, non-overlapping jobs and separated concerns.

Objectives + Prompts + Agentic Protocols + Switchboard + Operator

The Operator and the Switchboard are only half the story. The real innovation is that decisions are no longer hidden inside code and complex if / else-if branching logic. Decisions are explicit, declarative objects you can inventory.

The 1950s Telephone Operator

Before automated telephone networks, calls were connected by hand. A caller picked up the phone and reached a human operator. The operator did not participate in the conversation. The operator did not decide what was said. The operator simply connected the line to the correct destination, and only to destinations the network permitted.

Objectives perform work. The Kernel verifies the result. The Switchboard defines where it goes next. The Operator connects the line.

No component in the runtime holds hidden authority. The shape of an agent is the routing protocol, not the code.

Explicit Decisions

Traditional agent systems scatter decision logic across prompts, workflow code, conditional branches, routers, and tool calls. A reader looking at the flow (Objective, then Kernel, then Switchboard) is left asking: where is the decision?

In TCP/AP, every decision is an explicit object. Each Objective has a corresponding Prompt and Agentic Protocol, sitting side by side in the codebase:

agent/
├── objectives/
│   └── qualify_candidate.py
├── prompts/
│   └── qualify_candidate.md
├── protocols/
│   └── qualify_candidate.json
├── switchboard.json
└── operator.py

Together, these three form a single governed decision:

Objective + Prompt + Agentic Protocol = Decision

Nothing is hidden: every Objective is explicit, every decision is governed, and every route is declared. The whole agent is inventoryable, not buried in code.

The result is a deterministic execution environment built on top of probabilistic systems.

The Components

Objective

A worker. Receives input, performs a task, returns an Artifact. Never decides what happens next.

objective.py

# LLM, function, API: treated identically
def parse_cv(ctx):
    artifact = llm.extract(ctx["input"])
    return artifact  # → Kernel

Kernel

Evaluates the Artifact against the Agentic Protocol. Returns conformance + label. Same input, always same output.

kernel · response

{
  "conformant": true,
  "label":      "QUALIFIED"
}

Switchboard

The routing table. Every possible outcome maps to the next step. Workflow as data, not code.

switchboard.json

{
  "parse_cv|CONFORMANT|QUALIFIED":     "interview",
  "parse_cv|CONFORMANT|NOT_QUALIFIED": "reject",
  "parse_cv|INTERPRETATION_DRIFT|":    "human_review"
}

Operator

The Switchboard Walker. Runs each Objective, looks up the edge on the board, and hands execution to the next one. It holds the walk, never the policy. It decides nothing.

operator.py

# connects the line, decides nothing
node = "intake"
while node not in TERMINALS:
    result = objectives[node](ctx)   # → {status, label}
    key    = f'{node}|{result["status"]}|{result["label"]}'
    node   = switchboard.get(key, "human_review")

For the full Kernel wire contract (Agentic Protocol, Artifact, and all response cases), see How It Works: Protocol.

How It Works: Protocol Runtime Governance Substrate Engineering