Ctrlk
DeepNode Home
For the complete documentation index, see llms.txt. This page is also available as Markdown.
ChatGPT

Model Lifecycle

Lifecycle of a model within DeepNode — from publishing, deployment, validation, rewards, to deprecation or updates.

DeepNode’s architecture applies clear and enforceable lifecycle policies across all critical roles, Models, Miners, and Validators. Each entity follows a defined progression that governs how it is registered, utilized, monitored, upgraded, or removed.

This design promotes automation, reliability, and trust across the system.

What is a Lifecycle in DeepNode?

A lifecycle is the full progression that a network entity (such as a model or node) undergoes, beginning with registration and activation and continuing through operational usage, evaluation, and eventual upgrade or deactivation.

Each lifecycle incorporates both:

  • On-chain mechanisms (e.g., NFT registration, staking, validation commitments)

  • Off-chain processes (e.g., metadata checks, controlled testing phases, performance evaluation)

This dual approach allows DeepNode to leverage on-chain governance where appropriate while maintaining flexible orchestration in supporting infrastructure.

Why Lifecycles Matter

DeepNode’s lifecycle architecture ensures:

  • Standardized participation A consistent process for how all entities join and operate within the network.

  • Automated execution Lifecycle transitions and validations occur through protocol-driven processes, reducing manual intervention.

  • Accountability Reputation tracking and corrective measures maintain quality and discourage non-compliant behavior.

  • Transparent operation On-chain records and event-driven contract actions provide a verifiable and auditable history of lifecycle events.

Model Lifecycle

The Model Lifecycle defines the complete process an AI model undergoes within DeepNode, from initial creation to production deployment, iterative improvements, and eventual removal. This ensures every model in the network is verified, reliable, and properly tracked before being accessible to users.

The lifecycle is coordinated through a combination of smart contracts, validator mechanisms, and node orchestration services.

1. Draft Creation

  • The lifecycle begins when a Model Creator submits a new model draft through the DeepNode portal or API.

  • The model is stored off-chain in Draft status with a temporary identifier.

  • During this stage, Creators may freely edit, refine, and iterate on the model.

2. Registration & NFT Minting

  • Once the draft is ready for registration, the Creator initiates on-chain enrollment.

  • An ERC-1155 NFT is minted by the Model Contract, establishing ownership to the Creator (Miner).

  • The draft’s temporary ID is replaced with the permanent NFT-based Model ID.

3. Metadata Validation

  • Creators submit associated metadata (description, usage parameters, pricing, etc.) to IPFS.

  • A validation request is issued and reviewed by Validators.

  • If approved, Validators sign the metadata and submit it on-chain via the Model Contract.

If validation fails, the Creator must revise the metadata and re-process the validation step.

4. Test Deployment

  • The model is deployed to a test node selected by the Node Service.

  • If deployment fails, the system retries with another node or returns an error to the Creator for resolution.

5. Functional Validation

  • Upon successful deployment, a new validation task is assigned.

  • A randomized group of Validators receives the request on-chain and performs performance and behavior checks using the Partner API.

  • Results are submitted to the Validator Contract.

If consensus is negative, Validators provide structured feedback, and the Creator must make updates and redeploy the model before re-entering the validation step.

6. Production Deployment

  • After passing validation, the model is promoted to production.

  • The Node Service deploys the model to two nodes:

    • one from the top of the trust-weighted list

    • one from the bottom

  • This ensures redundancy and fairness in distribution.

If errors occur, new nodes are selected or the Creator is notified to fix issues and redeploy.

7. Model Goes Live

  • Once active, the model becomes visible within the public marketplace.

  • Consumers can submit requests via the portal or API.

  • Requests are routed to a node, with options for autopayment or encrypted bill-based access.

  • Results are returned and payments are processed automatically through the Model Contract.

8. Feedback & Rating

  • Consumers may provide ratings and feedback after each request.

  • These contribute to the model’s trust score and influence its marketplace ranking.

  • Consistent performance increases visibility; repeated errors lower ranking and credibility.

9. Updates & Versioning

  • Creators may update model metadata or logic.

  • Each update must undergo validation before deployment.

  • All versions are linked to the model’s NFT, preserving transparent version history.

10. Rotation & Maintenance

  • DeepNode periodically rotates production deployments, ensuring each model is executed across a diverse set of nodes.

  • This helps prevent centralization, supports network health, and gives newer nodes opportunities to execute established models.

11. Model Removal

  • Creators may voluntarily remove their model by burning the associated NFT.

  • Forced removal is also possible through governance decisions if a model is malicious or non-functional.

  • Removal terminates all active deployments and removes the model from the marketplace.

Node Lifecycle

The Node Lifecycle defines how a node is introduced into the DeepNode network, how it operates during its active period, and how it exits the system. Nodes are infrastructure units controlled by Miners (node operators) that execute AI models, process requests, and support both test-phase and production-phase deployments.

Each node is represented on-chain by an ERC-1155 NFT and follows a permissioned flow to maintain reliability, fairness, and quality within the network.

1. Slot Reservation & Staking

  • The Miner reserves a node slot by staking $DN through the Node Contract.

  • The reservation is time-limited, if the Miner does not bring the node online before the deadline, the slot is released and the stake may be penalized.

