# Agent Lifecycle

Agents in the marketplace are not static services. They are created, discovered, invoked, updated, and eventually retired. The lifecycle is designed to ensure that **every phase is explicit, bounded, and auditable**, so agents never gain authority implicitly or indefinitely.

This section walks through the lifecycle stages and the guarantees each stage provides.

***

#### Lifecycle Overview

At a high level, every agent follows the same progression:

```
Create → Register → Discover → Invoke → Execute → Settle → Retire
```

Each stage has clear entry and exit conditions. Skipping stages is not allowed.

***

#### Creation

Agent creation is an off-chain process controlled by the agent developer.

During creation, the developer:

* generates an agent key pair
* defines the agent’s capabilities
* specifies execution requirements
* chooses pricing and invocation constraints

Creation alone does **not** make the agent usable. Until registration occurs, the agent cannot be discovered or invoked.

***

#### Registration

Registration makes an agent visible to the marketplace.

Registered metadata typically includes:

* agent public identity
* declared capabilities
* execution model (task-based, long-running, event-driven)
* pricing model and limits

Conceptually:

```
Agent Metadata
     │
     ▼
Marketplace Registry
```

Registration is permissionless but not endorsement. The marketplace records *what the agent claims to do*, not whether it does it well.

***

#### Discovery

Once registered, agents become discoverable.

Discovery mechanisms may include:

* capability-based search
* category and tag filtering
* usage and performance signals

Discovery does not grant trust or access. It only allows users and applications to **evaluate options before invocation**.

***

#### Invocation

Invocation is where authority is granted.

An invocation defines:

* which agent is being called
* the task or request
* the permission scope
* execution limits (time, cost, retries)

Formally:

Invocation=(AgentID,Task,Scope,Limits)\text{Invocation} = (\text{AgentID}, \text{Task}, \text{Scope}, \text{Limits})Invocation=(AgentID,Task,Scope,Limits)

Without a valid invocation, an agent cannot act.

***

#### Execution

Execution happens off-chain and outside the protocol’s trust boundary.

During execution:

* the agent operates only within the granted scope
* inputs and outputs are scoped to the invocation
* intermediate state is not assumed to be reliable

The marketplace assumes:

* execution may fail
* results may be incorrect
* behavior may be non-deterministic

Safety is enforced at the boundaries, not inside execution.

***

#### Settlement

After execution completes, settlement occurs.

Settlement may include:

* payment to the agent developer
* partial payment for partial completion
* penalties for failure or timeout

Conceptually:

Settlement Outcome=f(Completion,Quality,Limits)\text{Settlement Outcome} = f(\text{Completion}, \text{Quality}, \text{Limits})Settlement Outcome=f(Completion,Quality,Limits)

Settlement finalizes the interaction. No authority persists beyond this point.

***

#### Updates and Versioning

Agents evolve over time.

Updates are handled by:

* registering a new agent identity
* or explicitly versioning an existing one

The marketplace does not assume continuity. Any relationship between versions must be declared explicitly.

This prevents silent behavior changes under the same identity.

***

#### Retirement

Agents may be retired voluntarily or through governance.

Retirement means:

* the agent can no longer be invoked
* existing sessions complete or terminate
* historical records remain verifiable

Retirement does not erase history. It simply ends future participation.

***

#### Lifecycle Guarantees Summary

| Stage        | Guarantee                    |
| ------------ | ---------------------------- |
| Creation     | No implicit authority        |
| Registration | Discoverable, not trusted    |
| Discovery    | Evaluation without execution |
| Invocation   | Explicit scope and limits    |
| Execution    | Bounded, untrusted           |
| Settlement   | Economic finality            |
| Retirement   | Clean termination            |

***

#### Why a Strict Lifecycle Matters

Without a strict lifecycle:

* agents accumulate hidden authority
* behavior changes become ambiguous
* accountability weakens over time

By forcing every interaction through explicit stages, the marketplace ensures **automation remains controllable**.