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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://techdocs.korprotocol.io/architecture/overview.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.