Model Owner

Model Owner

The Model Owner is the actor who brings a model to the network and runs its training from start to finish. They deploy the model's Task Contracts, define its logic through the manifest and service files, seed it with a genesis model, and orchestrate every Global Iteration — opening and closing each phase that Clients, Auditors, and Aggregators act within.

The role is deliberately powerful within its own model and powerless outside it: a model owner drives their model's lifecycle and can trigger slashing of its misbehaving validators, but admission to the network itself is gated by the DIN-Representative, and validator stakes live in the shared platform contracts.

Onboarding a model

A one-time setup path, in order:

1. Deploy the task contracts — dincli model-owner deploy task-coordinator / task-auditor, one pair per model.
2. Request slasher authorization — ask the DIN-Representative (off-chain, via the official channels) to authorize both contracts as slashers on DinValidatorStake; then confirm the authorization on the task side (dincli model-owner add-slasher).
3. Write the manifest & service files — the model's architecture and role logic (model.py, modelowner.py, client.py, auditor.py, aggregator.py), pinned to IPFS and referenced by CID in manifest.json. This is where the model owner's ML expertise lives; the protocol never sees the code, only its CIDs. See Manifest & Services.
4. Create & submit the genesis model — the initial weights every client starts from (dincli model-owner model create-genesis / submit-genesis); its score against the owner's test dataset sets the eligibility threshold for local models.
5. Request model registration — submit a registration request to DinModelRegistry (open-source or proprietary, with the corresponding fee); the DIN-Representative approves and the model receives its model ID.

Registration fees

Fees are charged on submission (approved or rejected — spam protection) and held by the registry for the ecosystem:

Action	Open-source	Proprietary
Register a new model	0.000001 ETH	0.00001 ETH
Request a manifest update	0.0000001 ETH	0.000001 ETH

Running a Global Iteration

Once registered, training proceeds in GIs, each producing a new global model. The model owner is the conductor: every phase is opened and closed by their explicit command, and participants can only act while their phase is open.

Phase	Model owner's job
Start GI	gi start — optionally setting the local-model score threshold (defaults to 5% below the latest global model's accuracy)
Registration	open/close the aggregator and auditor registration windows
LMS	open/close the window in which clients submit trained local models
Auditor assignment	create audit batches and generate/submit the test dataset auditors evaluate against
Evaluation	start/close the scoring phase, review results per auditor and per model
Aggregation	create T1/T2 batches, start/close Tier-1 and Tier-2 aggregation
Slash & end	trigger slashing of non-compliant auditors and aggregators, then gi end — the finalized T2 output becomes the next GI's starting model

Monitoring commands (show-state, show-models, show-t1-batches, …) give a live view at every step.

What the model owner provides vs. what the network provides

Model owner brings	Network provides
Model architecture & training logic (service files)	Sandboxed execution of that logic on participants' machines
Genesis model & test datasets	Clients' private data (never shared — only trained weights return)
Phase orchestration each GI	Staked, slashable validators to audit and aggregate honestly
Registration & update fees	Registry, staking, and settlement infrastructure

Further reading

• Model Owner command reference — every command with options
• Model Workflow — the full onboarding + GI walkthrough in order
• Task Contracts — the contracts this role deploys and drives
• Manifest · Services — the model-definition format