This page lays out how an Agent decides, as it actually works: what is deterministic, what is left to the model, what the model sees, how cost is metered and how well it does. It applies to paper funds and real funds alike (same execution logic); Watch mode stops at picking a pool and never places orders.
A round end to end
Opening a position goes through, in order:
- Scan: Meteora DLMM pools are scanned against your fixed conditions and the platform’s safety floor (for example excluding honeypots, freezable and high-transfer-tax tokens). Candidates can only be narrower than your conditions, never wider.
- The engine applies your limits: total budget, positions at once, positions per token, stop-loss cooldown, the daily-loss pool block… candidates and slots that don’t fit are removed first. When nothing can open (no slots, quota used up), the round doesn’t call the model.
- The Agent judges: the model reads your words and decides what to look up (pool data, price history, indicators, token risk, range backtests). It can only pick from pools this round’s scan actually returned, or open nothing. Range, shape, side and amount are its choice within your limits; the platform synthesizes the exact bins for the pool.
- Safety checks (Gate): data freshness, pool blocklist, TVL and active liquidity, recent volume, independent USD prices for both tokens, token risk, plus a sell stress test. Any failure means no open.
- Authorization (Policy): a separate authorization service checks per-position, total, count and slippage limits and issues a one-time execution authorization. A real-funds Vault also needs an on-chain co-signature.
- Signing: an isolated signing service only executes authorized actions. The Agent holds no private keys.
- Simulate, then send: every transaction is simulated before sending and isn’t sent if the simulation fails.
- Your Vault: funds only move between your Vault, DLMM pools and swaps.
If any step doesn’t pass, nothing opens this round, and the reason goes on the Agent’s timeline. “No open this round” is a normal outcome.
Two rhythms
| How often | What | |
|---|---|---|
| Protective checks | About every minute | Stop loss, price stop, max hold, a token turning unsafe, your close request. Executed on a hit, without the model |
| A full round | At your check frequency (during the public beta, at most every 10 minutes for Watch and paper funds) | Manage open positions (hold, exit early, reset the range, compound), then look for new ones |
Open positions
Each check starts with the rules the engine enforces; on a hit they run, and the AI can’t veto them:
- You asked to close all positions → exit;
- A token turns unsafe (freeze authority appears, transfer tax too high, blocklisted) → exit;
- Stop loss → exit. Your stop line if you wrote one; otherwise a backstop stop at a 30% loss. Measured in the quote token by default (SOL for SOL-quoted pools), so SOL’s own moves don’t trigger it;
- Max hold (only if you wrote one) → exit.
The value used for the stop = position valuation + known unclaimed fees. If a valuation isn’t available, the rule waits for the next one instead of exiting on missing data.
If none of those hit and a full round is due, the management model judges from your words: keep holding, exit early, reset the range or compound. It gets facts computed on your terms: PnL %, how long held, which side of the range price is on, minutes out of range (counted in closed 5-minute candles), range resets today, fees earned, and the 72-hour price structure (support, resistance, volume clusters).
Constraints the host program checks deterministically:
- If you listed exit conditions, that list is complete. An early exit must quote one of your conditions word for word, or have real token-risk evidence; indicators you didn’t write (“broke below the moving average”, “momentum fading”) and drawdowns inside your stop line don’t count.
- When the check fails, the platform doesn’t rewrite the model’s decision; it sends back which rule it didn’t match and asks the model to judge once more. If it still doesn’t match, nothing is executed this round.
- If the model is unavailable, times out or returns something invalid, the answer is always “keep holding”, and the protective rules above are unaffected.
The pre-check gate: no change, no model call
Most paper-fund management rounds end in “keep holding”. So before calling the model, a due management round is compared with this position’s last hold decision made by the model:
| Condition | Threshold |
|---|---|
| Still in range, distance from the edge | ≥ 15% of the range width |
| PnL change | < 2 percentage points |
| Distance from the stop / take-profit line | ≥ 3 percentage points |
| Price change | < 3% |
| TVL change | < 25% |
| 1-hour fees | not up or down 5× |
| New fees earned | < 0.5% of cost |
| Time left to max hold | > 60 minutes |
| Range | not changed by the engine |
| Baseline age | ≤ 120 minutes |
Only when all of them hold is the round skipped: a “keep holding” is recorded, with the baseline time and the changes in its reason, and the model isn’t called. If any value is unknown, the model is called as usual. The baseline is only ever a model decision, never one left by the gate, a rule or a fallback, so a run of small changes can’t slip through one by one. Before the model has judged a position, the moment of opening is the baseline (as long as the position is still the plan it opened with).
Hard rules (stop loss, max hold…) run before the gate and aren’t affected by it.
Paper funds only for now. Real-funds management calls the model every round; whether to switch it on there will be decided once there are enough paper-fund samples.
What the model sees
Paper-fund management rounds send the model a compact context: the last 3 hours of 5-minute candles, 12 hours of 15-minute and 24 hours of 1-hour candles (columnar), hourly volume and fees, only the necessary columns per bin, and the last 5 management records. Indicators (EMA, StochRSI, volume clusters) and PnL facts are still computed from the full data. A round’s input is about 11k tokens, down from about 65k.
Host checks and the decision record use the full context; the record also stores a hash of the context the model actually saw, so it can be recomputed.
Decision scoring
Every open decision is evaluated afterwards against “the same money left idle in the quote token”:
- Opens: at 24 hours, 72 hours and at close, compare net result, whether a hard stop fired, and time in range. Real-funds closes only use realized PnL (available after swap-back and reconciliation), never the last mark-to-market value;
- No open this round: 20% sampled, estimating “what was missed” from historical candles;
- Hold / exit: sampled, compared with the price direction 24 hours later.
The line under Exit review on the Agent page is this score, for example “Last 30 days (paper funds): N opens evaluated, X% better than doing nothing”, one line each for paper and real funds, hidden below 5 samples. Holds recorded by the pre-check gate aren’t model decisions and aren’t counted.
Scores are never fed back to the Agent: they don’t go into any prompt and don’t influence the next round.
Models and cost
Every Agent call (pool picking, position management, paper funds and real funds) currently uses the same model, DeepSeek V4.1 Flash, through the platform’s model gateway. The platform may change the model; each call records which one it used.
- Every model call is metered: input / output / cached tokens, time, model, the Agent and round it belongs to, and cost. When the gateway reports the actual cost we use it; otherwise it’s estimated from a price table, and an unconfirmed price is recorded as unknown, never as zero.
- Model usage and gateway cost are metered and reported daily in the operations report; the pre-check gate skips model calls when nothing material has changed, which is where it saves cost.
- Metering can’t slow down or change a decision: a failed write doesn’t affect the round.
- If the selected model is unavailable, the call fails and is treated as “AI unavailable” (no open / keep holding); it never quietly switches to another model.
During the public beta, strategy checks, chat, dry runs and pool-pick previews count toward your daily AI calls; the AI decisions of Watch and paper-fund Agents don’t, they only count toward the platform’s AI capacity; real-funds decisions count toward neither. See Troubleshooting.
Simulated before sending
Every transaction that moves funds is simulated before sending, and isn’t sent if the simulation fails:
- with real funds, the Agent’s transactions are simulated before and after signing; if the snapshot is over 30 seconds old at open, it’s refetched, the safety checks rerun and the same geometry re-synthesized at the current price, and if price moved more than 5% during the decision nothing opens this round;
- Vault deposits and withdrawals, and opening, claiming, exiting and resetting the range on positions in your wallet, are all built by the server and simulated before your wallet signs.
When a sent transaction has no clear result, the system never blindly resends or re-signs; see Security · When a transaction’s outcome is uncertain.
What the AI cannot do
- It can’t send transactions, and never gets a private key or authorization key; it has read-only database access.
- It can’t widen your limits: no pool outside this round’s query results, no spending above the total budget, per-position or position-count limits, no slippage above the authorization, no writing price bins directly.
- It can’t block protective exits: stop loss, max hold, a token turning unsafe and your close request run in the engine; the AI can only exit earlier.
- Without a usable decision it doesn’t open, and it never falls back to a default such as “take the top one”.
These rules limit what the AI can do; they don’t guarantee it does it well. It can pick the wrong pool, time an entry badly or misread your words. See Risks.