> ## Documentation Index
> Fetch the complete documentation index at: https://docs.manthan.systems/llms.txt
> Use this file to discover all available pages before exploring further.

# Runtime Architecture

> How the Runtime orchestrates execution without embedding business logic

The Runtime's job is orchestration only. It does not implement business rules itself — those live in application services and the `policy` package. This separation is what keeps the trust model stable even as business logic evolves.

## Orchestration chain

```
ExecutionTrustApplication
        |
        v
BusinessTransactionService
        |
        v
Runtime
        |
        v
RuntimeOrchestrator
        |
        v
RuntimePipeline
        |
        v
ExecutionComponent
        |
        v
VerificationComponent
        |
        v
ReceiptComponent
        |
        v
ExecutionTrustPipeline
        |
        v
ExecutionTrustRecordBuilder
        |
        v
Execution Trust Record
```

## What each layer is responsible for

* **`ExecutionTrustApplication`** — the composition root; wires together services, repositories, and the pipeline for a running instance.
* **`BusinessTransactionService`** — accepts and validates incoming Business Transactions before they enter the pipeline.
* **`Runtime` / `RuntimeOrchestrator`** — coordinate the ordered execution of pipeline stages against an immutable transaction.
* **`RuntimePipeline`** — the ordered sequence of Runtime Components a transaction passes through.
* **`ExecutionComponent` → `VerificationComponent` → `ReceiptComponent`** — each stage consumes an immutable transaction/record and returns a new immutable one; no stage mutates its input.
* **`ExecutionTrustPipeline` / `ExecutionTrustRecordBuilder`** — assemble the final, immutable `ExecutionTrustRecord` from everything the pipeline produced.

This mirrors the domain-level distinction in the [Glossary](/docs/reference/glossary): a **Runtime Component** is "a deterministic execution stage participating in the Runtime Pipeline. Each component accepts an immutable transaction and returns a new immutable transaction."

## Runtime vs. trust

An important nuance from the platform's own terminology: **the Runtime produces execution records — it does not itself establish trust.** Trust is established by Verification acting independently on the evidence the Runtime produced. This is why Verification is implemented as a separate package ([`verification`](/docs/packages/verification)) rather than a step the Runtime performs on itself.

## Related

<CardGroup cols={2}>
  <Card title="Execution Lifecycle" href="/docs/runtime/execution-lifecycle">The end-to-end stage sequence a transaction moves through.</Card>
  <Card title="Package Architecture" href="/docs/architecture/package-architecture">Where each of these components physically lives.</Card>
</CardGroup>