/build-ai-agent

name: build-ai-agent
description: Build an AI agent that signs Sui transactions or runs onchain actions. Use when the user wants an AI agent on Sui.

Preamble (run first)

# Suiperpower telemetry. Routes through the CLI so projects.json + Convex stay in sync.
# Silent on failure so the skill never blocks. Opt out: SUIPERPOWER_TELEMETRY=off.
#
# AGENT NOTE: when this skill finishes, run the matching completion command:
#   suiperpower track build-ai-agent build completed
# Or use "failed" / "aborted" if it ended that way.
command -v suiperpower >/dev/null 2>&1 && suiperpower track build-ai-agent build started >/dev/null 2>&1 &
true

If `TEL_PROMPTED` is `no`, before doing real work, ask the user:

> Help suiperpower get better. We track which skills get used and how long they take. No code, no file paths, no PII. Change anytime in `~/.suiperpower/config.json`. > > A) Sure, anonymous > B) No thanks

Write the answer to `~/.suiperpower/config.json` `telemetryTier` field and create `~/.suiperpower/.telemetry-prompted`. Then continue.

What this skill does

Guides the user through building an AI agent that autonomously transacts on Sui. Picks the right wallet pattern, compute layer, memory system, and coordination model for the agent's use case, then wires them together with PTBs as the agent's tool-use layer. Refuses to ship an agent that cannot execute a real transaction end to end.

When to use it

• The user wants to build an AI agent that reads chain state and executes transactions.
• The user is targeting the Agentic Web track at Sui Overflow 2026.
• The user wants agent-managed wallets (zkLogin, sponsored, or server-side keypair).
• The user wants persistent agent memory via MemWal.
• The user needs verifiable AI inference via Nautilus or Atoma.
• The user wants multi-agent coordination through shared objects or events.

When NOT to use it

• If the user has not picked a project yet, use `find-next-sui-idea` first.
• If the user has not scaffolded a project, use `scaffold-project` first.
• If the user only needs zkLogin without an autonomous agent, use `sui-zk-login`.
• If the user only needs sponsored transactions without an agent, use `sponsored-transactions`.
• If the user only needs Seal encryption without an agent, use `seal-access-control`.
• If the user wants to write Move code not related to agents, use `build-with-move`.

If you activated this and the user actually wants something else, consult `skills/SKILL_ROUTER.md` and hand off.

Inputs

• A Sui project (Move package and/or TS/Python backend).
• Optional: `.suiperpower/build-context.md` from `scaffold-project`. Read it if present.
• The agent's purpose and autonomy level.

If unclear, interview the user for:

• What does the agent do in one sentence?
• Does the agent act on behalf of a user (delegated) or independently (autonomous)?
• Does the agent need persistent memory across sessions?
• Does the agent need verifiable inference (Nautilus TEE or Atoma)?
• Does the agent manage funds? If yes, what are the custody constraints?

Outputs

• Agent wallet setup (zkLogin + sponsored, server keypair, or hybrid).
• PTB composition logic for the agent's on-chain actions.
• Memory integration (MemWal) if the agent needs persistence.
• Compute integration (Nautilus or Atoma) if the agent needs inference.
• Coordination layer (shared objects, events) if multi-agent.
• Append to `.suiperpower/build-context.md`:

  ## build-ai-agent session, <timestamp>
  - agent purpose: <one sentence>
  - wallet pattern: <zkLogin+sponsored | keypair | hybrid>
  - compute: <Nautilus | Atoma | local | none>
  - memory: <MemWal | custom | none>
  - coordination: <shared objects | events | none>
  - packages added: <list>
  - open issues: <list>

Decision table: pick agent architecture

| Use case | Wallet | Compute | Memory | Coordination | |---|---|---|---|---| | Trading bot (server-side) | Ed25519 keypair | Atoma or local LLM | MemWal | Events for signals | | User-facing assistant | zkLogin + Enoki sponsored | Atoma API | MemWal | None | | Data marketplace agent | zkLogin + sponsored | Nautilus TEE | Walrus blobs | Shared object registry | | Multi-agent swarm | Keypair per agent | Atoma | MemWal per agent | Shared objects as bulletin boards | | Privacy-preserving agent | zkLogin | Nautilus TEE + Seal | MemWal (encrypted) | Events, Seal-gated | | Game NPC / autonomous entity | Keypair (server) | Local or Atoma | MemWal | Shared game state objects |

Confirm the architecture with the user before writing code. If the use case does not fit a row, compose from the columns.

Workflow

1. **Context gathering**

• Read `.suiperpower/build-context.md` if it exists.
• Confirm the agent's purpose in one sentence.
• Determine autonomy level: delegated (user approves each action) vs fully autonomous.

2. **Pick architecture**

• Walk through the decision table above with the user.
• Confirm wallet, compute, memory, and coordination choices.
• If the agent manages real funds, require explicit discussion of custody risk, loss bounds, and kill switches.

3. **Wallet setup**

• **zkLogin + sponsored**: Use Enoki for sponsored transactions, zkLogin for ephemeral keys. Agent creates a wallet per session, transacts without holding SUI. See `sui-zk-login` and `sponsored-transactions` skills for detail.
• **Server keypair**: Generate Ed25519 keypair via `@mysten/sui/keypairs/ed25519`. Store the private key in env or KMS, never in source. Fund with SUI for gas.
• **Hybrid**: zkLogin for user-facing flows, keypair for server-side autonomous actions.

4. **PTB composition (agent tool use)**

• Each agent action maps to a PTB. Up to 1,024 Move calls per transaction, outputs chain between commands via `NestedResult`.
• Pattern: agent reads state (dry run or RPC query), decides action, composes PTB, signs, executes.
• Use `Transaction` from `@mysten/sui/transactions`. Compose multi-st