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 → RetireEach 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:
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
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.
Last updated