ComptyAI

Hold tokens. Get compute.
A compute-access protocol designed for Robinhood Chain.
$COMPTY: 0x7095beb8192b352a4c33f9e3c532e3b2f4d116e6

Documentation · Protocol · Quickstart · Roadmap

The idea

ComptyAI turns token activity into access to AI compute. A portion of collected token-related trading fees or protocol revenue is directed to a Compute Treasury. The treasury funds GPU rentals, and eligible token holders receive Compute Credits to use that capacity without a separate compute payment within their allocation.

The objective is useful capacity: inference, experiments, agent workloads and, where a supported GPU tier allows it, lightweight training. Token activity helps fund the service; compute is the utility holders receive.

“We don’t accumulate tokens. We accumulate compute.”

Current stage: protocol design and a runnable local reference model. Live fee collection, token deployment, funded GPU capacity and wallet-based claims are planned integrations. This repository does not announce a deployed or audited protocol.

From activity to access

Ordinary token transfers and chain gas fees do not automatically produce revenue for ComptyAI. Fee-generating integrations must be implemented explicitly. Read the fee-routing design.

Compute Credits

Compute Credits represent a limited service allowance, not another tradable token. The proposed flow uses an eligible-holder snapshot to allocate an epoch’s funded capacity, then meters use through the compute gateway.

• Holder access: eligibility and allocation rules are published for each epoch.
• Budget-backed allowance: issued credits must fit the capacity the treasury can fund.
• Usage accounting: reserve a maximum, settle actual usage, release the remainder.
• Defined limits: each credit has a GPU tier, expiry and service conditions.

“Free compute” means no additional compute charge within a holder’s funded allowance. Capacity, availability and limits still apply; wallet transactions may require network gas. The demo defines 1 credit = 1 minute of one example GPU tier. Final denominations and allocation policies remain open design decisions.

See credit lifecycle, holder eligibility and allocation math.

Try the reference model

Requires Node.js 22+. The example uses only built-in modules, so no dependency installation or wallet is required.

git clone https://github.com/hazelp343/ComptyAI.git
cd ComptyAI
npm run demo
npm test
npm run check

The deterministic demo follows one fictional epoch:

The sample job reserves 120 credits for the first holder, consumes 90 and releases 30, leaving 8,010 available credits. All values are fictional: they are not live fees, GPU quotes, tokenomics or promised capacity. Walk through the example →

Repository map

ComptyAI/
├── assets/
│   ├── brand/                   Original project logo + brand notes
│   └── banners/                 Four README banners + editable SVG sources
├── apps/
│   └── console/src/             End-to-end local demonstration
├── packages/
│   ├── compute-core/src/        Budgeting + proportional allocation
│   ├── credit-ledger/src/       Reserve, settle, cancel + expire credits
│   └── chain-config/src/        Robinhood mainnet + testnet metadata
├── services/
│   └── scheduler/src/providers/ Mock GPU adapter + execution flow
├── contracts/
│   └── src/interfaces/          Proposed Solidity integration interfaces
├── configs/                     Explicitly marked example parameters
├── examples/
│   ├── epochs/                  Fee + holder fixture
│   └── jobs/                    Example inference request
├── docs/
│   ├── protocol/                Fees, treasury, credits + eligibility
│   ├── architecture/adr/        Boundaries + design decisions
│   ├── economics/               Budget and allocation formulas
│   ├── developers/              Setup + chain integration notes
│   ├── operations/              Epoch runbook + transparency reporting
│   └── zh-CN/                   Chinese project introduction
├── tests/
│   ├── unit/                    Budget, allocation + ledger invariants
│   └── integration/             Complete mock execution lifecycle
├── scripts/                     Repository validation + asset generation
└── .github/
    ├── workflows/               Repository verification in CI
    └── ISSUE_TEMPLATE/          Bug reports + feature proposals

Designed for Robinhood Chain

The project targets Robinhood Chain, an EVM-compatible Ethereum Layer 2 built with Arbitrum technology. The local example defaults to Robinhood Chain Testnet; mainnet metadata is provided for future integration. Network IDs and endpoints are documented in chain configuration, with links to the official network documentation.

ComptyAI is an independent project. Targeting Robinhood Chain does not imply a partnership or endorsement. No ComptyAI contract address is published in this repository.

Build status

Read the roadmap for milestone acceptance criteria and the architecture for the trust boundaries.

Build with ComptyAI

Start with the developer quickstart, open a focused issue or propose a change through the contribution guide. See SECURITY.md for handling sensitive findings.

Code is licensed under MIT. The project name, supplied logo and brand artwork are covered separately in the brand notes.