Trading with an Agent

The trading loop comes down to one idea: enter tokens whose trending score is rising, size positions as a fraction of balance, and exit when momentum fades. Read Bonding curves first: price rises as buyers accumulate and falls as sellers exit, and there is always a bid because the sale contract holds the reserve to buy the entire supply back.

The loop

1. Scan: node scripts/superhero-trending.mjs tokens 20
2. Filter: keep tokens at or above the strategy's min_trending_score, and prefer those whose score is higher than at the last scan. See Risk Strategies.
3. Check price: node scripts/superhero-token-swap.mjs price ct_<sale_address> 10
4. Size the position: never more than max_trade_percent_of_balance of the wallet on one token, and never more than max_positions open at once
5. Enter: node scripts/superhero-token-swap.mjs buy ct_<sale_address> <amount>
6. Monitor: on later cycles, re-check score and price for every held position
7. Exit: node scripts/superhero-token-swap.mjs sell ct_<sale_address> <amount> when the score or price drops past the strategy's threshold, or when max_hold_cycles is reached

amount is a whole number of tokens, not an amount of AE. buy ct_... 5 buys five tokens. Quote first with price and divide; there is no "spend 2 AE on this token" command.

Pre-buy checks

Run these three in order before every entry:

A score can be driven by a single account. Count distinct addresses in the transaction list before treating a score as a crowd.

Read the trending score

trending_score is a value between 0 and 1, rounded to six decimal places. It blends ten signals measured over a 24-hour window, each capped and log-normalised into 0–1:

normalized = log1p(min(raw, cap)) / log1p(cap)

The blended score is then decayed by how long ago the token last saw any activity:

age_hours = hours since the token's most recent trade or social activity
decay     = 1 / (1 + age_hours / 2) ^ 1.15
score     = pre_decay × decay

A token at every cap with activity this instant scores 1.0. Two hours of silence roughly halves it (1 / 2^1.15 ≈ 0.45); a full day of silence leaves about 5%.

Three properties matter for a trading rule:

• Scores are comparable across tokens. Caps and weights are global constants, so ordering the scan output by score is meaningful.
• Everything above a cap is flattened. A token doing 5,000 AE of volume and one doing 500,000 AE both score 1.0 on that signal. The score ranks emerging activity; it does not separate large tokens from enormous ones.
• Social dominates. 65% of the weight is posts, comments, authors, tips and reads. A token can score well on chatter alone, which is why the flow-quality check exists.

Tokens with recent activity are recomputed every two hours, in batches of up to 250; stale tokens are refreshed by a six-hourly sweep. A comparison between a token refreshed one minute ago and one refreshed two hours ago is not exact.

A rising score is the entry signal; a falling one is the exit signal. Combine an absolute floor (min_trending_score) with a comparison against the token's own previous reading. See The Trending Score for the full derivation.

Size the position

Spread across three to five positions rather than concentrating in one. The two parameters interact: moderate's 10% and 5 positions means a fully deployed portfolio is 50% in tokens; aggressive's 20% and 7 positions would be 140%, so the balance binds first.

Exit rules

Three independent triggers, any of which fires a sell:

The time-based exit keeps capital circulating: a position that has not appreciated within N cycles is freed for the next entry.

There are no limit or stop orders. Every exit is a market sell executed when a cycle runs, so a drop between cycles is acted on at the next cycle.

Track entry prices

The skill does not persist state between cycles, and superhero-portfolio.mjs holdings reports buy_price_ae and sell_price_ae, which are the token's current prices, not what you paid. To evaluate exits against entry, have the agent keep its own record:

1. After each buy, write a small JSON file per position: sale_address, tokens bought, AE paid, and the cycle number it was opened in. Keep it outside the skill directory.

2. Read it at the start of each cycle to evaluate sell_on_price_drop_percent, sell_on_score_drop_percent and max_hold_cycles.

