> ## 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.

# Architecture Overview

> Design goals, guiding principles, and the canonical trust model

Parmana is Execution Trust Infrastructure. Traditional systems establish trust by recording who approved an action and when. Parmana extends this by making **execution itself verifiable** — establishing an immutable chain between authority, intent, execution, evidence, and cryptographic proof.

## Core principle

> Execution technology changes. Trust should not.

Parmana separates execution from trust so organizations can verify execution regardless of the underlying execution engine — whether that's enterprise software today, or AI agents, robotics, or distributed systems tomorrow.

## Design goals

* Deterministic execution
* Immutable trust artifacts
* Cryptographic verification
* Replayable execution
* Independent auditability
* Technology-agnostic execution
* Long-term algorithm agility

## Canonical trust model

```
Authority
    |
    v
Intent
    |
    v
Policy
    |
    v
Decision
    |
    v
Business Transaction
    |
    v
Execution
    |
    v
Verification
    |
    v
Receipt
    |
    v
Execution Trust Record
```

Every artifact in this chain is immutable, and every artifact contributes evidence to the whole. See [Concepts Overview](/docs/concepts/overview) for what each artifact means.

## Guiding principles

| Principle                              | What it means in practice                                                                                                                                                            |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Immutable by default                   | No domain object supports an update operation.                                                                                                                                       |
| Deterministic by design                | Same policy + same inputs → same decision, always.                                                                                                                                   |
| Verifiable by evidence                 | Every claim is backed by cryptographic evidence, not trust in the runtime.                                                                                                           |
| Replayable by construction             | Any past decision can be deterministically re-derived.                                                                                                                               |
| Storage agnostic                       | The Runtime doesn't know or care which storage adapter is behind the repository interfaces.                                                                                          |
| Execution agnostic                     | Execution engines are swappable without changing the trust model.                                                                                                                    |
| Cryptographically verifiable           | Hashing and signatures are core, not bolted on.                                                                                                                                      |
| Future-ready through algorithm agility | Cryptographic algorithms are replaceable implementation details, not fixed domain concepts — e.g. a future move to post-quantum signatures wouldn't require an architectural change. |

## Next

<CardGroup cols={2}>
  <Card title="Runtime Architecture" href="/docs/architecture/runtime-architecture">How the Runtime orchestrates execution without embedding business logic.</Card>
  <Card title="Package Architecture" href="/docs/architecture/package-architecture">How responsibilities are split across the eight monorepo packages.</Card>
  <Card title="Security Model" href="/docs/architecture/security-model">Immutability, append-only evidence, and cryptographic guarantees.</Card>
  <Card title="Repository Model" href="/docs/architecture/repository-model">How storage is abstracted behind interfaces.</Card>
</CardGroup>