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

# POST /execute (Legacy)

> Legacy execution endpoint retained for compatibility

## Status

<Warning>
  `/execute` is a legacy endpoint.

  New integrations should use:

  1. `GET Policy Schema`
  2. `POST /evaluate`
  3. `POST /override` (when required)
  4. `POST /confirm-execution`
</Warning>

***

## Why The Workflow Changed

Parmana's architecture evolved to separate:

* Policy evaluation
* Human override
* Execution confirmation

This provides stronger authority verification and better auditability.

Instead of a single execution step:

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

Parmana now uses:

```text theme={null}
Verified Signals
        ↓
Evaluate
        ↓
Override (optional)
        ↓
Execution
        ↓
Confirm Execution
```

***

## Recommended Workflow

### Step 1

Retrieve the policy schema.

```http theme={null}
GET /policies/{policyId}/versions/{version}/schema
```

***

### Step 2

Collect and verify required signals.

```json theme={null}
{
  "insurance_active": true,
  "risk_score": 10,
  "claim_amount": 100
}
```

***

### Step 3

Evaluate policy.

```http theme={null}
POST /evaluate
```

Response:

```json theme={null}
{
  "status": "approved",
  "attestation": {
    "...": "..."
  }
}
```

***

### Step 4

If required, perform override.

```http theme={null}
POST /override
```

***

### Step 5

Execute the action.

```text theme={null}
Payment
Claim Approval
Account Change
Transfer
```

Execution occurs in the external system.

***

### Step 6

Confirm execution.

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

Response:

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

***

## Why Separation Matters

### Authorization

```text theme={null}
Was the action authorized?
```

Answered by:

```http theme={null}
POST /evaluate
```

***

### Human Authority

```text theme={null}
Did an authorized human approve an exception?
```

Answered by:

```http theme={null}
POST /override
```

***

### Execution Integrity

```text theme={null}
Did the executed action match the authorized action?
```

Answered by:

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

***

## Architecture

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

***

## Migration Guidance

If you currently use `/execute`:

### Before

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

### After

```text theme={null}
Request
    ↓
Evaluate
    ↓
Override (optional)
    ↓
Execute
    ↓
Confirm Execution
```

This produces:

* Signed attestation
* Override evidence
* Execution Integrity Proof
* Independent verification capability

***

## Related APIs

### Policy Schema

```http theme={null}
GET /policies/{policyId}/versions/{version}/schema
```

### Evaluate

```http theme={null}
POST /evaluate
```

### Override

```http theme={null}
POST /override
```

### Confirm Execution

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

### Verify

```http theme={null}
POST /verify
```

***

## Parmana Architecture

Parmana separates:

```text theme={null}
Authority Verification
```

from

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

AI can request actions.

Policies define authority.

Humans retain authority.

Parmana verifies authority before execution and produces verifiable evidence after execution.