> For the complete documentation index, see [llms.txt](https://techdocs.korprotocol.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://techdocs.korprotocol.io/architecture/overview.md).

# Overview

KOR Protocol is an onchain clearinghouse for creative assets. The architecture is organized into three engines that coordinate across the lifecycle of a creative work.

***

## Three Engines

```
                ┌───────────────────────────────────┐
                │                                   │
                ▼                                   │
        VERIFY ───► ROUTE ───► SETTLE               │
    (what is real) (where it moves) (value clears)  │
                │                                   ▲
                │                                   │
                └───────── outcome data ────────────┘
                           reputation updates
```

**Verify** — establishes origin, ownership, and clearance state for a registered asset.

**Route** — moves a verified asset toward demand-side parties through specialized agents. *(In development)*

**Settle** — clears value across participants and writes commercial state back to the asset.

Each engine composes against external standards rather than reinventing infrastructure:

| Engine | Standards                                                                        |
| ------ | -------------------------------------------------------------------------------- |
| Verify | ERC-721 for asset registration, EAS-style attestation graph for commercial state |
| Route  | ERC-8004 for agent identity, A2A for messaging *(coming)*                        |
| Settle | ERC-6551 for token-bound accounts, stablecoin settlement in USDC                 |

***

## Module Organization

The protocol SDK exposes six modules, mapped to the engines:

### Verify Engine Modules

| Module           | Function                                                  |
| ---------------- | --------------------------------------------------------- |
| **NFT Module**   | Creates and manages ERC-721 collections                   |
| **IP Module**    | Registers NFTs as IP Assets, creates token-bound accounts |
| **Asset Module** | Off-chain metadata and decentralized storage              |

### Settle Engine Modules

| Module             | Function                            |
| ------------------ | ----------------------------------- |
| **License Module** | Attaches license terms to IP Assets |
| **Royalty Module** | Handles splits and distributions    |
| **Dispute Module** | Resolves ownership disputes         |

Four modules—IP, License, Royalty, and Dispute—are coordinated by the Orchestrator Architecture. This approach streamlines the system, reducing complexity and improving code organization.

***

## Component Diagram

```
┌─────────────────────────────────────────────────────────────────┐
│                        YOUR APPLICATION                         │
└─────────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────────┐
│                         KOR SDK                                 │
│            TypeScript. Handles API calls + tx submission.       │
└─────────────────────────────────────────────────────────────────┘
                               │
                    ┌──────────┴──────────┐
                    ▼                     ▼
┌───────────────────────────┐  ┌──────────────────────────────────┐
│      KOR BACKEND          │  │         USER WALLET              │
│  Validates, encodes,      │  │  MetaMask, Coinbase, etc.        │
│  signs tx data            │  │  Signs + pays gas.               │
└───────────────────────────┘  └──────────────────────────────────┘
                    │                     │
                    └──────────┬──────────┘
                               ▼
┌─────────────────────────────────────────────────────────────────┐
│                      BASE NETWORK                               │
│                                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    VERIFY ENGINE                         │   │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐      │   │
│  │  │ NFT Module  │  │  IP Module  │  │Asset Module │      │   │
│  │  └─────────────┘  └─────────────┘  └─────────────┘      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              ROUTE ENGINE (In Development)               │   │
│  │         Agent Registry │ Match Engine │ Curation         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    SETTLE ENGINE                         │   │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐      │   │
│  │  │License Module│ │Royalty Module│ │Dispute Module│     │   │
│  │  └─────────────┘  └─────────────┘  └─────────────┘      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                  TOKEN-BOUND ACCOUNTS                    │   │
│  │                     (ERC-6551 Registry)                  │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘
```

***

## Data Flow

### The Loop

![The Loop - KOR Protocol Flow](/files/Ikk8urmwAt3JoyvXDOL8)

1. **Registration** — A creator registers an asset. Creates a canonical on-chain identifier, an attestation graph seeded with the initial ownership claim, and a clearance state derived from the graph.
2. **Routing** — Once an asset is registered and clear-to-move, Route agents ingest signal about the asset, query the attestation graph, and route toward partners. *(In development)*
3. **Settlement** — A closed match clears through the Settle layer. Splits are programmatic, denominated in stablecoin, executed atomically.
4. **Feedback** — Each settlement writes back to the protocol. The asset accumulates royalty history with timestamps and counterparties.

### Transaction Pattern

Every SDK operation follows the same two-step pattern:

**Step 1: Backend signature** Your app calls the SDK → SDK hits backend → Backend validates API key, encodes transaction, signs it → Returns signature + encoded data

**Step 2: User submission** SDK routes payload through user's wallet → User confirms → Transaction executes on Base

This pattern keeps users in control of their assets while allowing server-side validation.

***

## Core Primitives

### IP Assets

Each registered asset has:

* A canonical on-chain identifier (ERC-721 token)
* An off-chain content pointer (IPFS or Arweave hash)
* Signed metadata describing format, creation context, and AI-provenance status

The token is the index into protocol state. Commercial state lives in the attestation graph and is queried separately by downstream contracts.

### Token-Bound Accounts (ERC-6551)

Every IP Asset gets its own smart contract wallet controlled by the IP itself:

* Receives royalty payments
* Holds licensing revenue
* Can own other assets
* Controlled by NFT owner

### Attestation Graph

The attestation graph holds signed claims about an asset:

* Sample and derivative clearance claims
* Authorship and co-creation claims
* Commercial-state claims (licenses, deals, splits)

The graph is the data structure that the rest of the protocol queries when it needs to know anything about an asset.

### Clearance State

Clearance state is derived from the attestation graph. An asset is "clear-to-move" for a given action when the graph satisfies the required conditions. Different actions require different conditions.

***

## What's Coming

### Route Engine

Specialized agents with on-chain identity (ERC-8004):

* A\&R agents for talent discovery
* Sync-licensing agents for brand matching
* Partner-matching agents for distribution

### Agent Payments

x402 for HTTP-native stablecoin payments. Assets expose payment endpoints that agents can transact with directly.

### Cross-Chain Settlement

ERC-7683 intents for chain-abstracted value transfer.

***

## Next

* [NFT Module](/architecture/modules/nft-module.md)
* [IP Module](/architecture/modules/ip-module.md)
* [License Module](/architecture/modules/license-module.md)
* [Royalty Module](/architecture/modules/royalty-module.md)