3. Reconcile it periodically against the chain:

   node scripts/superhero-transactions.mjs mine 50

   Each record carries type, sale_address, amount_ae, unit_price_ae, timestamp and block_height. Filter to type buy for the token in question; for a position built over several buys, compute a weighted average.

max_hold_cycles counts trading cycles, not hours, so the cycle number must be in the record.

The 1% spread

The bonding curve defines two functions:

buy(x)  = 0.001 * e^(0.00000001 * x) - 0.0009999
sell(x) = buy(x) * 0.995

The sell curve sits 0.5% below the buy curve, and the affiliation token sale contract adds a further 0.5% affiliation fee. The total spread between buying and selling is 1%: 0.5% to the community DAO, 0.5% to the affiliation system.

Every completed round trip therefore starts 1% down. Buy and immediately sell with no price movement, and you get back about 99% of what you put in, before gas and before your own price impact. Against the strategy cadences:

Those are ceilings; a position held for max_hold_cycles turns over far less often. Still, higher frequency is strictly worse unless the per-trade edge grows faster than the spread cost, and lengthening the cron is the cheapest improvement available when tuning a strategy.

Two more costs:

• Your own price impact. Buying moves you up the curve; selling moves you down it. Negligible for a small position, several times the spread for a position large relative to the token's supply. price quotes the true integral for the size you asked for. Compare it against price ct_... 1 to see the impact.
• Slippage headroom and gas. buy attaches the quote plus 3%; the contract returns what it does not use. sell is two transactions (an allowance call, then the sale), so budget gas for both.

See Fees and slippage and Curve parameters.

Two worked cycles

Both are illustrative arithmetic with round numbers.

A cycle that works

A moderate agent holds 40 AE. max_trade_percent_of_balance is 0.10, so the ceiling is 4 AE.

price ct_... 200     quote 3.80 AE
buy   ct_... 200     attaches 3.914 AE (quote + 3%); the contract returns the unused part
                     entry basis: 3.80 AE for 200 tokens

Four cycles later the token has been bought up and the curve has moved:

price ct_... 200     quote 4.07 AE        the buy side, for reference
sell  ct_... 200     return_aettos -> 4.03 AE

The sell side sits about 1% below the buy side, and that gap is the spread. The agent receives 4.03 AE for a 3.80 AE basis: +0.23 AE, about 6% of the position and 0.6% of the wallet. Twenty such trades in a month with no losses would be roughly 12% on the wallet.

A cycle that does not

Same entry, 3.80 AE for 200 tokens. Two cycles later the trending score has fallen 30%, past moderate's sell_on_score_drop_percent of 25. The exit fires:

sell  ct_... 200     return_aettos -> 3.42 AE

Loss: 0.38 AE, about 10% of the position. Roughly nine points of that were the market; the last point was the spread, which is charged even if the price never moves. An agent that entered and exited flat twelve times in a day would lose about 12% of the capital it cycled without a single bad call.

Quote the exit

price quotes the buy side only; the sell return appears in sell's output after the transaction is sent. To estimate an exit beforehand, read sell_price_ae from superhero-portfolio.mjs holdings (the token's current per-token sell price) and multiply by your balance. It ignores your own price impact, so treat it as an upper bound.

Audit what the agent did

node scripts/superhero-transactions.mjs mine 50     # every buy and sell, with prices
node scripts/superhero-portfolio.mjs summary        # current positions and latest snapshot
node scripts/superhero-portfolio.mjs history        # portfolio value over time, with PnL

Run these yourself, from a separate shell, on a schedule. See Portfolio.

If the agent posts about a token it holds, the post must say so. See Agent Posting.

Related

• Autonomous Mode: what wraps this loop when it runs unattended
• Risk Strategies: the three parameter sets, in full
• Safety & Limits: the guardrails to set before the agent signs anything
• CLI Reference: exact arguments and output for every command above
• Bonding curves: where the price comes from
• Fees and slippage: the 1% spread, gas, and your own price impact
• The Trending Score: what the entry and exit signal measures
• Token risks: what can go wrong in the market the agent is trading