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

# Execution Integrity

> How Parmana verifies that the action that executed is the action that was authorized

# Execution Integrity

Authorization is not enough.

An organization must also know whether the action that executed was the action that was authorized.

Execution Integrity is Parmana's mechanism for answering that question.

```text theme={null}
Authorization
        ↓
Execution
        ↓
Confirmation
        ↓
Execution Integrity Proof
```

Execution Integrity creates verifiable evidence that execution matched authorization.

***

## The Problem

Most systems verify authorization before execution.

Few systems verify what actually happened after execution.

Typical flow:

```text theme={null}
Request
    ↓
Approval
    ↓
Execution
```

After execution, organizations often cannot prove:

```text theme={null}
Was the approved action executed?

Or

Did something different execute?
```

This creates an accountability gap.

***

## Core Question

Execution Integrity answers:

> Did the executed action match the authorized action?

If yes:

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

If no:

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

***

## Core Principle

Authorization and execution are separate events.

```text theme={null}
Authorization
      ≠
Execution
```

Execution Integrity connects them.

```text theme={null}
Authorization
        ↓
Execution
        ↓
Comparison
        ↓
Proof
```

***

## Authorization Record

Policy evaluation produces an attestation.

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

Example:

```json theme={null}
{
  "executionId": "claim-001",
  "policyId": "claims-approval",
  "decision": {
    "action": "approve"
  }
}
```

The attestation becomes the authorization record.

***

## Execution

Execution occurs outside Parmana.

Examples:

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

External systems perform execution.

```text theme={null}
Attestation
      ↓
External System
      ↓
Execution
```

***

## Confirmation

After execution, the external system confirms what occurred.

```text theme={null}
Executed Action
        ↓
Confirm Execution
```

Example:

```json theme={null}
{
  "type": "approve",
  "executedBy": "claims-system",
  "executedAt": "2026-06-14T09:27:04Z",
  "payload": {
    "action": "approve",
    "claim_amount": 100
  }
}
```

This information is submitted to:

```http theme={null}
POST /confirm-execution
```

***

## Execution Integrity Proof

Parmana compares:

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

and produces an Execution Integrity Proof.

```text theme={null}
Authorization
        ↓
Comparison
        ↓
Integrity Proof
```

***

## Example Proof

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

This proves that the executed action matched the authorized action.

***

## Match Analysis

Execution Integrity evaluates several conditions.

### Action Type

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

Example:

```text theme={null}
approve
=
approve
```

Result:

```json theme={null}
{
  "actionTypeMatch": true
}
```

***

### Payload Consistency

The executed payload must remain consistent with the authorized action.

Example:

```json theme={null}
{
  "action": "approve",
  "claim_amount": 100
}
```

Result:

```json theme={null}
{
  "payloadConsistent": true
}
```

***

### Time Window

Execution should occur within the permitted confirmation window.

Example:

```json theme={null}
{
  "withinTimeWindow": true,
  "timeWindowSeconds": 300
}
```

***

## Match Details

Example:

```json theme={null}
{
  "matchDetails": {
    "actionTypeMatch": true,
    "payloadConsistent": true,
    "withinTimeWindow": true,
    "timeWindowSeconds": 300
  }
}
```

All conditions must pass.

***

## Successful Verification

Example:

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

Meaning:

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

***

## Failed Verification

Example:

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

Meaning:

```text theme={null}
Authorized Action
        ≠
Executed Action
```

Verification succeeded.

Integrity validation failed.

***

## Example: Approved Claim

Authorization:

```json theme={null}
{
  "action": "approve",
  "claim_amount": 100
}
```

Execution:

```json theme={null}
{
  "action": "approve",
  "claim_amount": 100
}
```

Result:

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

***

## Example: Mismatched Execution

Authorization:

```json theme={null}
{
  "action": "approve"
}
```

Execution:

```json theme={null}
{
  "action": "reject"
}
```

Result:

```json theme={null}
{
  "match": false
}
```

Execution differed from authorization.

***

## Banking Example

A customer requests a transfer.

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

The bank verifies facts.

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

Parmana evaluates policy.

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

An attestation is issued.

```text theme={null}
Authorization
```

The bank executes the transfer.

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

The bank confirms execution.

```text theme={null}
Confirm Execution
```

Parmana produces an Execution Integrity Proof.

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

Result:

```text theme={null}
AI Captured Request
Bank Verified Facts
Parmana Authorized Action
Bank Executed Action
Parmana Verified Execution
```

***

## Auditability

Execution Integrity provides evidence that auditors can review.

Auditors can answer:

```text theme={null}
What Was Authorized?
What Was Executed?
Did They Match?
When Was Execution Confirmed?
Who Executed The Action?
```

This creates a complete execution trail.

***

## Relationship To Attestations

Attestations answer:

```text theme={null}
Was The Action Authorized?
```

Execution Integrity answers:

```text theme={null}
Was The Authorized Action Executed?
```

Together they provide end-to-end accountability.

***

## Relationship To Verification

Execution Integrity Proofs are signed artifacts.

They can be independently verified.

```text theme={null}
Authorization
        ↓
Execution Integrity Proof
        ↓
Verification
```

This allows third parties to validate execution evidence.

***

## Complete Flow

```text theme={null}
Task
 ↓
Policy
 ↓
Schema
 ↓
Verified Signals
 ↓
Evaluation
 ↓
Attestation
 ↓
Execution
 ↓
Confirm Execution
 ↓
Execution Integrity Proof
 ↓
Verification
```

Execution Integrity closes the gap between authorization and execution.

***

## Core Insight

Authorization alone is insufficient.

Organizations must also know whether execution matched authorization.

```text theme={null}
Authorized Action
        ↓
Executed Action
        ↓
Execution Integrity Proof
```

This is how Parmana creates verifiable evidence that autonomous systems not only received authorization but also executed the authorized action.