2. Off-Chain Deployment

  • The Miner independently deploys the node infrastructure, either on their own dedicated hardware or cloud-based systems.

  • The node must conform to the required API specification to communicate with DeepNode services.

3. Node Registration & NFT Minting

  • Once the node is deployed, the Miner completes on-chain registration.

  • A Node NFT is minted and tied to the reserved slot, establishing the node’s identity and lifecycle on-chain.

4. Draft Metadata Preparation

  • The Miner prepares the node’s metadata, including:

    • technical specs

    • compute capacity

    • description

    • supported domains

  • This data remains in Draft status and can be modified or deleted before being submitted for review.

5. Metadata Validation

  • The Miner uploads metadata to IPFS and submits it to the Validator Service.

  • Validators review the information.

  • If valid, Validators sign the metadata, enabling the Miner to finalize the submission on-chain via the Node Contract.

If invalid, Validators return feedback, and the Miner must correct and resubmit.

6. Node Validation

  • After metadata approval, the Miner initiates full node validation.

  • Validators perform checks through API-based testing using the Partner API, examining:

    • functionality

    • performance

    • reliability

  • Results are submitted on-chain.

Nodes that fail validation must be updated and retested before proceeding.

7. Node Online

  • Once validated, the node is marked as Online.

  • It becomes eligible to:

    • host test model deployments

    • serve production inference requests

    • receive performance-based rewards

8. Test Model Deployments

  • During model validation cycles, the Node Service may assign the node to host temporary test deployments.

  • The node must deploy, run, and remove these models as directed.

9. Production Deployments & Inference

  • Approved models are deployed to production nodes in pairs:

    • one with high reputation

    • one with lower reputation

  • The node processes incoming requests and returns results through the Node Service.

  • Its interaction impacts its reputation score.

10. Monitoring & Ratings

  • A range of telemetry is continuously monitored, including:

    • uptime

    • response speed

    • failure rates

    • throughput

  • Poor metrics reduce the node’s trust score and decrease task assignment frequency.

  • Strong performance metrics improve ranking and reward allocation.

11. Exit Queue & Offboarding

  • To remove a node, the Miner must enter it into the exit queue.

  • During this period, the node must remain active and stable.

  • If errors accumulate during the exit phase, penalties may be applied.

12. Node Removal

  • Once eligible, the Miner finalizes node removal via the Node Contract.

  • This process:

    • unstakes and returns tokens

    • transfers any outstanding rewards

    • burns the Node NFT

    • releases the slot for future participants

Validator Lifecycle

Validators are core participants in DeepNode. They provide independent, automated assessments of models, nodes, and metadata to maintain network quality, fairness, and reliability. Their lifecycle includes staking, registration, task execution, consensus participation, and reputation management.

Validators are represented on-chain via ERC-1155 NFTs and interact with the protocol through both smart contracts and off-chain services.

1. Registration & NFT Minting

  • A prospective Validator stakes $DN and mints a Validator NFT using the Validator Contract.

  • This NFT formally links their identity to the on-chain system and enables them to receive validation task assignments.

Unlike Nodes, Validators may exit at any time without penalty, provided they are not actively engaged in a validation task.

2. Validator Key Generation

  • After NFT minting, the Validator Service issues a unique Validator Key.

  • This key is used to securely authenticate validation tasks through the Partner API.

3. Off-Chain Deployment & Setup

  • The Validator deploys their validation service off-chain and subscribes to task events from the Validator Contract.

  • The service continuously listens for assigned tasks and executes validation logic automatically.

4. Event Subscription

  • The Validator subscribes to the Validator Task event stream using an indexer or chain RPC.

  • This enables real-time detection of newly assigned tasks directed to their Validator ID.

5. Validation Task Execution

Once active, Validators are randomly selected (weighted by reputation) to perform one or more of the following tasks:

  • Model Validation: Evaluate deployed models using the Partner API for accuracy, robustness, performance, and safety (e.g., hallucination detection, benchmarking).

  • Node Validation: Test a node's functional API behavior, performance, load handling, and reliability.

  • Metadata Validation: Review metadata from IPFS for completeness, compliance, and safety (e.g., copyright, malicious content).

6. Commit Decision

  • After completing validation, the Validator generates a structured report hosted on their Validator API.

  • A signed result (pass/fail), along with the report URL, is submitted on-chain to the Validator Contract.

7. Consensus Formation

  • The Validator Service aggregates all results from Validators assigned to the same task.

  • Consensus is determined on-chain through trust-weighted majority agreement scores.

  • If consensus passes, the model or node promoted; if it fails, structured feedback is returned to the creator or operator.

8. Reputation & Rewards

  • Validator build reputation over time based on:

    • alignment with consensus results

    • timely task completion

    • independence of evaluation (no copied results)

  • High-reputation Validators:

    • receive more frequent task assignments

    • attract delegated stake from Stakers

    • earn an increased share of $DN rewards

9. Key Rotation

  • Validator Keys can be securely rotated through the Validator Service and updated in Validator’s configuration.

  • This enables long-term operation changes without affecting accumulated reputation.

10. Exit & Removal

  • Validators may exit the protocol at any time by removing their Validator NFT through the contract.

  • Upon exit:

    • staked $DN is returned

    • the Validator NFT is burned

    • task assignment eligibility is terminated

PreviousRoles
NextDomains

Last updated