scheduled-autonomy

Scheduled Autonomy — strategies that run while the user sleeps

The full loop for hands-off strategy execution. Three layers make it safe:

1. The plan is explicit and saved to disk (what to do, when).
2. The execution journal makes runs idempotent (crashes and re-runs never double-buy).
3. The agent-wallet policy gate caps what any single run, or day, can spend — maxTxValueWei per tx, maxDailySpendWei + maxDailyTxCount per rolling 24h. The schedule cannot exceed the policy even if it fires a thousand times.

The loop (memorize this shape)

ONE-TIME SETUP
  1. chaingpt_strategy_dca_plan ...                 # produces steps + a JSON payload
  2. chaingpt_risk_token / chaingpt_research_token  # pre-flight the asset ONCE
  3. chaingpt_strategy_save_plan name=eth-dca type=dca payload=<the JSON>
  4. Agent wallet ready: chaingpt_agent_wallet_status
     → recommend the "DCA bot" policy template (single chain, single router, small caps)
  5. Create the schedule (see below)

EVERY SCHEDULED TICK (this is the prompt the schedule runs)
  1. chaingpt_strategy_due_steps name=eth-dca       # what's due? nothing → done, exit
  2. For each due step:
       a. chaingpt_dex_quote ...                    # fresh quote, sanity-check price impact
       b. execute:
          - agent-wallet mode: chaingpt_agent_wallet_sign_and_send (policy gate decides)
          - user-signs mode:   chaingpt_dex_build_swap_tx acknowledgeMainnet=true → present tx
       c. chaingpt_strategy_mark_step name=eth-dca stepId=<id> txHash=<hash>   # IMMEDIATELY
  3. Report: step(s) executed, spend vs daily cap, next step time

Creating the schedule (Claude Code)

Use Claude Code's scheduled agents (/schedule) or any cron that invokes claude:

/schedule create "eth-dca tick" --cron "0 9 * * *" --prompt
  "Run one tick of the saved plan 'eth-dca': call chaingpt_strategy_due_steps name=eth-dca;
   if nothing is due, stop. For each due step: fresh chaingpt_dex_quote (abort the step and
   mark it skipped with a note if price impact > 1%), execute via the agent wallet
   (chaingpt_agent_wallet_sign_and_send, memo 'eth-dca step <id>'), then immediately
   chaingpt_strategy_mark_step with the tx hash. Finish with a one-line summary."

Cadence note: schedule ticks MORE often than the plan cadence if you want catch-up behavior (a daily plan + daily tick that fails once skips a day; a daily plan + 6-hourly tick self-heals). due_steps returns everything overdue, so catch-up is automatic — the daily-spend cap bounds how much catch-up can execute at once.

Hard rules

• Mark immediately after execution. An executed-but-unmarked step is returned again next tick. The journal is the only memory the schedule has.
• Never mark before the tx is sent. A marked-but-unexecuted step is silently lost money on the table.
• Already-marked refusal means double-fire. If mark_step says the step is already recorded, do NOT overwrite — investigate why the tick ran twice.
• The policy gate's refusal is final. If sign_and_send is refused (daily cap reached, kill switch on), mark NOTHING, report the refusal, and stop. Never coach the user into widening caps mid-run; that decision belongs to a non-scheduled session.
• Pre-flight the asset once at setup, and re-check risk weekly (chaingpt_risk_token) for long-running plans — tokens get compromised after launch too.
• Plans + journal are local files (~/.chaingpt-mcp/plans/). Nothing is uploaded.

Failure handling

Situation	Behavior
RPC/quote upstream down	Skip the tick (steps stay due; next tick catches up)
Price impact above the user's threshold	mark_step status=skipped note="impact 2.3%" — a skipped step is a decision, not a failure
Policy refusal (caps/kill switch)	Stop the tick, report, leave steps due
Plan complete	due_steps says COMPLETE — tell the user to remove the schedule

Modes

• Agent-wallet mode (fully autonomous): the wallet signs inside policy caps. Pair with the dca-base policy template. The PreToolUse mainnet guard will ask for confirmation in interactive sessions; for headless scheduled runs, the policy gate + velocity caps are the (deliberate) safety boundary — set CHAINGPT_GUARD=off ONLY in the scheduled environment, never globally.
• User-signs mode (semi-autonomous): the tick prepares unsigned transactions and the summary asks the user to sign. Zero custody risk; the user is the scheduler's hands.

Solana plans (v1.19+): same loop with chaingpt_dex_jupiter_quote → chaingpt_dex_jupiter_build_swap_tx → chaingpt_agent_wallet_solana_sign_and_send → chaingpt_strategy_mark_step. The lamport velocity caps (policy.solana.maxDailySpendLamports / maxDailyTxCount) are the third safety layer, exactly like the wei caps on EVM.

Related: skills/strategy/SKILL.md (planners), skills/agent-wallet/SKILL.md (policy gate), reference/scheduled-autonomy.md (10-minute end-to-end walkthrough).