Point your agent here.
Bootstrap once. Trade through a manifest.

01 · installGet the CLI on your PATH.

The public testnet CLI is available from the standalone CLI repository:

# source install
git clone https://github.com/0x26xyz/0x26-cli.git
cd 0x26-cli
cargo install --path .

# verify
and --version
and version
and --help

Prebuilt release binaries are published on the CLI repository's GitHub Releases. Source install remains the most transparent path for agents.

02 · modelThree objects. One flow.

03 · hello worldBootstrap once, then reuse the manifest.

Generate keys.

For native accounts, the owner key authorises the account. For wallet-owned accounts, the EVM wallet signs the policy mint. In both paths, the session key signs intents. Treat every secret like an SSH private key.

and keygen --out owner.key
and keygen --out session.key

Bootstrap a native account and policy.

agent bootstrap creates or resolves the account, optionally funds it on testnet, mints the policy, and writes agent.toml. Follow-on commands use that manifest so an agent does not need to retype account, policy, market, RPC, or session-key path.

# fresh ids for this testnet agent; reusing an existing id is rejected
ACCOUNT_ID=$(( 1000000 + 0x$(openssl rand -hex 5) ))
POLICY_ID=$(( ACCOUNT_ID * 1000 + 1 ))
MARKET_ID=7

and agent bootstrap \
  --owner owner.key \
  --session session.key \
  --account-id "$ACCOUNT_ID" \
  --policy-id "$POLICY_ID" \
  --market-id "$MARKET_ID" \
  --faucet \
  --skip-order \
  --manifest-out agent.toml

Or bind an existing EVM wallet-owned account.

agent bootstrap-evm is for an account that already exists on-chain and is linked to an EVM wallet. It signs the policy mint as EIP-712, submits kombat_submitEvmOwnerCall, waits for the policy when requested, and writes the same agent.toml manifest. Add --new-account to first sign an EvmAccountClaim and create the wallet-owned account with kombat_createEvmAccount.

# EVM private key comes from env, dotenv file, file, or an interactive prompt
and keygen --out session.key

EVM_ADDRESS=0x...
POLICY_ID=$(( $(date +%s) * 1000000 + 61001 ))
MARKET_ID=7

and agent bootstrap-evm \
  --session session.key \
  --wallet-address-hex "$EVM_ADDRESS" \
  --policy-id "$POLICY_ID" \
  --market-id "$MARKET_ID" \
  --private-key-env EVM_PRIVATE_KEY \
  --env-file .env \
  --skip-order \
  --manifest-out agent.toml \
  --wait

# new wallet-owned account: claim the address, then mint the policy
and agent bootstrap-evm \
  --new-account \
  --session session.key \
  --wallet-address-hex "$EVM_ADDRESS" \
  --policy-id "$POLICY_ID" \
  --market-id "$MARKET_ID" \
  --private-key-env EVM_PRIVATE_KEY \
  --env-file .env \
  --skip-order \
  --manifest-out agent.toml \
  --wait

--private-key-env, --private-key-file, and --interactive are mutually exclusive. Do not pass wallet private keys as literal CLI arguments. Plain kombat_createAccount does not bind EVM addresses; wallet links require the signed account claim.

Run.

The session key can only submit intents inside the policy. The ergonomic flags below use human units; the CLI converts to micro-USDC, lots, and ticks using live market metadata.

# inspect the live context
and --manifest agent.toml account get
and --manifest agent.toml policy get
and --manifest agent.toml market snapshot --depth 5
and --manifest agent.toml risk snapshot

# move 50 USDC into isolated collateral on the default market
and --manifest agent.toml collateral deposit --amount-usdc 50 --wait

# submit a tiny IOC market buy, then flatten the position
and --manifest agent.toml order market buy --size-btc 0.001
and --manifest agent.toml order flatten

# place a post-only limit with human price and BTC size
and --manifest agent.toml order place \
  --client-order-id 1001 \
  --side bid \
  --size-btc 0.001 \
  --price 78000 \
  --tif gtc \
  --post-only \
  --wait

# discover vaults, contribute, and inspect the resulting position
and --manifest agent.toml vault list --status open
and --manifest agent.toml vault deposit \
  --vault-id-hex 0x... \
  --amount-usdc 10000 \
  --wait-timeout-ms 10000
and --manifest agent.toml vault action-status --action-id-hex 0x...
and --manifest agent.toml vault position

Public gateway indexes can lag. A wait result may show intent_status.stage = "unknown" while order_status.stage = "filled". For fill management, trust order/account state and inspect policy get before resubmitting after a timeout. Vault deposits are asynchronous delegation actions; use vault action-status and vault position to confirm completion.

04 · unitsUse human flags unless you need raw chain units.

The chain is integer-first. The CLI is agent-friendly at the edge.

Surface	Raw	Human
Collateral	--amount-micro-usdc	--amount-usdc
Order size	--quantity-lots	--size-base / --size-btc
Limit price	--price-ticks	--price

Do not assume 1 lot = 1 BTC. Lot size is market-specific and is read from RPC. Market helpers submit IOC orders and wait for terminal order state by default.

05 · policy termsWhat you can express.

A mandate is a set of hard numeric caps. The chain rejects any intent that breaches one.

Field	Unit	Typical
gas_budget_per_day	micro-USDC	10,000,000
gas_refill_per_day	micro-USDC	10,000,000
max_intents_per_second	count	5
max_intents_per_day	count	50,000
max_volume_per_day	micro-USDC	50,000,000,000
max_drawdown_pct	bps × 10	1,500 (= 15.00%)

The CLI's policy mint flags accept these in human units (--max-volume-per-day-usdc, etc.) and convert internally.

06 · sdksIf you'd rather call the RPC directly.

The CLI wraps the Rust SDK. For bots and services, use the SDK for your language.

• Rust — and-chain-sdk. Typed builders, byte-exact signing, wire-compat proven. repo →
• TypeScript — @0x26xyz/and-chain-sdk. Thin JSON-RPC transport. repo →
• Python — and-chain-sdk. Thin transport. repo →
• .NET — AndChain.Sdk. Thin transport. repo →

All SDKs expose JSON-RPC transport and typed signing helpers for session intents, native owner calls, and EIP-712 EVM owner calls. The Rust SDK remains the byte-exact reference implementation.

07 · for agentsPoint your agent at this URL.

If you're configuring a coding agent (Claude Code, Cursor, Hermes, Aider, or anything with tool-use), give it:

• llms.txt — https://0x26.xyz/llms.txt — canonical agent docs
• whitepaper — https://0x26.xyz/whitepaper.pdf — protocol details
• CLI install — github.com/0x26xyz/0x26-cli
• SDK source — the four repos linked above

Every install step, every command, every unit conversion, and every manifest-backed flow is documented in llms.txt. No hidden state, no manual "ask a human" steps - the wallet flow is scriptable from account claim or policy mint to first fill.