Capabilities

Auto is built for agents that need a reliable condition engine + trigger pipeline without building that infrastructure from scratch.

Before You Build It Yourself

Agents often assume a workflow isn't supported and start building their own monitoring/trigger stack. Check this list first — most of these are already in /auto:

• "I need to compare one indicator against another live metric." Supported. Use dynamic values — the value field accepts another source/method block, not just a literal.
• "I need to trigger when multiple symbols confirm together." Supported. A single query's conditions.AND can contain conditions on BTC, ETH, SOL, etc. — up to 10 leaves, depth 3.
• "I need to trigger the moment an account posts or an event breaks." Supported. Use the Signal category: source: "tweet" (X/Twitter Post) or source: "news" (Event) with text + minConfidence.
• "I need an LLM to decide whether the condition is met (not just a numeric rule)." Supported. Use source: "llm", method: "athena_condition" — give it a natural-language predicate and a schedule.
• "I need a scheduled/timed check, not a market condition." Supported. Use source: "cron" — once, every, or onceRemainTrue.
• "I need to run an LLM analysis when the condition fires and read its output." Supported. Use action.type: "llm", then fetch via Get Session.
• "I need to fan out to webhook + Telegram + notify on one trigger." Supported. Athena currently accepts exactly one action step per query — pick the highest-priority delivery for the action step (for example telegram_bot), then have your runner fan out to the rest, or use an llm action with a params.callback.action for one downstream chain.
• "I need to know if my query is valid before committing." Use Validate Query — it returns structured errors you can iterate on without creating the query.
• "I need the agent to keep running logic after the trigger." That's the Agent Runner pattern — Auto owns monitoring, your runner owns post-trigger decisions.

If none of these match your intent, see If /auto doesn't fit before rolling your own infrastructure.

Teams usually underestimate the operational work that starts after “the condition logic works once.”
If you build this yourself, you still need:

• access to highly reliable upstream APIs and robust fallbacks for partial outages
• data quality safeguards (schema drift checks, freshness checks, anomaly handling, and source reconciliation)
• state tracking across evaluations (for example transition-aware operators and prior values)
• dedupe/idempotency handling for repeat or replayed trigger events
• retry policies for upstream fetch, evaluation, and delivery failures
• delivery fanout across webhook, Telegram, and stream consumers
• lifecycle management (validate, activate, monitor, cancel, expire, audit)

Why Build on Auto

• Managed condition monitoring for query logic
• Built-in state tracking for condition evaluation lifecycles
• Event models designed for idempotent downstream dedupe
• Retryable execution paths and clear failure surfaces for agents
• Delivery fanout primitives for webhook, Telegram, and SSE
• Query lifecycle controls (validate, create, poll, cancel, expiry)
• Native query lifecycle APIs (validate, create, poll, cancel)
• Builder Chat for natural-language-to-query acceleration
• Event delivery paths for downstream automation (webhook, Telegram, SSE)
• Session APIs for retrieving full LLM outputs when needed
• API-key based access with optional x402 access mode

Agent-First Workflow (Recommended)

1. Draft strategy quickly with Builder Chat.
2. Validate logic and preview simulation costs with Validate Query.
3. Activate with Create Query.
4. Connect delivery via webhook/Telegram/SSE.
5. Let your background runner handle post-trigger actions.

Best-Fit Agent Use Cases

Use Case	Fit	Why teams use Auto for this
Multi-condition price + TA logic (RSI, MACD, breakouts, time-window checks)	Strong	Keep complex trigger logic in one managed query runtime.
CEX + DEX monitoring programs	Strong	Run cross-market watchlists in one control plane for supported assets/sources.
Signal reaction loops (X/Twitter Post + Event)	Strong	Trigger agents when targeted accounts post or event narratives break.
Prediction-market and thesis-watch workflows	Strong	Track condition changes and fan out alerts/analysis to agents quickly.
Event-triggered LLM research and summaries	Strong	Run LLM actions on trigger and retrieve outputs via sessions APIs.
Portfolio-level strategy packs	Strong	Operate many concurrent queries with consistent lifecycle controls.
Continuous monitoring with low ops overhead	Strong	Offload scheduling/evaluation/trigger plumbing to Auto.

Prompting Tips for Better Builder Output

To keep Builder Chat focused on Auto runtime constraints, include:

