Agents.sol

Overview

The Agents.sol contract is the core registry and economic coordination layer for Nexis AI agents. It manages agent registration, staking mechanisms, reputation systems, proof-of-inference recording, and delegation permissions. The contract is implemented as an upgradeable (UUPS) module with role-based access control. Contract Location: /nexis-appchain/packages/contracts-bedrock/contracts/Agents.sol

Key Features

Agent Registration: Decentralized registry for AI agents with metadata and service endpoints
Multi-Asset Staking: Support for ETH and ERC20 token staking with unbonding periods
Reputation System: Multi-dimensional reputation tracking across reliability, accuracy, performance, and trustworthiness
Proof of Inference: On-chain commitment and attestation of AI model outputs
Delegation Framework: Granular permission delegation for metadata, inference, and withdrawal operations
Treasury Integration: Automated routing of slashed stakes and penalties to treasury pools

Architecture

Contract Roles

Access Control Roles

Role	Bytes32 Identifier	Description
`DEFAULT_ADMIN_ROLE`	`0x00`	Administrative control over contract configuration
`SLASHER_ROLE`	`keccak256("SLASHER_ROLE")`	Authority to slash agent stakes for violations
`REPUTATION_ROLE`	`keccak256("REPUTATION_ROLE")`	Permission to adjust agent reputation scores
`ORACLE_ROLE`	`keccak256("ORACLE_ROLE")`	Can record inferences without explicit delegation
`CONTRIBUTION_ROLE`	`keccak256("CONTRIBUTION_ROLE")`	Log contributions to agent development
`VERIFIER_ROLE`	`keccak256("VERIFIER_ROLE")`	Attest to inference validity and quality
`TASK_MODULE_ROLE`	`keccak256("TASK_MODULE_ROLE")`	Lock/unlock stakes (typically Tasks.sol)

Delegation Permissions

Permission	Bytes32 Identifier	Description
`PERMISSION_METADATA`	`keccak256("PERMISSION_METADATA")`	Update agent metadata and service URI
`PERMISSION_INFERENCE`	`keccak256("PERMISSION_INFERENCE")`	Record inference commitments
`PERMISSION_WITHDRAW`	`keccak256("PERMISSION_WITHDRAW")`	Request and claim withdrawals

Core Data Structures

AgentSummary

struct AgentSummary {
    uint256 agentId;           // Unique agent identifier
    address owner;             // Agent owner address
    string metadata;           // IPFS/Arweave URI with agent details
    string serviceURI;         // Service endpoint (API URL, gRPC, etc.)
    uint256 totalStake;        // Total staked across all assets
    uint256 lockedStake;       // Stake locked in active tasks
    int256 weightedReputation; // Aggregated reputation score
}

InferenceCommitment

struct InferenceCommitment {
    uint256 agentId;      // Agent performing inference
    bytes32 inputHash;    // Hash of input data
    bytes32 outputHash;   // Hash of output/prediction
    bytes32 modelHash;    // Hash of model version/weights
    uint256 taskId;       // Associated task ID (0 if none)
    address reporter;     // Address that recorded the inference
    string proofURI;      // URI to proof artifacts (ZK proof, etc.)
    uint64 timestamp;     // Recording timestamp
}

StakeView

struct StakeView {
    uint256 total;     // Total staked amount
    uint256 locked;    // Amount locked in tasks
    uint256 available; // Amount available for withdrawal/locking
}

PendingWithdrawal

struct PendingWithdrawal {
    uint256 amount;       // Withdrawal amount
    uint64 releaseTime;   // Timestamp when withdrawal becomes claimable
}

ReputationDelta

struct ReputationDelta {
    bytes32 dimension;  // Reputation dimension (reliability, accuracy, etc.)
    int256 delta;       // Change to apply (positive or negative)
    string reason;      // Human-readable justification
}

Agent Registration & Metadata

register

function register(
    uint256 agentId,
    string calldata metadata,
    string calldata serviceURI
) external whenNotPaused

Parameters:

agentId: Unique identifier for the agent (chosen by registrant)
metadata: IPFS/Arweave URI containing agent description, capabilities, model info
serviceURI: Service endpoint for invoking the agent (HTTP API, gRPC, WebSocket, etc.)

