bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 3쪽 중 2쪽
with diverse backgrounds in AI, blockchain, and high-performance computing.
Here is quick overview to how does it look like infra wise.
<figure><img src="https://2560886960-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fo8bW2LCw3s9Oq1VIQ85p%2Fuploads%2FNvFqFcCT50YTsKR5pzfX%2Fimage.png?alt=media&token=e18455d3-d6a3-41cb-b5eb-b6ab28ae64fc" alt=""><figcaption></figcaption></figure>
The Cluster Protocol stack is organized into four horizontal layers, each independently functional and collectively composable. Every layer feeds into the ones below it, and all activity settles through a single on-chain settlement layer on Base.
**Inference Engine** The topmost layer and the primary service interface. Handles all AI model requests across the platform.
* 500+ open-source models accessible via a single OpenAI-compatible API
* Multi-modal coverage: chat completions, embeddings, image generation, text-to-speech, speech-to-text, and document reranking
* Multi-provider routing with automatic failover — if one provider drops, the gateway reroutes transparently
* Pay-per-token billing with no subscriptions, no minimums, no lock-in
**Tokenized Data Marketplace + AI Services** The middle layer, split into two interconnected components that feed into each other.
Tokenized Data Marketplace:
* Datasets stored on IPFS for decentralized persistence
* Ownership represented as ERC-721 NFTs on Base
* Revenue automatically distributed on every purchase via PaymentRouter smart contract
* Data quality maintained through community reviews, ratings, and access-gated previews
AI Services:
* Fine-tuning pipeline: bring a base model and training data, Cluster handles compute and outputs a live inference endpoint
* Pre-configured templates and multi-step workflows for common patterns (RAG pipelines, classification, reasoning chains)
* Direct feed from the data marketplace — tokenized datasets can be used as fine-tuning inputs without leaving the platform
The data marketplace feeds the AI services layer. A dataset tokenized on Cluster can be used to fine-tune a model on Cluster, and the resulting model is served through the inference engine above — creating a closed-loop value chain within one platform.
**Settlement Layer — Base (Ethereum L2)** The on-chain backbone that handles all payments, ownership, and contract logic.
* Smart contracts deployed and verified on Base mainnet: DatasetNFT, DatasetRegistry, PaymentRouter, ClusterToken
* x402 payment protocol enabling HTTP-native micropayments — AI agents and developers pay per request with no accounts or API keys
* Balance system for traditional deposit-and-spend users
* Python SDK providing unified access to inference, data, and on-chain queries in a single client
**CodeXero — Application Layer** The consumer-facing surface built natively on top of all three infrastructure layers.
* Prompt-to-dApp: natural language input becomes a compiled, deployed, tokenized on-chain application
* Browser-native runtime via WebContainer — no local setup, no CLI, no dependencies
* Every deployment consumes Cluster inference for code generation, Cluster compute for compilation, and Cluster hosting for delivery — all settled at the infrastructure layer
* Outputs: live dApps, autonomous agents, and protocol integrations — all running on Cluster infrastructure underneath
# Inference Engine
<figure><img src="https://2560886960-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fo8bW2LCw3s9Oq1VIQ85p%2Fuploads%2FlwoGHEf9qTIWTKgm9hRX%2Fimage.png?alt=media&token=0037e23f-addb-41f2-a7d5-472eeadeec76" alt=""><figcaption></figcaption></figure>
The inference engine is the core service layer of Cluster Protocol. It provides a unified API gateway that routes requests across 500+ open-source AI models from multiple compute providers, with automatic failover, load balancing, and per-token billing.
# 500+ Models, One API
The inference API follows the unified, general industry standards, chat completions. Any application built for the OpenAI API can switch to Cluster by changing the base URL and API key, no code changes required.
<mark style="color:$success;">`POST /v1/chat/completions`</mark>\ <mark style="color:$success;">`Authorization: Bearer <api_key>`</mark>
<mark style="color:$success;">`{`</mark>\ <mark style="color:$success;">`"model": "meta-llama/llama-3.1-70b-instruct",`</mark>\ <mark style="color:$success;">`"messages": [`</mark>\ <mark style="color:$success;">`{"role": "user", "content": "Explain how tokenized datasets work."}`</mark>\ <mark style="color:$success;">`]`</mark>\ <mark style="color:$success;">`}`</mark>
The model catalog includes families from Meta (Llama), Mistral AI, DeepSeek, Qwen, Google (Gemma), and others, spanning parameter ranges from 7B to 405B. Models are categorized by task type: general chat, code generation, reasoning, instruction following, and domain-specific applications.
Billing is per-token, with separate rates for input and output tokens. There are no subscription tiers or minimum commitments.
# Multi-Modal APIs
Beyond text completions, Cluster serves a full suite of AI modalities through the same gateway:
**Embeddings** (<mark style="color:$warning;">`POST /v1/embeddings`</mark>) Convert text into dense vector representations for semantic search, clustering, and retrieval-augmented generation (RAG). Supports multiple embedding models with configurable dimensions.
**Image Generation** (<mark style="color:$warning;">`POST /v1/images/generations`</mark>) Generate images from text prompts using open-source diffusion models. Returns URLs or base64-encoded images.
**Text-to-Speech** (<mark style="color:$warning;">`POST /v1/audio/speech`</mark>) Convert text to natural-sounding audio across multiple voices and languages.
**Speech-to-Text** (<mark style="color:$warning;">`POST /v1/audio/transcriptions`</mark>) Transcribe audio files into text. Supports multiple audio formats and languages.
**Document Reranking** (<mark style="color:$warning;">`POST /v1/rerank`</mark>) Reorder a set of documents by relevance to a query. Used in RAG pipelines to improve retrieval quality before sending context to the language model.
All modalities are served through the same authentication, billing, and settlement infrastructure. A single API key and a single balance covers everything.
# Provider Routing & Failover
Requests are not served by a single compute backend. The gateway maintains connections to multiple inference providers and routes each request based on availability, latency, and capacity.
If the primary provider for a given model fails or times out, the gateway automatically retries with the next available provider. This happens transparently, the client receives a response without knowing which backend served it.
The routing layer also handles:
* **Load distribution** across providers to avoid concentration on a single backend
* **Latency optimization** by selecting the fastest responding provider for each request
* **Model availability** — if a model is temporarily unavailable on one provider, the gateway routes to an alternative that serves the same model
The developer does not configure any of this. From the client perspective, there is one endpoint, one model name, and one response.
# Tokenized Data Marketplace
<figure><img src="https://2560886960-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fo8bW2LCw3s9Oq1VIQ85p%2Fuploads%2FqFJ9YR5dyCf8QTi5mARz%2Fimage.png?alt=media&token=fa17b2ed-cb49-40a7-b526-259ab406b352" alt=""><figcaption></figcaption></figure>
The data marketplace enables anyone to upload, tokenize, and monetize datasets on-chain. Datasets are stored on IPFS for decentralized persistence and represented as ERC-721 NFTs on Base for verifiable ownership and programmable revenue distribution.
# IPFS Storage & On-Chain Provenance
Every dataset uploaded to Cluster is pinned to IPFS via Pinata. IPFS assigns a content-addressed identifier (CID) based on the hash of the file contents. This means:
* The data is immutable - the same CID always resolves to the same content
* The data is persistent - stored across the IPFS network, not dependent on a single server
* The data is verifiable - anyone can confirm that a CID matches its content
The CID is stored on-chain alongside the dataset's metadata, creating a permanent link between the on-chain ownership record and the off-chain data.
# NFT Ownership & Revenue Distribution
Each dataset can be minted as an ERC-721 NFT through the DatasetNFT contract. The NFT represents verifiable ownership of the dataset and is required for the creator to receive revenue.
When a buyer purchases access to a dataset, the transaction is processed by the PaymentRouter smart contract, which automatically splits the payment:
* **85%** to the dataset creator (the NFT holder)
* **10%** to the protocol treasury
* **5%** to the referrer (if applicable)
This split is enforced at the contract level — it cannot be circumvented or modified per-transaction. Creators earn automatically every time their dataset is purchased.
# Data Quality & Curation
The marketplace supports structured and unstructured datasets across domains including NLP, computer vision, medical, financial, social, and domain-specific training data.
Each dataset entry includes:
* Metadata (name, description, domain, license, tags)
* File manifest (individual files with sizes)
* Preview (first rows visible without login)
* Community reviews and ratings
Access control operates at multiple levels:
* **Public**: Metadata, description, preview
* **Login-gated**: Download link for free datasets
* **Purchase-gated**: Download link for paid datasets
* **Creator**: Full access, edit, publish, mint
# Data-to-Model Pipeline
The marketplace is not an isolated product — it feeds directly into the inference and fine-tuning layers.
A data creator uploads a dataset → tokenizes it as an NFT → the dataset is used to fine-tune a model on Cluster compute → the resulting fine-tuned model is deployed to the inference API → consumers call the model and the data creator earns from both the dataset purchase and the downstream model usage.
This creates a closed-loop value chain where data, compute, and inference are interconnected within a single platform, and value flows back to contributors at every stage.
# AI Services
<figure><img src="https://2560886960-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fo8bW2LCw3s9Oq1VIQ85p%2Fuploads%2FNptuOQo8iCbdqalQIROy%2Fimage.png?alt=media&token=57d6a4fb-357c-48df-af47-491b48fffa18" alt=""><figcaption></figcaption></figure>
Beyond serving pre-trained models, Cluster provides infrastructure for teams that need AI tailored to their domain. The AI Services layer handles fine-tuning workflows, pre-configured templates, and multi-step pipelines, allowing developers to go from raw data to a production-ready, domain-specific model without managing any of the underlying compute or deployment infrastructure themselves.
# Fine-Tuning Pipeline
Developers who need models specialized for their domain can use the fine-tuning pipeline. The process:
1. **Select a base model** from the Cluster model catalog (e.g., Llama 3.1 70B)
2. **Provide training data** — either upload new data or reference an existing tokenized dataset from the marketplace
3. **Configure training parameters** — learning rate, epochs, batch size, evaluation criteria
4. **Submit the job** — Cluster provisions GPU compute and runs the fine-tuning workflow
5. **Deploy the result** — the fine-tuned model is automatically hosted on Cluster's inference layer, accessible via the same <mark style="color:$warning;">`/v1/chat/completions`</mark> endpoint
The output is not a file download - it is a live, production-ready inference endpoint served through the same API gateway as every other model on the platform.
# AI Templates & Workflows
For common use cases, Cluster provides pre-configured templates that combine models, data, and prompts into ready-to-deploy workflows. Templates abstract the underlying infrastructure complexity and allow developers to deploy functional AI applications without configuring each layer individually.
Templates cover patterns including:
* RAG (Retrieval-Augmented Generation) pipelines using Cluster embeddings + datasets
* Classification workflows using fine-tuned models
* Multi-step reasoning chains combining multiple model calls
* Data processing pipelines that clean, transform, and prepare datasets for training
Templates are composable - developers can modify, extend, or combine them to build custom workflows.
# x402 Payment Protocol
<figure><img src="https://2560886960-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fo8bW2LCw3s9Oq1VIQ85p%2Fuploads%2F16Aq2cfjJWd8WAd1Cuam%2Fimage.png?alt=media&token=99bdf285-6730-4335-adb3-0f2b3c00a083" alt=""><figcaption></figcaption></figure>
x402 is an open payment protocol (originated by Coinbase) that uses the HTTP 402 status code to enable native micropayments within API calls. Cluster integrates x402 as a first-class payment method across the inference API and data marketplace.
# How x402 Works
The protocol operates within the standard HTTP request/response cycle:
1. Client sends a request to a Cluster endpoint (e.g., <mark style="color:$warning;">`POST /v1/chat/completions`</mark>)
2. If no payment is attached, the server responds with <mark style="color:red;">`402 Payment Required`</mark> and includes payment instructions in the response header (amount, recipient wallet, network)
3. Client signs a USDC payment on Base and resubmits the request with the payment proof in the header
4. Server verifies the payment, processes the request, and returns the response
The entire flow adds approximately 1-2 seconds of latency on the initial request. For streaming inference, this is a one-time initial delay - subsequent tokens stream normally.
# Agent-Native Payments
x402 is the mechanism that makes AI agents economically autonomous.
An AI agent with a USDC wallet on Base can call Cluster's inference API, pay for each request programmatically, and receive responses — without any human registering an account, generating an API key, or depositing funds. The agent is a self-sufficient economic actor.
This has direct implications for the emerging agentic web:
* Agents can consume inference from Cluster without human intermediation
* Agents can purchase datasets from the marketplace autonomously
* Multi-agent systems can coordinate and pay for services across the Cluster stack independently
x402 eliminates the account-based friction that prevents agents from accessing AI services today.
# Payment Architecture
Cluster supports three concurrent payment methods:
**x402 (for agents and Web3 developers)** Pay USDC per request via HTTP-native micropayments. No account required. Settlement is instant on Base. Zero protocol fees from x402 itself - Cluster retains 100% of the payment.
**Balance System (for regular users and teams)** Deposit USDC or ETH via the platform. Balance is deducted per API call on a pay-as-you-go basis. Suitable for users with budgets who prefer a traditional deposit-and-spend flow.
**Direct On-Chain Payment (for dataset purchases)** One-time payment via the PaymentRouter smart contract. Buyer sends ETH/token → contract splits revenue → buyer receives access. Suitable for high-value, one-off purchases.
All three methods coexist. The gateway detects which payment method is present in the request and routes accordingly.
# Platform Overview
Cluster Hub (hub.clusterprotocol.ai) is the unified web interface for the entire Cluster Protocol ecosystem. It provides a consumer-facing entry point to all infrastructure services - model browsing, dataset discovery, API key management, usage analytics, and billing.
Authentication is handled by Privy, supporting both Web2 (email, Google) and Web3 (wallet) login methods.
<figure><img src="https://2560886960-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fo8bW2LCw3s9Oq1VIQ85p%2Fuploads%2FZyqp2pvnRMfxXV11ZbUl%2Fimage.png?alt=media&token=212e1cb1-e8fc-49a6-822e-3e878c20282e" alt=""><figcaption></figcaption></figure>
# Model Marketplace
The model marketplace allows users to browse, search, and filter the full catalog of 500+ models. Each model entry includes:
* Model description, parameter count, and architecture
* Provider and availability status
* Pricing (per-token, input/output rates)
* Performance benchmarks
* One-click API call generation
Users can also upload community models - versioned, rated, and discoverable by other users on the platform.
# Dataset Marketplace
The dataset marketplace surfaces all tokenized datasets with full metadata, preview capabilities, and on-chain ownership information. Users can:
* Browse datasets by domain, license, size, and tags
* Preview first rows before login
* View on-chain NFT ownership and transaction history
* Purchase access (payment handled by PaymentRouter)
* Upload and tokenize new datasets
# Developer Dashboard & API Keys
Authenticated users access a dashboard that includes:
* **API key management** — create, revoke, and configure permissions (read, write, admin) with configurable expiration
* **Usage analytics** — per-model, per-day breakdown of API calls and token consumption
* **Balance management** — view balance, deposit funds, track spending
* **Creator dashboard** — earnings from dataset sales, purchase history
* **Dataset management** — view, edit, and manage uploaded datasets
<figure><img src="https://2560886960-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fo8bW2LCw3s9Oq1VIQ85p%2Fuploads%2FMXNAHVGB3zccsQaVlSRS%2Fimage.png?alt=media&token=e256cd3e-4b62-47ba-9a03-a478b2a23062" alt=""><figcaption></figcaption></figure>
# Prompt-to-dApp
CodeXero is the application layer built natively on Cluster Protocol's infrastructure. It enables anyone to create, and deploy fully on-chain applications using a natural language prompt.
<figure><img src="https://2560886960-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fo8bW2LCw3s9Oq1VIQ85p%2Fuploads%2FlObm6ibb5ItA4BsAqYOZ%2Fimage.png?alt=media&token=59f3241f-a60a-41fc-ba4d-c6f2e6b3f753" alt=""><figcaption></figcaption></figure>
A user describes what they want to build in plain language. CodeXero:
1. Interprets the prompt and generates a build plan
2. Generates frontend code and smart contract logic
3. Compiles smart contracts (Solidity → ABI/bytecode)
4. Deploys frontend to hosting (Netlify/IPFS)
5. Deploys contracts to the target blockchain via the user's connected wallet
The entire process happens in the browser. No local setup, no CLI, no dependencies.
# Browser-Native Runtime
CodeXero runs a full development environment in the browser via WebContainer: a browser-native Node.js runtime. This includes:
* **ActionRunner**: Executes streamed build actions deterministically
* **WebContainer**: Full Node.js toolchain in-browser
* **TerminalManager**: Live CLI and build logs
* **Contract Compiler**: Solidity compilation to ABI and bytecode
* **WalletConnector**: Transaction signing and on-chain deployment
The user never installs anything. The entire build, compile, and deploy cycle runs in their browser tab.
# How CodeXero Consumes Cluster Infra
CodeXero is not a standalone product: it is the primary consumption engine for Cluster's infrastructure:
* **Inference**: Every prompt-to-dApp generation calls Cluster's inference API for code generation, planning, and model routing
* **Compute**: Smart contract compilation and deployment verification runs on Cluster compute
* **Data**: Templates and starter repos are sourced through the Cluster ecosystem
Every dApp deployed through CodeXero generates inference token consumption, creating organic demand for the Cluster프로젝트로 돌아가기