> For the complete documentation index, see [llms.txt](https://docs.talus.network/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.talus.network/reference/move/nexus_interface/agent.md).

# agent

* [Struct `Agent`](#struct-agent)
* [Struct `AgentInnerV1`](#struct-agentinnerv1)
* [Struct `AgentExecutionConfig`](#struct-agentexecutionconfig)
* [Struct `AgentVaultFieldKey`](#struct-agentvaultfieldkey)
* [Struct `FixedTool`](#struct-fixedtool)
* [Struct `SkillRequirement`](#struct-skillrequirement)
* [Struct `ExecutionSpec`](#struct-executionspec)
* [Struct `AgentPaymentVault`](#struct-agentpaymentvault)
* [Struct `AgentPaymentVaultInnerV1`](#struct-agentpaymentvaultinnerv1)
* [Struct `AgentCreatedEvent`](#struct-agentcreatedevent)
* [Enum `SkillDagBinding`](#enum-skilldagbinding)
* [Enum `ExecutionSelection`](#enum-executionselection)
* [Enum `SkillSchedulePolicy`](#enum-skillschedulepolicy)
* [Constants](#constants)
* [Function `create_agent_identity`](#function-create_agent_identity)
* [Function `allocate_skill_id`](#function-allocate_skill_id)
* [Function `assert_agent_registry_authorized`](#function-assert_agent_registry_authorized)
* [Function `bind_agent_registry`](#function-bind_agent_registry)
* [Function `agent_next_skill_id`](#function-agent_next_skill_id)
* [Function `requirements_payment_policy`](#function-requirements_payment_policy)
* [Function `requirements_schedule_policy`](#function-requirements_schedule_policy)
* [Function `requirements_input_commitment`](#function-requirements_input_commitment)
* [Function `requirements_fixed_tools`](#function-requirements_fixed_tools)
* [Function `fixed_tool`](#function-fixed_tool)
* [Function `fixed_tool_registry_id`](#function-fixed_tool_registry_id)
* [Function `fixed_tool_fqn`](#function-fixed_tool_fqn)
* [Function `execution_selection_agent_skill`](#function-execution_selection_agent_skill)
* [Function `execution_selection_default_agent`](#function-execution_selection_default_agent)
* [Function `execution_selection_agent_id`](#function-execution_selection_agent_id)
* [Function `execution_selection_skill_id`](#function-execution_selection_skill_id)
* [Function `execution_selection_default_agent_dag_id`](#function-execution_selection_default_agent_dag_id)
* [Function `new_default_agent_execution_config`](#function-new_default_agent_execution_config)
* [Function `new_agent_execution_config`](#function-new_agent_execution_config)
* [Function `agent_execution_config_dag_id`](#function-agent_execution_config_dag_id)
* [Function `agent_execution_config_skill_id`](#function-agent_execution_config_skill_id)
* [Function `agent_execution_config_selected_dag`](#function-agent_execution_config_selected_dag)
* [Function `agent_execution_config_agent_id`](#function-agent_execution_config_agent_id)
* [Function `agent_execution_config_is_default`](#function-agent_execution_config_is_default)
* [Function `destroy_agent_execution_config`](#function-destroy_agent_execution_config)
* [Function `execution_spec`](#function-execution_spec)
* [Function `execution_spec_dag_id`](#function-execution_spec_dag_id)
* [Function `execution_spec_agent_id`](#function-execution_spec_agent_id)
* [Function `execution_spec_skill_id`](#function-execution_spec_skill_id)
* [Function `execution_spec_interface_version`](#function-execution_spec_interface_version)
* [Function `execution_spec_network`](#function-execution_spec_network)
* [Function `execution_spec_entry_group`](#function-execution_spec_entry_group)
* [Function `execution_spec_inputs`](#function-execution_spec_inputs)
* [Function `execution_spec_invoker`](#function-execution_spec_invoker)
* [Function `new_task_vertex_authorization_grants`](#function-new_task_vertex_authorization_grants)
* [Function `new_task_components_address_funded_with_grants`](#function-new_task_components_address_funded_with_grants)
* [Function `new_task_components_from_agent_vault_with_grants`](#function-new_task_components_from_agent_vault_with_grants)
* [Function `assert_canonical_fixed_tools`](#function-assert_canonical_fixed_tools)
* [Function `cancel_task_reserve_to_vault`](#function-cancel_task_reserve_to_vault)
* [Function `refill_task_reserve_from_vault`](#function-refill_task_reserve_from_vault)
* [Function `deposit_agent_payment_vault`](#function-deposit_agent_payment_vault)
* [Function `refill_execution_payment_from_agent_vault_balance`](#function-refill_execution_payment_from_agent_vault_balance)
* [Function `withdraw_agent_payment_vault`](#function-withdraw_agent_payment_vault)
* [Function `dag_binding_pinned`](#function-dag_binding_pinned)
* [Function `dag_binding_runtime_selected`](#function-dag_binding_runtime_selected)
* [Function `dag_binding_is_runtime_selected`](#function-dag_binding_is_runtime_selected)
* [Function `dag_binding_pinned_dag_id`](#function-dag_binding_pinned_dag_id)
* [Function `agent_payment_vault_id`](#function-agent_payment_vault_id)
* [Function `agent_payment_vault_agent_id`](#function-agent_payment_vault_agent_id)
* [Function `agent_payment_vault_available_balance`](#function-agent_payment_vault_available_balance)
* [Function `skill_requirements`](#function-skill_requirements)
* [Function `schedule_once`](#function-schedule_once)
* [Function `schedule_recurring`](#function-schedule_recurring)
* [Function `schedule_policy_allows_recurrence`](#function-schedule_policy_allows_recurrence)
* [Function `schedule_policy_min_interval_ms`](#function-schedule_policy_min_interval_ms)
* [Function `schedule_policy_max_occurrences`](#function-schedule_policy_max_occurrences)

### Struct `Agent`

Keyed on-chain Talus agent identity object.

Custody of this object controls access to agent-owned dynamic object children such as the standard payment vault.

```move
public struct Agent has key, store
```

<details>

<summary>Fields</summary>

`id: sui::object::UID`

</details>

#### Struct `AgentInnerV1`

Version one stored layout for \[[`Agent`](#nexus_interface_agent_Agent)].

The stable \[[`Agent`](#nexus_interface_agent_Agent)] cannot contain these fields because its published layout must remain unchanged while stored data evolves.

```move
public struct AgentInnerV1 has store
```

<details>

<summary>Fields</summary>

`next_skill_id: u64registry_id: std::option::Option<sui::object::ID>`

</details>

#### Struct `AgentExecutionConfig`

Caller-authored runtime intent for DAG execution through an agent selection.

```move
public struct AgentExecutionConfig has copy, drop, store
```

<details>

<summary>Fields</summary>

`selection:` [`nexus_interface::agent::ExecutionSelection`](#nexus_interface_agent_ExecutionSelection)`network: sui::object::IDentry_group:` [`nexus_interface::graph::EntryGroup`](/reference/move/nexus_interface/graph.md#nexus_interface_graph_EntryGroup)`inputs: sui::vec_map::VecMap<`[`nexus_interface::graph::Vertex`](/reference/move/nexus_interface/graph.md#nexus_interface_graph_Vertex)`, sui::vec_map::VecMap<`[`nexus_interface::graph::InputPort`](/reference/move/nexus_interface/graph.md#nexus_interface_graph_InputPort)`,` [`nexus_primitives::data::NexusData`](/reference/move/nexus_primitives/data.md#nexus_primitives_data_NexusData)`>>invoker: addressauthorization_bindings: sui::vec_map::VecMap<`[`nexus_interface::graph::Vertex`](/reference/move/nexus_interface/graph.md#nexus_interface_graph_Vertex)`, sui::object::ID>`

</details>

#### Struct `AgentVaultFieldKey`

Dynamic object field key for the standard agent payment vault.

```move
public struct AgentVaultFieldKey has copy, drop, store
```

<details>

<summary>Fields</summary>

</details>

#### Struct `FixedTool`

Fixed-tool requirement storing the Tool registry ID and fully-qualified name recorded by a skill. Registration checks the FQN's current ToolRegistry presence; clients and operators must separately read back the selected DAG vertex, Tool ID, registry ID, and schema.

```move
public struct FixedTool has copy, drop, store
```

<details>

<summary>Fields</summary>

`tool_registry_id: sui::object::IDtool_fqn: std::ascii::String`

</details>

#### Struct `SkillRequirement`

Skill requirements committed by the current skill revision.

```move
public struct SkillRequirement has copy, drop, store
```

<details>

<summary>Fields</summary>

`input_commitment: vector<u8>payment_policy:` [`nexus_interface::payment::SkillPaymentPolicy`](/reference/move/nexus_interface/payment.md#nexus_interface_payment_SkillPaymentPolicy)`schedule_policy:` [`nexus_interface::agent::SkillSchedulePolicy`](#nexus_interface_agent_SkillSchedulePolicy)`fixed_tools: vector<`[`nexus_interface::agent::FixedTool`](#nexus_interface_agent_FixedTool)`>`

</details>

#### Struct `ExecutionSpec`

Resolved execution target retained by a durable scheduler Task.

\[[`AgentExecutionConfig`](#nexus_interface_agent_AgentExecutionConfig)] is caller intent. \[[`ExecutionSpec`](#nexus_interface_agent_ExecutionSpec)] is the registry validated target after agent, skill, DAG, and interface resolution.

```move
public struct ExecutionSpec has copy, drop, store
```

<details>

<summary>Fields</summary>

`dag_id: sui::object::IDagent_id: sui::object::IDskill_id: u64interface_version:` [`nexus_interface::version::InterfaceVersion`](/reference/move/nexus_interface/version.md#nexus_interface_version_InterfaceVersion)`network: sui::object::IDentry_group:` [`nexus_interface::graph::EntryGroup`](/reference/move/nexus_interface/graph.md#nexus_interface_graph_EntryGroup)`inputs: sui::vec_map::VecMap<`[`nexus_interface::graph::Vertex`](/reference/move/nexus_interface/graph.md#nexus_interface_graph_Vertex)`, sui::vec_map::VecMap<`[`nexus_interface::graph::InputPort`](/reference/move/nexus_interface/graph.md#nexus_interface_graph_InputPort)`,` [`nexus_primitives::data::NexusData`](/reference/move/nexus_primitives/data.md#nexus_primitives_data_NexusData)`>>invoker: address`

</details>

#### Struct `AgentPaymentVault`

Standard balance holder for agent-funded TAP execution.

The vault is created with every agent as a dynamic object child. Deposits are permissionless, while withdrawals go through registry-mediated agent custody. Active `payment_interface::ExecutionPayment`s split their locked SUI out of the vault at creation. The vault exposes only its available balance; execution locks are held by their ExecutionPayment objects.

```move
public struct AgentPaymentVault has key, store
```

<details>

<summary>Fields</summary>

`id: sui::object::UID`

</details>

#### Struct `AgentPaymentVaultInnerV1`

Version one stored layout for \[[`AgentPaymentVault`](#nexus_interface_agent_AgentPaymentVault)].

The stable \[[`AgentPaymentVault`](#nexus_interface_agent_AgentPaymentVault)] cannot contain these fields because its published layout must remain unchanged while stored data evolves.

```move
public struct AgentPaymentVaultInnerV1 has store
```

<details>

<summary>Fields</summary>

`agent_id: sui::object::IDavailable_balance: sui::balance::Balance<sui::sui::SUI>`

</details>

#### Struct `AgentCreatedEvent`

Emitted when a new agent identity and its payment vault are created.

```move
public struct AgentCreatedEvent has copy, drop
```

<details>

<summary>Fields</summary>

`agent_id: sui::object::IDvault_id: address`

</details>

#### Enum `SkillDagBinding`

Binding between a TAP skill and DAG selection.

Ordinary skills pin one DAG. The default skill may use `RuntimeSelected`, but the selected DAG must still be committed in execution evidence.

```move
public enum SkillDagBinding has copy, drop, store
```

<details>

<summary>Variants</summary>

Variant `Pinneddag_id: address`Variant `RuntimeSelected`

</details>

#### Enum `ExecutionSelection`

Selects either a registered Agent skill or the registry-owned default Agent for one DAG execution.

```move
public enum ExecutionSelection has copy, drop, store
```

<details>

<summary>Variants</summary>

Variant `AgentSkillagent_id: sui::object::IDskill_id: u64selected_dag: std::option::Option<sui::object::ID>`Variant `DefaultAgentdag_id: sui::object::ID`

</details>

#### Enum `SkillSchedulePolicy`

Scheduling limits committed by one skill revision.

```move
public enum SkillSchedulePolicy has copy, drop, store
```

<details>

<summary>Variants</summary>

Variant `Once`Variant `Recurringmin_interval_ms: u64max_occurrences: std::option::Option<u64>`

</details>

#### Constants

```move
#[error]
const EInvalidPaymentPolicy: vector<u8> = b"TAP payment policy is invalid";
```

```move
#[error]
const EInvalidSchedulePolicy: vector<u8> = b"TAP schedule policy is invalid";
```

```move
#[error]
const EFixedToolDuplicate: vector<u8> = b"TAP fixed tool is duplicated";
```

```move
#[error]
const EInsufficientVaultBalance: vector<u8> = b"Talus agent payment vault balance is insufficient";
```

```move
#[error]
const EVaultAgentMismatch: vector<u8> = b"Talus agent payment vault does not belong to agent";
```

```move
#[error]
const ERegistryAuthorityMismatch: vector<u8> = b"TAP agent is not bound to the provided registry authority";
```

```move
#[error]
const EAgentExecutionSkillRequired: vector<u8> = b"Agent execution config does not include an agent skill";
```

```move
#[error]
const EDefaultAgentExecutionRequired: vector<u8> = b"Agent execution config does not select the default agent";
```

#### Function `create_agent_identity`

Create the on-chain identity object for one Talus agent.

The function initializes the Agent payment vault. Registry code is responsible for checking mutable agent custody before exposing this identity as an agent record.

```move
public fun create_agent_identity(ctx: &mut sui::tx_context::TxContext): nexus_interface::agent::Agent
```

#### Function `allocate_skill_id`

Allocate the next agent-local skill index.

Only code with mutable access to [`Agent`](#nexus_interface_agent_Agent) can allocate, preventing external callers from forging skill IDs for an agent they do not control.

```move
public fun allocate_skill_id(agent: &mut nexus_interface::agent::Agent): u64
```

#### Function `assert_agent_registry_authorized`

Validate that the caller is the registry bound to this agent.

```move
public fun assert_agent_registry_authorized(agent: &nexus_interface::agent::Agent, registry_authority: &sui::object::UID)
```

#### Function `bind_agent_registry`

Bind an agent identity to the registry that controls its skill metadata.

Only code that can borrow the registry UID later can register or update skills.

```move
public fun bind_agent_registry(agent: &mut nexus_interface::agent::Agent, registry_id: &sui::object::UID)
```

#### Function `agent_next_skill_id`

Returns the next skill index that would be allocated for this agent.

```move
public fun agent_next_skill_id(agent: &nexus_interface::agent::Agent): u64
```

#### Function `requirements_payment_policy`

Returns the payment policy committed by these skill requirements.

```move
public fun requirements_payment_policy(requirements: nexus_interface::agent::SkillRequirement): nexus_interface::payment::SkillPaymentPolicy
```

#### Function `requirements_schedule_policy`

Returns the schedule policy committed by these skill requirements.

```move
public fun requirements_schedule_policy(requirements: nexus_interface::agent::SkillRequirement): nexus_interface::agent::SkillSchedulePolicy
```

#### Function `requirements_input_commitment`

Returns the input commitment bytes committed by these skill requirements.

```move
public fun requirements_input_commitment(requirements: nexus_interface::agent::SkillRequirement): vector<u8>
```

#### Function `requirements_fixed_tools`

Returns the fixed-tool requirements recorded by these skill requirements.

```move
public fun requirements_fixed_tools(requirements: nexus_interface::agent::SkillRequirement): vector<nexus_interface::agent::FixedTool>
```

#### Function `fixed_tool`

Constructs a fixed tool identity from its registry ID and fully-qualified name.

```move
public fun fixed_tool(tool_registry_id: sui::object::ID, tool_fqn: std::ascii::String): nexus_interface::agent::FixedTool
```

#### Function `fixed_tool_registry_id`

Returns the tool registry ID of a fixed tool.

```move
public fun fixed_tool_registry_id(tool: nexus_interface::agent::FixedTool): sui::object::ID
```

#### Function `fixed_tool_fqn`

Returns the fully-qualified name of a fixed tool.

```move
public fun fixed_tool_fqn(tool: nexus_interface::agent::FixedTool): std::ascii::String
```

#### Function `execution_selection_agent_skill`

Constructs an execution selection targeting a specific agent skill.

```move
public fun execution_selection_agent_skill(agent_id: sui::object::ID, skill_id: u64, selected_dag: std::option::Option<sui::object::ID>): nexus_interface::agent::ExecutionSelection
```

#### Function `execution_selection_default_agent`

Constructs an execution selection targeting the default agent for a DAG.

```move
public fun execution_selection_default_agent(dag_id: sui::object::ID): nexus_interface::agent::ExecutionSelection
```

#### Function `execution_selection_agent_id`

Returns the agent ID of an agent-skill execution selection.

Aborts with [`EAgentExecutionSkillRequired`](#nexus_interface_agent_EAgentExecutionSkillRequired) if the selection is a default-agent selection.

```move
public fun execution_selection_agent_id(selection: &nexus_interface::agent::ExecutionSelection): sui::object::ID
```

#### Function `execution_selection_skill_id`

Returns the skill ID of an agent-skill execution selection.

Aborts with [`EAgentExecutionSkillRequired`](#nexus_interface_agent_EAgentExecutionSkillRequired) if the selection is a default-agent selection.

```move
public fun execution_selection_skill_id(selection: &nexus_interface::agent::ExecutionSelection): u64
```

#### Function `execution_selection_default_agent_dag_id`

Returns the DAG ID of a default-agent execution selection.

Aborts with [`EDefaultAgentExecutionRequired`](#nexus_interface_agent_EDefaultAgentExecutionRequired) if the selection is an agent-skill selection.

```move
public fun execution_selection_default_agent_dag_id(selection: &nexus_interface::agent::ExecutionSelection): sui::object::ID
```

#### Function `new_default_agent_execution_config`

Builds an execution config that runs a DAG through the default agent.

The invoker is recorded as the transaction sender.

```move
public fun new_default_agent_execution_config(dag: sui::object::ID, network: sui::object::ID, entry_group: nexus_interface::graph::EntryGroup, inputs: sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::vec_map::VecMap<nexus_interface::graph::InputPort, nexus_primitives::data::NexusData>>, ctx: &mut sui::tx_context::TxContext): nexus_interface::agent::AgentExecutionConfig
```

#### Function `new_agent_execution_config`

Builds an execution config that runs a DAG through a specific agent skill.

The invoker is recorded as the transaction sender.

```move
public fun new_agent_execution_config(agent_id: sui::object::ID, network: sui::object::ID, entry_group: nexus_interface::graph::EntryGroup, inputs: sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::vec_map::VecMap<nexus_interface::graph::InputPort, nexus_primitives::data::NexusData>>, skill_id: u64, selected_dag: std::option::Option<sui::object::ID>, authorization_bindings: sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::object::ID>, ctx: &mut sui::tx_context::TxContext): nexus_interface::agent::AgentExecutionConfig
```

#### Function `agent_execution_config_dag_id`

Returns the DAG ID of a default-agent execution config.

Aborts with [`EDefaultAgentExecutionRequired`](#nexus_interface_agent_EDefaultAgentExecutionRequired) if the config targets an agent skill.

```move
public fun agent_execution_config_dag_id(self: &nexus_interface::agent::AgentExecutionConfig): sui::object::ID
```

#### Function `agent_execution_config_skill_id`

Returns the skill ID of an agent-skill execution config.

Aborts with [`EAgentExecutionSkillRequired`](#nexus_interface_agent_EAgentExecutionSkillRequired) if the config targets the default agent.

```move
public fun agent_execution_config_skill_id(self: &nexus_interface::agent::AgentExecutionConfig): u64
```

#### Function `agent_execution_config_selected_dag`

Returns the runtime-selected DAG of an agent-skill execution config, if any.

Aborts with [`EAgentExecutionSkillRequired`](#nexus_interface_agent_EAgentExecutionSkillRequired) if the config targets the default agent.

```move
public fun agent_execution_config_selected_dag(self: &nexus_interface::agent::AgentExecutionConfig): std::option::Option<sui::object::ID>
```

#### Function `agent_execution_config_agent_id`

Returns the agent ID of an agent-skill execution config.

Aborts with [`EAgentExecutionSkillRequired`](#nexus_interface_agent_EAgentExecutionSkillRequired) if the config targets the default agent.

```move
public fun agent_execution_config_agent_id(self: &nexus_interface::agent::AgentExecutionConfig): sui::object::ID
```

#### Function `agent_execution_config_is_default`

Returns whether caller intent selects the default Agent.

```move
public fun agent_execution_config_is_default(self: &nexus_interface::agent::AgentExecutionConfig): bool
```

#### Function `destroy_agent_execution_config`

Consumes an execution config and returns its component fields.

```move
public fun destroy_agent_execution_config(self: nexus_interface::agent::AgentExecutionConfig): (sui::object::ID, nexus_interface::graph::EntryGroup, sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::vec_map::VecMap<nexus_interface::graph::InputPort, nexus_primitives::data::NexusData>>, address, nexus_interface::agent::ExecutionSelection, sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::object::ID>)
```

#### Function `execution_spec`

Creates a durable execution target after registry validation.

```move
public fun execution_spec(dag_id: sui::object::ID, agent_id: sui::object::ID, skill_id: u64, interface_version: nexus_interface::version::InterfaceVersion, network: sui::object::ID, entry_group: nexus_interface::graph::EntryGroup, inputs: sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::vec_map::VecMap<nexus_interface::graph::InputPort, nexus_primitives::data::NexusData>>, invoker: address): nexus_interface::agent::ExecutionSpec
```

#### Function `execution_spec_dag_id`

Returns the DAG pinned by \[[`ExecutionSpec`](#nexus_interface_agent_ExecutionSpec)].

```move
public fun execution_spec_dag_id(self: &nexus_interface::agent::ExecutionSpec): sui::object::ID
```

#### Function `execution_spec_agent_id`

Returns the agent pinned by \[[`ExecutionSpec`](#nexus_interface_agent_ExecutionSpec)].

```move
public fun execution_spec_agent_id(self: &nexus_interface::agent::ExecutionSpec): sui::object::ID
```

#### Function `execution_spec_skill_id`

Returns the skill pinned by \[[`ExecutionSpec`](#nexus_interface_agent_ExecutionSpec)].

```move
public fun execution_spec_skill_id(self: &nexus_interface::agent::ExecutionSpec): u64
```

#### Function `execution_spec_interface_version`

Returns the interface revision pinned by \[[`ExecutionSpec`](#nexus_interface_agent_ExecutionSpec)].

```move
public fun execution_spec_interface_version(self: &nexus_interface::agent::ExecutionSpec): nexus_interface::version::InterfaceVersion
```

#### Function `execution_spec_network`

Returns the leader network pinned by \[[`ExecutionSpec`](#nexus_interface_agent_ExecutionSpec)].

```move
public fun execution_spec_network(self: &nexus_interface::agent::ExecutionSpec): sui::object::ID
```

#### Function `execution_spec_entry_group`

Returns the entry group pinned by \[[`ExecutionSpec`](#nexus_interface_agent_ExecutionSpec)].

```move
public fun execution_spec_entry_group(self: &nexus_interface::agent::ExecutionSpec): nexus_interface::graph::EntryGroup
```

#### Function `execution_spec_inputs`

Returns the input values pinned by \[[`ExecutionSpec`](#nexus_interface_agent_ExecutionSpec)].

```move
public fun execution_spec_inputs(self: &nexus_interface::agent::ExecutionSpec): sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::vec_map::VecMap<nexus_interface::graph::InputPort, nexus_primitives::data::NexusData>>
```

#### Function `execution_spec_invoker`

Returns the invoker recorded by \[[`ExecutionSpec`](#nexus_interface_agent_ExecutionSpec)].

```move
public fun execution_spec_invoker(self: &nexus_interface::agent::ExecutionSpec): address
```

#### Function `new_task_vertex_authorization_grants`

Builds vertex authorization grants for a Task.

```move
public fun new_task_vertex_authorization_grants(agent: &nexus_interface::agent::Agent, dag_id: sui::object::ID, skill_id: u64, interface_version: nexus_interface::version::InterfaceVersion, task_id: sui::object::ID, authorization_bindings: sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::object::ID>): vector<nexus_primitives::authorization::Grant<nexus_interface::authorization::AgentVertexAuthorization>>
```

#### Function `new_task_components_address_funded_with_grants`

Builds the authorization and user funded reserve for a Task.

```move
public fun new_task_components_address_funded_with_grants(agent: &nexus_interface::agent::Agent, interface_revision: nexus_interface::version::InterfaceVersion, payment_policy: nexus_interface::payment::SkillPaymentPolicy, task_id: sui::object::ID, skill_id: u64, prepayment: sui::coin::Coin<sui::sui::SUI>, refund_recipient: address, occurrence_budget_mist: u64, dag_id: sui::object::ID, authorization_bindings: sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::object::ID>, ctx: &mut sui::tx_context::TxContext): (nexus_interface::authorization::AgentSkillAuthorization, nexus_interface::payment::TaskPaymentReserve)
```

#### Function `new_task_components_from_agent_vault_with_grants`

Builds the authorization and Agent funded reserve for a Task.

```move
public fun new_task_components_from_agent_vault_with_grants(agent: &mut nexus_interface::agent::Agent, interface_revision: nexus_interface::version::InterfaceVersion, payment_policy: nexus_interface::payment::SkillPaymentPolicy, task_id: sui::object::ID, skill_id: u64, prepay_amount_mist: u64, occurrence_budget_mist: u64, dag_id: sui::object::ID, authorization_bindings: sui::vec_map::VecMap<nexus_interface::graph::Vertex, sui::object::ID>, ctx: &mut sui::tx_context::TxContext): (nexus_interface::authorization::AgentSkillAuthorization, nexus_interface::payment::TaskPaymentReserve)
```

#### Function `assert_canonical_fixed_tools`

Asserts that a fixed-tool list contains no duplicate entries.

Aborts with [`EFixedToolDuplicate`](#nexus_interface_agent_EFixedToolDuplicate) if two entries share both registry ID and FQN.

```move
public fun assert_canonical_fixed_tools(fixed_tools: &vector<nexus_interface::agent::FixedTool>)
```

#### Function `cancel_task_reserve_to_vault`

Cancels a scheduled payment reserve and returns its remaining funds to the agent vault.

Aborts with [`EVaultAgentMismatch`](#nexus_interface_agent_EVaultAgentMismatch) if the reserve or vault does not belong to the agent.

```move
public fun cancel_task_reserve_to_vault(agent: &mut nexus_interface::agent::Agent, reserve: &mut nexus_interface::payment::TaskPaymentReserve)
```

#### Function `refill_task_reserve_from_vault`

Refills an agent funded Task reserve from its owning vault.

```move
public fun refill_task_reserve_from_vault(agent: &mut nexus_interface::agent::Agent, reserve: &mut nexus_interface::payment::TaskPaymentReserve, amount: u64)
```

#### Function `deposit_agent_payment_vault`

Deposit SUI into an agent payment vault. Any sender may fund a vault.

```move
public fun deposit_agent_payment_vault(agent: &mut nexus_interface::agent::Agent, coin: sui::coin::Coin<sui::sui::SUI>)
```

#### Function `refill_execution_payment_from_agent_vault_balance`

Refill an agent-funded execution payment by withdrawing from the owning agent vault.

```move
public fun refill_execution_payment_from_agent_vault_balance(agent: &mut nexus_interface::agent::Agent, payment: &mut nexus_interface::payment::ExecutionPayment, amount: u64): u64
```

#### Function `withdraw_agent_payment_vault`

Withdraw spendable SUI from an agent payment vault.

Registry wrappers choose the authorization policy. Active execution funds are held in their separate `ExecutionPayment`; creation splits them from the vault, so the stored vault balance is spendable.

```move
public fun withdraw_agent_payment_vault(agent: &mut nexus_interface::agent::Agent, amount: u64, ctx: &mut sui::tx_context::TxContext): sui::coin::Coin<sui::sui::SUI>
```

#### Function `dag_binding_pinned`

Constructs a skill DAG binding pinned to a specific DAG.

```move
public fun dag_binding_pinned(dag_id: address): nexus_interface::agent::SkillDagBinding
```

#### Function `dag_binding_runtime_selected`

Constructs a skill DAG binding whose DAG is selected at runtime.

```move
public fun dag_binding_runtime_selected(): nexus_interface::agent::SkillDagBinding
```

#### Function `dag_binding_is_runtime_selected`

Returns whether a skill DAG binding selects its DAG at runtime.

```move
public fun dag_binding_is_runtime_selected(binding: nexus_interface::agent::SkillDagBinding): bool
```

#### Function `dag_binding_pinned_dag_id`

Returns the pinned DAG ID of a binding, or `none` when the DAG is runtime-selected.

```move
public fun dag_binding_pinned_dag_id(binding: nexus_interface::agent::SkillDagBinding): std::option::Option<address>
```

#### Function `agent_payment_vault_id`

Returns the object address of the agent's payment vault.

```move
public fun agent_payment_vault_id(agent: &nexus_interface::agent::Agent): address
```

#### Function `agent_payment_vault_agent_id`

Returns the agent ID recorded in the agent's payment vault.

```move
public fun agent_payment_vault_agent_id(agent: &nexus_interface::agent::Agent): sui::object::ID
```

#### Function `agent_payment_vault_available_balance`

Returns the spendable SUI balance of the agent's payment vault. Active execution funds are not in this stored vault balance.

```move
public fun agent_payment_vault_available_balance(agent: &nexus_interface::agent::Agent): u64
```

#### Function `skill_requirements`

Constructs the input, payment, scheduling, and fixed-Tool requirements committed by a skill revision.

```move
public fun skill_requirements(input_commitment: vector<u8>, payment_policy: nexus_interface::payment::SkillPaymentPolicy, schedule_policy: nexus_interface::agent::SkillSchedulePolicy, fixed_tools: vector<nexus_interface::agent::FixedTool>): nexus_interface::agent::SkillRequirement
```

#### Function `schedule_once`

Creates a policy that permits exactly one dispatched occurrence.

```move
public fun schedule_once(): nexus_interface::agent::SkillSchedulePolicy
```

#### Function `schedule_recurring`

Creates a recurring policy with a minimum interval and optional total cap.

Aborts with [`EInvalidSchedulePolicy`](#nexus_interface_agent_EInvalidSchedulePolicy) if `min_interval_ms` is zero or a supplied `max_occurrences` is zero.

```move
public fun schedule_recurring(min_interval_ms: u64, max_occurrences: std::option::Option<u64>): nexus_interface::agent::SkillSchedulePolicy
```

#### Function `schedule_policy_allows_recurrence`

Returns whether \[[`SkillSchedulePolicy`](#nexus_interface_agent_SkillSchedulePolicy)] permits recurrence.

```move
public fun schedule_policy_allows_recurrence(policy: nexus_interface::agent::SkillSchedulePolicy): bool
```

#### Function `schedule_policy_min_interval_ms`

Returns the minimum dispatch interval.

```move
public fun schedule_policy_min_interval_ms(policy: nexus_interface::agent::SkillSchedulePolicy): u64
```

#### Function `schedule_policy_max_occurrences`

Returns the total dispatch cap.

```move
public fun schedule_policy_max_occurrences(policy: nexus_interface::agent::SkillSchedulePolicy): std::option::Option<u64>
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.talus.network/reference/move/nexus_interface/agent.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `build a script that syncs our docs to a CMS` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.