Emits: AgentRegistered(address indexed owner, uint256 indexed agentId, string metadata, string serviceURI) Example:

// JavaScript (ethers.js)
const agentsContract = new ethers.Contract(AGENTS_ADDRESS, AGENTS_ABI, signer);

const agentId = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("my-agent-v1"));
const metadata = "ipfs://QmXyZ..."; // Agent description, model details
const serviceURI = "https://api.myagent.com/v1/inference";

const tx = await agentsContract.register(agentId, metadata, serviceURI);
await tx.wait();
console.log(`Agent registered with ID: ${agentId}`);

Reverts:

AgentAlreadyRegistered(uint256 agentId, address currentOwner) if agent ID is taken

updateMetadata

Update agent metadata URI (owner or metadata delegate only).

function updateMetadata(
    uint256 agentId,
    string calldata metadata
) external onlyOwnerOrDelegate(agentId, PERMISSION_METADATA)

Example:

const newMetadata = "ipfs://QmNewHash...";
await agentsContract.updateMetadata(agentId, newMetadata);

updateServiceURI

Update agent service endpoint.

function updateServiceURI(
    uint256 agentId,
    string calldata serviceURI
) external onlyOwnerOrDelegate(agentId, PERMISSION_METADATA)

transferAgentOwnership

Transfer agent ownership to a new address.

function transferAgentOwnership(
    uint256 agentId,
    address newOwner
) external onlyAgentOwner(agentId)

Emits: AgentOwnershipTransferred(uint256 indexed agentId, address indexed previousOwner, address indexed newOwner)

Staking System

stakeETH

Stake native ETH to an agent.

function stakeETH(uint256 agentId) external payable nonReentrant whenNotPaused

Parameters:

agentId: Agent to stake for
msg.value: Amount of ETH to stake

Emits:

StakeIncreased(uint256 indexed agentId, address indexed asset, address indexed staker, uint256 amount, uint256 totalStaked)

Example:

const stakeAmount = ethers.utils.parseEther("10.0"); // 10 ETH
const tx = await agentsContract.stakeETH(agentId, { value: stakeAmount });
await tx.wait();

stakeERC20

Stake ERC20 tokens to an agent.

function stakeERC20(
    uint256 agentId,
    address token,
    uint256 amount
) external nonReentrant whenNotPaused

Parameters:

agentId: Agent to stake for
token: ERC20 token address
amount: Token amount (in token’s smallest unit)

Prerequisites:

Caller must approve Agents contract to spend tokens

Example:

// 1. Approve token spending
const tokenContract = new ethers.Contract(TOKEN_ADDRESS, ERC20_ABI, signer);
const stakeAmount = ethers.utils.parseUnits("1000", 18); // 1000 tokens
await tokenContract.approve(AGENTS_ADDRESS, stakeAmount);

// 2. Stake tokens
await agentsContract.stakeERC20(agentId, TOKEN_ADDRESS, stakeAmount);

requestWithdrawal

Initiate unbonding period for stake withdrawal.

function requestWithdrawal(
    uint256 agentId,
    address asset,
    uint256 amount
) external whenNotPaused onlyOwnerOrDelegate(agentId, PERMISSION_WITHDRAW)

Parameters:

agentId: Agent ID
asset: Asset address (address(0) for ETH)
amount: Amount to withdraw

Behavior:

Immediately reduces active stake
Creates pending withdrawal entry with release timestamp
Release time = block.timestamp + unbondingPeriod[asset]

Emits: UnbondingInitiated(uint256 indexed agentId, address indexed asset, uint256 amount, uint64 releaseTime) Example:

const withdrawAmount = ethers.utils.parseEther("5.0");
const ethAsset = ethers.constants.AddressZero;

await agentsContract.requestWithdrawal(agentId, ethAsset, withdrawAmount);

claimWithdrawals

Claim matured withdrawals (or force early exit with penalty).

