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

# Decision Flow

> How Parmana transforms verified facts into verifiable authority decisions before execution

# Decision Flow

The Parmana decision flow defines how authority is verified before actions occur.

Rather than allowing systems to execute actions directly, Parmana verifies that the required policy conditions have been satisfied before execution.

```text theme={null}
Task
↓
Policy
↓
Schema
↓
Verified Signals
↓
Evaluation
↓
Attestation
↓
Override (optional)
↓
Execution
↓
Execution Integrity Proof
↓
Verification
```

This flow creates a complete authority trail from request to execution.

***

## Overview

Parmana answers one question:

> Did the right policy authorize this action?

If the answer is yes:

```text theme={null}
Execute
```

If the answer is no:

```text theme={null}
Do Not Execute
```

The decision is based on verified facts rather than assumptions, AI outputs, or application-specific logic.

***

# Step 1 — Task

A customer or system initiates a business action.

Examples:

```text theme={null}
Transfer Funds
Approve Claim
Issue Refund
Create Vendor
Close Account
```

Tasks represent business intent.

```text theme={null}
Customer
     ↓
Task
```

***

# Step 2 — Policy

The organization maps the task to a policy.

Example:

```text theme={null}
Transfer Funds
        ↓
High Value Transfer Policy
```

Or:

```text theme={null}
Approve Claim
        ↓
Claims Approval Policy
```

Policies define authority requirements.

***

# Step 3 — Schema

Every policy defines a schema.

The schema specifies which signals are required before evaluation.

Example:

```json theme={null}
{
  "requiredSignals": {
    "authenticated_user": "boolean",
    "available_balance": "number",
    "destination_verified": "boolean",
    "transfer_amount": "number"
  }
}
```

The schema determines the evidence required for evaluation.

***

# Step 4 — Verified Signals

External systems verify the required facts.

Examples:

```text theme={null}
Banking Platform
Identity Provider
Fraud System
Claims System
CRM
ERP
```

Verified signals may look like:

```json theme={null}
{
  "authenticated_user": true,
  "available_balance": 5000,
  "destination_verified": true,
  "transfer_amount": 1000
}
```

Important:

```text theme={null}
Parmana does not verify signals.
```

External systems verify signals.

Parmana evaluates them.

***

# Step 5 — Evaluation

Verified signals are submitted to Parmana.

```text theme={null}
Verified Signals
        ↓
Policy Evaluation
```

Parmana evaluates policy requirements.

Possible outcomes:

```text theme={null}
Approve
Reject
Require Override
```

Example:

```json theme={null}
{
  "action": "approve",
  "requires_override": false,
  "reason": "policy_requirements_satisfied"
}
```

***

# Step 6 — Attestation

Evaluation produces a signed attestation.

```text theme={null}
Decision
    ↓
Attestation
```

The attestation records:

* Policy
* Policy version
* Decision
* Evidence fingerprint
* Provenance
* Signature

Example:

```json theme={null}
{
  "executionId": "claim-001",
  "policyId": "claims-approval",
  "signature": "..."
}
```

The attestation becomes the authorization record.

***

# Step 7 — Override (Optional)

Some policies require human escalation.

Example:

```json theme={null}
{
  "action": "reject",
  "requires_override": true
}
```

The workflow becomes:

```text theme={null}
Policy Decision
        ↓
Pending Override
        ↓
Human Review
```

An authorized human may:

```text theme={null}
Approve
Reject
```

Overrides create a separate authority record.

The original policy decision remains unchanged.

***

# Step 8 — Execution

Execution occurs outside Parmana.

Examples:

```text theme={null}
Bank Transfer
Claim Approval
Refund
Vendor Creation
Account Closure
```

Parmana verifies authority.

External systems perform execution.

```text theme={null}
Decision
      ↓
Execution
```

***

# Step 9 — Execution Integrity Proof

After execution, the system confirms what actually happened.

```text theme={null}
Authorized Action
        ↓
Executed Action
        ↓
Comparison
```

Parmana generates an Execution Integrity Proof.

Example:

```json theme={null}
{
  "match": true,
  "verified": true
}
```

This proves that the executed action matches the authorized action.

***

# Step 10 — Verification

Evidence can be independently verified.

```text theme={null}
Attestation
      ↓
Verification
```

Verification checks:

```text theme={null}
Signature
Runtime
Schema
Provenance
Release
Trust Chain
```

Example:

```json theme={null}
{
  "valid": true,
  "signatureVerified": true,
  "runtimeVerified": true
}
```

***

# Complete Flow

```text theme={null}
Customer Chooses Task
            ↓
Task → Policy Mapping
            ↓
Policy
            ↓
Schema
            ↓
Required Signals
            ↓
Verified Signals
            ↓
Parmana Evaluation
            ↓
Decision
            ↓
Attestation
            ↓
Override (optional)
            ↓
Execution
            ↓
Execution Integrity Proof
            ↓
Verification
```

***

# Banking Example

A customer asks an AI assistant to transfer money.

```text theme={null}
Customer
      ↓
AI Assistant
```

The AI captures the request.

```text theme={null}
Transfer ₹10,000
```

The bank verifies facts.

```text theme={null}
Customer Authenticated
Account Verified
Balance Available
Destination Verified
```

Verified signals are sent to Parmana.

```text theme={null}
Verified Signals
        ↓
Parmana
```

Parmana evaluates policy.

```text theme={null}
Approve
```

The bank executes the transfer.

```text theme={null}
Transfer Executed
```

The bank confirms execution.

```text theme={null}
Execution Integrity Proof
```

Result:

```text theme={null}
AI Captured Request
Bank Verified Facts
Parmana Enforced Policy
Bank Executed Decision
```

***

# Authority Trail

The decision flow creates a complete authority trail.

```text theme={null}
Verified Facts
        ↓
Policy Evaluation
        ↓
Decision
        ↓
Override
        ↓
Execution
        ↓
Integrity Proof
        ↓
Verification
```

This allows organizations to demonstrate:

* Which policy applied
* Which facts were verified
* Which decision was made
* Whether an override occurred
* What action was executed
* Whether execution matched authorization

***

# Core Insight

Parmana separates authority verification from execution.

```text theme={null}
AI Captures Request
        ↓
Systems Verify Facts
        ↓
Parmana Verifies Authority
        ↓
Systems Execute Action
```

This ensures that autonomous systems follow human rules before they act.