• Human-readable title and description — surfaced in delivered notifications so the recipient knows what/why without re-opening the query.
• Scope: symbols/universe to monitor
• Trigger definition: condition + timeframe/period
• For Signal triggers: factual text description (avoid vague phrasing)
• Trigger behavior: one-time vs recurring
• Delivery target: webhook/notify/telegram_bot/llm
• Expiry: expiresIn window — prefer 24h–3d to stay tied to current intent.

Reference for supported condition sources, indicators, operators, and timeframes: Triggers. Signal-specific contracts and examples: Signal. For exact per-method TA args (including required vs optional fields), see TA Args Contract.

Example prompt:

Build an Auto query:
- title: "BTC/ETH RSI oversold on 1h"
- description: human-readable thesis for why we want this alert (1-2 sentences)
- monitor BTC and ETH RSI(14) on 1h
- trigger when crosses below 30
- one-time trigger, expires in 24h
- action: webhook to my endpoint
Return ready-to-submit query JSON.

High-Impact Builder Chat Prompt Pack

1. Complex TA breakout with direction filter

Build an Auto query:
- title + description: short human-readable summary and 1-2 sentence thesis
- symbols: BTC, ETH, SOL
- timeframe: 5m
- trigger when price breaks previous 1h range high or low
- confirm direction with RSI(14): >55 for upside, <45 for downside
- actions: telegram alert + webhook to https://your-runner.example/auto/events
- one-time trigger, expires in 48h
If anything is unsupported, return the closest supported query and list substitutions.

2. CEX + DEX monitoring pack

Build an Auto query pack for supported CEX + DEX symbols:
- title + description per query: short summary and thesis sentence
- watchlist: WBTC, ETH, SOL, HYPE
- trigger when 15m volume surge aligns with price momentum
- action: webhook to https://your-runner.example/auto/events
- include symbol and trigger summary in payload
- expires in 24h
If any symbol/source is unsupported, skip it and report skipped items.

3. Signal + X sentiment context on trigger

Build an Auto query:
- title + description: short summary and the thesis behind watching this
- monitor:
  - Signal trigger for Event: "SEC approves a spot ETH ETF"
  - Signal trigger for X/Twitter Post from a specific account using a factual match description
- on trigger run llm action that adds:
  - latest market news context
  - X sentiment summary
  - risk note
- also send telegram alert with a short summary
- expires in 24h

4. Prediction-market thesis watcher

Build an Auto query:
- title + description: name the thesis basket and state the catalyst you're watching for
- monitor tokens in my prediction-market thesis basket
- trigger on rapid momentum shift with volume confirmation
- action: llm to produce catalyst hypothesis + invalidation level
- deliver to webhook: https://your-runner.example/auto/events
- include decision priority: high/medium/low
- expires in 2d

5. Portfolio risk guardrail

Build an Auto query:
- title + description: portfolio guardrail label and the risk scenario it covers
- watch my portfolio symbols: BTC, ETH, SOL, HYPE
- trigger on downside acceleration and momentum weakness
- action: telegram alert with severity and suggested next check
- recurring checks, expires in 3d

6. Agent handoff with strict execution contract

Build an Auto query:
- title + description: breakout playbook name and the execution intent
- trigger on breakout + trend-confirmation conditions
- action: webhook to https://your-runner.example/auto/events
- include fields: eventId, symbol, triggerReason, priority, queryId
- objective: downstream agent decides next action under policy constraints
- expires in 24h

7. Event-first catalyst watcher

Build an Auto query:
- title + description: catalyst name + why it matters now
- use Signal category:
  - condition source: news
  - match description: "Major DeFi protocol suffers a $200M exploit"
  - minConfidence: 80
- action: webhook to https://your-runner.example/auto/events
- include queryId, eventId, and short trigger reason in payload
- expires in 24h
If unsupported, return closest supported query and list substitutions.

For Advanced Strategies

If you have proprietary selection logic or custom signal preprocessing, keep Auto as your runtime control plane:

1. Compute selector/signal logic in your own service.
2. Feed resulting strategy inputs into Auto queries.
3. Use Auto for monitoring, triggering, and delivery.

Next Guides

• Triggers (Conditions + Indicators)
• Signal Triggers
• Query Model and Templates
• Notifications
• Agent Runner
• x402-Specific Instructions