function claimWithdrawals(
    uint256 agentId,
    address asset,
    uint256 maxEntries,
    address receiver,
    bool forceEarly
) external nonReentrant whenNotPaused onlyOwnerOrDelegate(agentId, PERMISSION_WITHDRAW)
    returns (uint256 releasedAmount, uint256 penaltyAmount)

Parameters:

agentId: Agent ID
asset: Asset address
maxEntries: Maximum withdrawal queue entries to process (0 = unlimited)
receiver: Recipient address (address(0) = agent owner)
forceEarly: If true, claim withdrawals before unbonding period ends (incurs penalty)

Returns:

releasedAmount: Amount transferred to receiver
penaltyAmount: Penalty deducted (sent to treasury)

Emits:

WithdrawalExecuted(...) for normal withdrawals
EarlyWithdrawal(...) if forceEarly is true

Example:

// Claim all matured withdrawals
const [released, penalty] = await agentsContract.callStatic.claimWithdrawals(
    agentId,
    ethers.constants.AddressZero,
    0,  // maxEntries
    ethers.constants.AddressZero,  // receiver (defaults to owner)
    false  // forceEarly
);

const tx = await agentsContract.claimWithdrawals(
    agentId,
    ethers.constants.AddressZero,
    0,
    ethers.constants.AddressZero,
    false
);
await tx.wait();
console.log(`Claimed ${ethers.utils.formatEther(released)} ETH`);

cancelWithdrawal

Cancel a pending withdrawal and restore stake.

function cancelWithdrawal(
    uint256 agentId,
    address asset,
    uint256 queueIndex
) external whenNotPaused onlyOwnerOrDelegate(agentId, PERMISSION_WITHDRAW)

Parameters:

queueIndex: Index in withdrawal queue (relative to head)

Emits: WithdrawalCancelled(uint256 indexed agentId, address indexed asset, uint256 amount)

stakeBalances

Query stake amounts for an agent.

function stakeBalances(
    uint256 agentId,
    address asset
) public view returns (StakeView memory)

Returns:

struct StakeView {
    uint256 total;     // Total staked
    uint256 locked;    // Locked in tasks
    uint256 available; // Available for withdrawal/locking
}

Example:

const balances = await agentsContract.stakeBalances(agentId, ethers.constants.AddressZero);
console.log(`Total: ${ethers.utils.formatEther(balances.total)} ETH`);
console.log(`Locked: ${ethers.utils.formatEther(balances.locked)} ETH`);
console.log(`Available: ${ethers.utils.formatEther(balances.available)} ETH`);

Stake Locking (Task Integration)

lockStake

Lock stake for task execution (callable by Tasks contract via TASK_MODULE_ROLE).

function lockStake(
    uint256 agentId,
    address asset,
    uint256 amount
) external onlyRole(TASK_MODULE_ROLE)

Emits: StakeLocked(uint256 indexed agentId, address indexed asset, uint256 amount, uint256 newLockedBalance)

unlockStake

Unlock stake after task completion.

function unlockStake(
    uint256 agentId,
    address asset,
    uint256 amount
) external onlyRole(TASK_MODULE_ROLE)

Emits: StakeUnlocked(uint256 indexed agentId, address indexed asset, uint256 amount, uint256 newLockedBalance)

Slashing

slashStake

Slash agent stake as penalty (callable by SLASHER_ROLE).

function slashStake(
    uint256 agentId,
    address asset,
    uint256 amount
) external nonReentrant onlyRole(SLASHER_ROLE)

Behavior:

Reduces agent’s staked balance
Transfers slashed amount to Treasury
Treasury distributes across pools (40% treasury, 30% insurance, 30% rewards)

Emits: StakeSlashed(uint256 indexed agentId, address indexed asset, uint256 amount) Example:

// Admin/slasher account
const slashAmount = ethers.utils.parseEther("2.0");
await agentsContract.slashStake(agentId, ethers.constants.AddressZero, slashAmount);

Reputation System

Reputation Dimensions

Nexis agents are evaluated across four default dimensions:

Dimension	Bytes32 Key	Description
Reliability	`keccak256("reliability")`	Uptime, response consistency, SLA adherence
Accuracy	`keccak256("accuracy")`	Inference correctness, prediction quality
Performance	`keccak256("performance")`	Latency, throughput, resource efficiency
Trustworthiness	`keccak256("trustworthiness")`	Security, data privacy, ethical behavior

