The Token Factory & Registry: Standardizing AI Assetization

​

The ERC-20 Standard for AI Agents: Design Philosophy

• Intrinsic Economic Representation: Each token serves as a direct, quantifiable representation of an agent’s potential utility, governance rights, or claim on its generated value. This moves AI beyond a service model to an asset model.
• Standardized Fungibility & Composability: Adherence to the ERC-20 standard ensures seamless integration with the broader DeFi ecosystem on Capx Chain (and potentially beyond), allowing agent tokens to be used in lending protocols, as collateral, or within other financial primitives.
• Predictable Economic Framework: A uniform issuance model provides a stable foundation for valuation, market analysis, and the development of sophisticated financial instruments around AI agents.

​

The Token Factory: Protocol Mechanics & Automated Issuance

​

Contract Implementation: Capx Agent Contracts ➹

    //SPDX-License-Identifier: MIT
    pragma solidity ^0.8.20;

    interface ICapxAgentFactory {
        struct CapxAgentParams {
            string name;
            string symbol;
            string tokenURI;
            uint8 decimals;
            uint256 ecr20TotalSupply;
            address agentOwner;
        }

        struct CapxAgentInfo {
            uint256 id;
            address agent;
            string name;
            string symbol;
            string tokenURI;
            uint8 decimals;
            uint256 ecr20TotalSupply;
            address initialAgentOwner;
        }

        event NewCapxAgent(
            address indexed agent,
            address indexed owner,
            string name,
            string symbol,
            string tokenURI,
            uint8 decimals,
            uint256 erc20TotalSupply
        );

        function createAgent(CapxAgentParams memory _agentParams) external;
        
        function name() public view returns (string memory);

        function symbol() public view returns (string memory);
        
        function decimals() public view returns (uint8);
    }

​

Technical Issuance Process:

1. Agent Deployment Trigger: Upon successful deployment of an AI agent via Capx Cloud, a secure call is made to the Token Factory contract on Capx Chain.
2. Dedicated Agent Wallet Context: The deployment process ensures the agent is associated with a Privy-linked wallet. This wallet becomes the initial recipient or controller of certain token allocations, ensuring secure, programmatic control for the agent or its creator.
3. Immutable Token Contract Generation: The Token Factory executes the createAgent function (or a similar internal method). This function deploys a new, distinct ERC-20 compliant smart contract for the agent.
   • Fixed Supply Parameter: 1,000,000,000 (one billion) tokens are minted to a totalSupply variable within the new token contract. This supply is immutable; the ERC-20 contract itself will contain no mint() or burn() functions callable post-deployment, ensuring absolute supply predictability.
   • Standardized Token Parameters:
     • name(): Derived from the agent’s registered name (e.g., “Agent X Token”).
     • symbol(): A unique ticker (e.g., “AXT”).
     • decimals(): Standard ERC-20 decimal places (typically 18).
   • Ownership & Control: The Token Factory may temporarily hold ownership to set initial parameters or immediately transfer ownership of the new token contract to the agent’s Privy-linked wallet or a pre-specified developer/DAO address.
4. Automated Initial Allocation & Vesting (Conceptual):
   • A significant portion of the totalSupply is programmatically transferred to predefined addresses or vesting contracts. This distribution is determined by allocation rules.
     • Developer/Creator Allocation: Transferred to the developer’s wallet, potentially via a vesting contract (e.g., linear release over time) to align long-term incentives.
     • Ecosystem/Treasury Reserve: Allocated to a Capx-controlled multisig or DAO treasury for grants, community incentives, or strategic airdrops.
     • Initial Liquidity Pool Seeding Allocation: A portion designated to bootstrap the agent’s trading pair on the native Capx DEX.
     • Public Float: The remaining tokens become immediately available for circulation.
   • Future Iterations: The allocation logic within the Token Factory or associated contracts may incorporate more complex vesting schedules or DAO-configurable parameters, subject to on-chain governance.

​

The Capx Token Registry: On-Chain Verifiability & Discovery

​

Registry Functions & Importance:

• registerToken(address agentTokenContract, bytes32 agentIdentifier): When the Token Factory creates a new agent token, it (or an authorized address) calls this function to log the new token contract’s address alongside a unique identifier for the AI agent (e.g., a hash of its metadata or deployment ID).
• Source of Truth: The registry provides an immutable, auditable record, allowing dApps, explorers, and users (via the Capx SuperApp) to verify that a given ERC-20 token is an officially sanctioned Capx AI agent token, mitigating risks of counterfeit or imposter tokens.
• Metadata Linkage: The registry might store or link to off-chain (e.g., IPFS) or on-chain metadata about the agent (description, creator, performance metrics pointers), enabling rich data display in frontends.
• Facilitating Discovery & Integration: The Capx SuperApp and the native DEX directly query this registry to populate lists of tradable agents, ensuring users only interact with verified assets. Third-party services can also integrate with this registry for data provisioning.

​

Lifecycle & Governance:

1. Deployment & Automatic Registration: An AI agent is deployed via Capx Cloud; the Token Factory mints its 1 billion tokens and registers the new token contract with the Capx Token Registry.
2. Initial Liquidity Event: A portion of the minted tokens, paired with $CAPX, is used to seed a liquidity pool on the Capx DEX, establishing an initial market.
3. Market Dynamics: Users discover the agent token via the Capx SuperApp (which sources data from the Registry and DEX), trade it, stake it (if yield mechanisms are enabled), and participate in its micro-economy.
4. Value Accrual & Fluctuation: The agent token’s market value evolves based on the agent’s utility, performance, adoption, demand, and overall market sentiment, all transparently reflected on-chain.