Each dimension is weighted equally by default (2500 BPS each = 25%).

adjustReputation

Adjust agent reputation in a specific dimension (callable by REPUTATION_ROLE).

function adjustReputation(
    uint256 agentId,
    bytes32 dimension,
    int256 delta,
    string calldata reason
) external onlyRole(REPUTATION_ROLE)

Parameters:

dimension: Reputation dimension identifier
delta: Reputation change (positive or negative)
reason: Human-readable justification

Emits: ReputationAdjusted(uint256 indexed agentId, bytes32 indexed dimension, int256 newScore, string reason) Example:

const RELIABILITY_DIM = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("reliability"));
const delta = 50; // Increase by 50 points
const reason = "Achieved 99.9% uptime for Q1 2025";

await agentsContract.adjustReputation(agentId, RELIABILITY_DIM, delta, reason);

aggregatedReputation

Calculate weighted aggregate reputation score.

function aggregatedReputation(uint256 agentId) public view returns (int256 weighted)

Formula:

weighted = Σ(dimension_score × dimension_weight) / Σ(dimension_weight)

Returns: Weighted average reputation score (can be negative) Example:

const reputation = await agentsContract.aggregatedReputation(agentId);
console.log(`Agent reputation: ${reputation.toString()}`);

updateReputationWeight

Update weighting for a reputation dimension (admin only).

function updateReputationWeight(
    bytes32 dimension,
    uint256 weight
) external onlyRole(DEFAULT_ADMIN_ROLE)

Parameters:

weight: Weight in basis points (0-10000)

Inference Recording & Verification

recordInference

Record proof-of-inference commitment on-chain.

function recordInference(
    uint256 agentId,
    bytes32 inputHash,
    bytes32 outputHash,
    bytes32 modelHash,
    uint256 taskId,
    string calldata proofURI
) external whenNotPaused returns (bytes32 inferenceId)

Parameters:

inputHash: Hash of inference input data
outputHash: Hash of model output/prediction
modelHash: Hash identifying model version
taskId: Associated task ID (0 if none)
proofURI: URI to proof artifacts (ZK proof, execution trace, etc.)

Returns: Unique inference ID (keccak256(agentId, nonce, inputHash, outputHash)) Authorization: Agent owner, inference delegate, or ORACLE_ROLE Emits: InferenceRecorded(...) Example:

const inputData = { prompt: "Analyze sentiment", context: "..." };
const inputHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(JSON.stringify(inputData)));

const output = { result: "positive", confidence: 0.92 };
const outputHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(JSON.stringify(output)));

const modelHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("gpt-4-sentiment-v2"));
const proofURI = "ipfs://QmProof...";

const inferenceId = await agentsContract.callStatic.recordInference(
    agentId,
    inputHash,
    outputHash,
    modelHash,
    0, // taskId (0 if not task-related)
    proofURI
);

await agentsContract.recordInference(agentId, inputHash, outputHash, modelHash, 0, proofURI);
console.log(`Inference recorded: ${inferenceId}`);

attestInference

Attest to inference validity (callable by VERIFIER_ROLE).

function attestInference(
    bytes32 inferenceId,
    bool success,
    string calldata uri,
    ReputationDelta[] calldata deltas
) external onlyRole(VERIFIER_ROLE)

Parameters:

inferenceId: Inference to attest
success: Whether inference passed verification
uri: URI to attestation report/details
deltas: Reputation adjustments to apply

Behavior:

Records attestation on-chain
Applies reputation deltas
If associated with a task, triggers Tasks.onInferenceVerified()

Emits: InferenceAttested(...) Example:

// Solidity (verifier contract)
ReputationDelta[] memory deltas = new ReputationDelta[](2);
deltas[0] = ReputationDelta({
    dimension: keccak256("accuracy"),
    delta: int256(10),
    reason: "Correct prediction verified"
});
deltas[1] = ReputationDelta({
    dimension: keccak256("performance"),
    delta: int256(5),
    reason: "Fast response time"
});

agents.attestInference(inferenceId, true, "ipfs://QmAttestation...", deltas);

getInference

Retrieve inference commitment and attestation.

function getInference(bytes32 inferenceId)
    external view
    returns (
        InferenceCommitment memory commitment,
        VerifierAttestation memory attestation
    )

Example:

const [commitment, attestation] = await agentsContract.getInference(inferenceId);
console.log("Agent ID:", commitment.agentId.toString());
console.log("Task ID:", commitment.taskId.toString());
console.log("Proof URI:", commitment.proofURI);
console.log("Verified:", attestation.success);

Delegation

setDelegate

Grant or revoke delegation permissions.

function setDelegate(
    uint256 agentId,
    address delegate,
    bytes32 permission,
    bool enabled
) external onlyAgentOwner(agentId)

Parameters:

delegate: Address to grant/revoke permissions
permission: PERMISSION_METADATA, PERMISSION_INFERENCE, or PERMISSION_WITHDRAW
enabled: true to grant, false to revoke

Emits: DelegateUpdated(uint256 indexed agentId, address indexed delegate, bytes32 indexed permission, bool enabled) Example:

const PERMISSION_INFERENCE = await agentsContract.PERMISSION_INFERENCE();
const delegateAddress = "0x1234...";

// Grant inference permission to delegate
await agentsContract.setDelegate(agentId, delegateAddress, PERMISSION_INFERENCE, true);

// Revoke permission
await agentsContract.setDelegate(agentId, delegateAddress, PERMISSION_INFERENCE, false);

hasDelegatedPermission

Check if an address has delegated permission.

function hasDelegatedPermission(
    uint256 agentId,
    address operator,
    bytes32 permission
) public view returns (bool)

Example:

const PERMISSION_WITHDRAW = await agentsContract.PERMISSION_WITHDRAW();
const hasPermission = await agentsContract.hasDelegatedPermission(
    agentId,
    operatorAddress,
    PERMISSION_WITHDRAW
);

Discovery & Aggregation

listAgents

List agents with pagination.

function listAgents(
    uint256 offset,
    uint256 limit
) external view returns (AgentSummary[] memory)

Parameters:

offset: Starting index
limit: Maximum results (0 = all remaining)

Example:

// Fetch first 100 agents
const agents = await agentsContract.listAgents(0, 100);

agents.forEach((agent, index) => {
    console.log(`Agent ${index}:`, {
        id: agent.agentId.toString(),
        owner: agent.owner,
        totalStake: ethers.utils.formatEther(agent.totalStake),
        reputation: agent.weightedReputation.toString()
    });
});

aggregatedStats

Get network-wide statistics.

function aggregatedStats() external view returns (AggregatedStats memory)

Returns:

struct AggregatedStats {
    uint256 totalAgents;
    address[] assets;
    uint256[] totalStakedPerAsset;
}

Example:

const stats = await agentsContract.aggregatedStats();
console.log(`Total agents: ${stats.totalAgents.toString()}`);

stats.assets.forEach((asset, i) => {
    const amount = stats.totalStakedPerAsset[i];
    console.log(`Asset ${asset}: ${ethers.utils.formatEther(amount)} staked`);
});

Admin Functions

pause / unpause

Emergency pause contract operations.

function pause() external onlyRole(DEFAULT_ADMIN_ROLE)
function unpause() external onlyRole(DEFAULT_ADMIN_ROLE)

setTreasury

Update treasury contract address.

function setTreasury(address newTreasury) external onlyRole(DEFAULT_ADMIN_ROLE)

setTasksContract

Set Tasks contract for inference verification callbacks.

function setTasksContract(address newTasksContract) external onlyRole(DEFAULT_ADMIN_ROLE)

setUnbondingPeriod

Configure unbonding period for an asset.

function setUnbondingPeriod(
    address asset,
    uint64 period
) external onlyRole(DEFAULT_ADMIN_ROLE)

Example:

// Set 14 day unbonding for USDC
const USDC_ADDRESS = "0xA0b8...";
const period = 14 * 24 * 60 * 60; // 14 days in seconds

await agentsContract.setUnbondingPeriod(USDC_ADDRESS, period);

setEarlyExitPenalty

Set early withdrawal penalty in basis points.

function setEarlyExitPenalty(
    address asset,
    uint16 bps
) external onlyRole(DEFAULT_ADMIN_ROLE)

Parameters:

bps: Penalty in basis points (0-10000, e.g., 500 = 5%)

Events Reference

Agent Lifecycle

event AgentRegistered(
    address indexed owner,
    uint256 indexed agentId,
    string metadata,
    string serviceURI
);

event AgentMetadataUpdated(uint256 indexed agentId, string metadata);
event AgentServiceURIUpdated(uint256 indexed agentId, string serviceURI);
event AgentOwnershipTransferred(
    uint256 indexed agentId,
    address indexed previousOwner,
    address indexed newOwner
);

Staking Events

event StakeIncreased(
    uint256 indexed agentId,
    address indexed asset,
    address indexed staker,
    uint256 amount,
    uint256 totalStaked
);

event StakeLocked(
    uint256 indexed agentId,
    address indexed asset,
    uint256 amount,
    uint256 newLockedBalance
);

event StakeUnlocked(
    uint256 indexed agentId,
    address indexed asset,
    uint256 amount,
    uint256 newLockedBalance
);

event UnbondingInitiated(
    uint256 indexed agentId,
    address indexed asset,
    uint256 amount,
    uint64 releaseTime
);

event WithdrawalExecuted(
    uint256 indexed agentId,
    address indexed asset,
    uint256 amount,
    address indexed receiver
);

event EarlyWithdrawal(
    uint256 indexed agentId,
    address indexed asset,
    uint256 amount,
    uint256 penalty,
    address receiver
);

event StakeSlashed(
    uint256 indexed agentId,
    address indexed asset,
    uint256 amount
);

Inference Events

event InferenceRecorded(
    uint256 indexed agentId,
    bytes32 indexed inferenceId,
    bytes32 indexed inputHash,
    bytes32 outputHash,
    bytes32 modelHash,
    uint256 taskId,
    address reporter,
    string proofURI
);

event InferenceAttested(
    bytes32 indexed inferenceId,
    uint256 indexed agentId,
    uint256 indexed taskId,
    address verifier,
    bool success,
    string uri
);

Reputation Events

event ReputationAdjusted(
    uint256 indexed agentId,
    bytes32 indexed dimension,
    int256 newScore,
    string reason
);

event ReputationWeightUpdated(bytes32 indexed dimension, uint256 weight);

Delegation Events

event DelegateUpdated(
    uint256 indexed agentId,
    address indexed delegate,
    bytes32 indexed permission,
    bool enabled
);

Integration Examples

Full Agent Lifecycle

// 1. Register agent
const agentId = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("my-agent"));
await agentsContract.register(
    agentId,
    "ipfs://QmMetadata...",
    "https://api.myagent.com/v1"
);

// 2. Stake ETH
await agentsContract.stakeETH(agentId, {
    value: ethers.utils.parseEther("10")
});

// 3. Delegate inference permission to oracle
const oracleAddress = "0x5678...";
const PERMISSION_INFERENCE = await agentsContract.PERMISSION_INFERENCE();
await agentsContract.setDelegate(agentId, oracleAddress, PERMISSION_INFERENCE, true);

// 4. Record inference (as oracle)
const inferenceId = await oracleContract.recordInferenceForAgent(agentId, ...);

// 5. Verifier attests
// (Handled by verifier role account)

// 6. Check reputation
const reputation = await agentsContract.aggregatedReputation(agentId);
console.log("Agent reputation:", reputation.toString());

// 7. Request withdrawal
await agentsContract.requestWithdrawal(
    agentId,
    ethers.constants.AddressZero,
    ethers.utils.parseEther("2")
);

// 8. Wait for unbonding period...

// 9. Claim withdrawal
await agentsContract.claimWithdrawals(
    agentId,
    ethers.constants.AddressZero,
    0,
    ethers.constants.AddressZero,
    false
);

Security Considerations

Reentrancy Protection

All external functions handling value transfers are protected with nonReentrant modifier.

Access Control

Critical functions use role-based access control
Agent owners must explicitly delegate permissions
Delegation is granular (metadata, inference, withdrawal)

Upgradeability

UUPS proxy pattern for upgrades
Only DEFAULT_ADMIN_ROLE can authorize upgrades

Stake Safety

Locked stake cannot be withdrawn
Unbonding periods prevent instant exits
Early exit penalties discourage premature withdrawal

Gas Optimization Tips

Batch Withdrawals: Use maxEntries parameter to limit gas costs
Queue Management: Cancel unwanted withdrawals to avoid processing costs
Delegation: Use delegates for frequent operations instead of owner multisig
View Functions: Always use callStatic for queries to avoid unnecessary transactions

Tasks.sol - Task marketplace with agent stake locking
Treasury.sol - Receives slashed stakes and penalties
Subscriptions.sol - Recurring payments to agents

ABI & Deployment

ABI Location: /nexis-appchain/packages/contracts-bedrock/artifacts/contracts/Agents.sol/Agents.json Network Addresses:

Network	Contract Address	Explorer
Nexis Mainnet	`0x...`	View Contract
Nexis Testnet	`0x...`	View Contract

Support & Resources

GitHub: nexis-network/nexis-appchain
Discord: Nexis Community
Documentation: nex-t1.ai

Getting Started

Infrastructure

Developers

Smart Contracts

Tokenomics

Playground

Changelog

Legal

Documentation Index

​Agents.sol

​Overview

​Key Features

​Architecture

​Contract Roles

​Access Control Roles

​Delegation Permissions

​Core Data Structures

​AgentSummary

​InferenceCommitment

​StakeView

​PendingWithdrawal

​ReputationDelta

​Agent Registration & Metadata

​register

​updateMetadata

​updateServiceURI

​transferAgentOwnership

​Staking System

​stakeETH

​stakeERC20

​requestWithdrawal

​claimWithdrawals

​cancelWithdrawal

​stakeBalances

​Stake Locking (Task Integration)

​lockStake

​unlockStake

​Slashing

​slashStake

​Reputation System

​Reputation Dimensions

​adjustReputation

​aggregatedReputation

​updateReputationWeight

​Inference Recording & Verification

​recordInference

​attestInference

​getInference

​Delegation

​setDelegate

​hasDelegatedPermission

​Discovery & Aggregation

​listAgents

​aggregatedStats

​Admin Functions

​pause / unpause

​setTreasury

​setTasksContract

​setUnbondingPeriod

​setEarlyExitPenalty

​Events Reference

​Agent Lifecycle

​Staking Events

​Inference Events

​Reputation Events

​Delegation Events

​Integration Examples

​Full Agent Lifecycle

​Security Considerations

​Reentrancy Protection

​Access Control

​Upgradeability

​Stake Safety

​Gas Optimization Tips

​Related Contracts

​ABI & Deployment

​Support & Resources

Agents.sol

Overview

Key Features

Architecture

Contract Roles

Access Control Roles

Delegation Permissions

Core Data Structures

AgentSummary

InferenceCommitment

StakeView

PendingWithdrawal

ReputationDelta

Agent Registration & Metadata

register

updateMetadata

updateServiceURI

transferAgentOwnership

Staking System

stakeETH

stakeERC20

requestWithdrawal

claimWithdrawals

cancelWithdrawal

stakeBalances

Stake Locking (Task Integration)

lockStake

unlockStake

Slashing

slashStake

Reputation System

Reputation Dimensions

adjustReputation

aggregatedReputation

updateReputationWeight

Inference Recording & Verification

recordInference

attestInference

getInference

Delegation

setDelegate

hasDelegatedPermission

Discovery & Aggregation

listAgents

aggregatedStats

Admin Functions

pause / unpause

setTreasury

setTasksContract

setUnbondingPeriod

setEarlyExitPenalty

Events Reference

Agent Lifecycle

Staking Events

Inference Events

Reputation Events

Delegation Events

Integration Examples

Full Agent Lifecycle

Security Considerations

Reentrancy Protection

Access Control

Upgradeability

Stake Safety

Gas Optimization Tips

Related Contracts

ABI & Deployment

Support & Resources