Developer agent hubopenclawmcp

FarmDash Agent Hub Complete Manual: Every Skill, SDK, and MCP Tool Explained

The single source of truth for FarmDash's public agent stack: fetchable OpenClaw skills, the 84-tool MCP capability contract, the OpenAPI specification, and the Signal Architect REST API.

By TitanidesLeto · Published 2026-05-13 · Updated 2026-05-13

TLDR: The FarmDash Agent Hub combines public OpenClaw skills, an 84-tool MCP capability contract, OpenAPI, and a public REST API under one zero-custody contract: FarmDash never touches your private keys, every state-changing call is signed locally with EIP-191 or EIP-712, and provider failure returns a typed degraded state instead of fabricated zero data. Pick the right public surface for the job using the decision matrix below, then compose them with the Sense -> Decide -> Guard -> Present -> Verify pattern.

The Agent Hub is the only part of FarmDash that has direct lines to your wallet, your trading capital, and your autonomous loops. That makes it the most powerful surface we ship — and the most dangerous one to use blindly. This manual exists so you never have to guess.

If you have read the Signal Architect Complete Reference you already know the spot-execution layer. This guide zooms out: it covers all ten skills, every distribution channel, and the precise composition pattern that lets one agent research a protocol, ground itself on wallet state, guard the transaction path, execute through the owning skill, and reconcile the result - without ever leaving the zero-custody contract.

What is the FarmDash Agent Hub?

The FarmDash Agent Hub is a unified set of tools that let an autonomous AI agent research, plan, execute, and monitor DeFi farming positions without ever holding the user's private keys. It ships through three independent distribution channels so that whatever framework your agent runs on, there is a native integration:

  1. Ten fetchable OpenClaw skill contracts — each is separately versioned and served from a stable FarmDash URL. Marketplace publication or review is not implied.
  2. The FarmDash Model Context Protocol capability contract — public metadata for the 84-tool surface and its readiness states. It is not a public stdio install path.
  3. OpenAPI + REST API — for custom agents built on Eliza, LangChain, OpenAI Agents SDK, Anthropic Agent SDK, or hand-rolled stacks.
Component Format Best for Auth
OpenClaw skills (10) Stable HTTPS SKILL.md files Single-purpose agent capability contracts Optional bearer token
MCP capability contract Public metadata at /.well-known/mcp.json Capability discovery and readiness review N/A
Typed clients Generated from the public OpenAPI contract TypeScript agents, custom Eliza Actions Optional bearer token
REST API OpenAPI 3.1 spec at /agents/openapi.yaml Any language, any runtime EIP-191 for state-changing calls

The ten skills, taken together, cover the phases of an autonomous DeFi loop:

  • Sense — Trail Intelligence (research) + Wagon Steward (current portfolio state)
  • Decide — Trail Marshal (workflow planning), Supply Master (yield ranking), Hedge Warden (hedge plan), and Futures Strategist analysis tools
  • Guard — Camp Guard (approval, transaction, route, and health checks)
  • Present — every skill returns structured JSON the agent can show the user
  • Verify — Signal Architect (spot legs), Futures Strategist (perps legs), Ledger Keeper (records), and Autonomous Operator (session context)

You almost never install just one skill in a real deployment. The composition section below shows why.

Which OpenClaw skill should I install first?

Install the skill that matches the most cautious capability you need. Read-only first, execution second. Here is the canonical decision table.

If your agent needs to... Install this skill Tools Signing?
Research protocols, simulate points, run sybil audits Trail Intelligence v2.2.0 9 None (read-only)
Aggregate the user's existing positions across chains Wagon Steward v0.6.0 BETA 5 None (read-only)
Recommend and track a named multi-step workflow Trail Marshal v1.0.0 4 None; session token for run records
Execute spot swaps, route cross-chain, resolve typed intents Signal Architect v3.4.0 6 execution/planning tools plus shared MCP surface EIP-191 for spot
Run Hyperliquid perpetual futures strategies Futures Strategist v2.3.0 8 EIP-712 via Hyperliquid API wallet
Check approvals, route risk, and unsigned transactions Camp Guard v1.0.0 3 None (risk gate only)
Compare yield pools by sustainability Supply Master v1.0.0 1 None (read-only)
Plan delta hedges for spot farming exposure Hedge Warden v1.0.0 1 None (handoff only)
Reconcile recorded activity and export CSV Ledger Keeper v1.0.0 2 None (read-only)
Persist session context and event snapshots Autonomous Operator v1.0.0 8 Session capability token

A research-only agent installs Trail Intelligence + Wagon Steward and stops there — those two combined cover ~80% of "what should I farm?" questions and they cannot move funds, period.

A full execution agent installs the research, portfolio, guard, execution, ledger, and session skills. Trail Marshal does not bypass other skills; it builds a plan and records workflow state so the agent can call each owning skill under that skill's own ClawScan-reviewed contract.

What does each skill actually do?

This section is the per-skill brief. Every skill has its own SKILL.md with the full tool reference; this is the operator-level summary.

Trail Intelligence v2.2.0 - Read-only DeFi research

Trail Intelligence is the research layer. It exposes read-only tools covering public protocol data plus FarmDash's proprietary Trail Heat ranking, Pioneer Pace scoring, and sybil-resistance heuristics. Core tools include get_trail_heat, get_protocol_metadata, get_protocol_risk_factors, find_capital_route, get_agent_events, audit_sybil_risk, and get_historical_trailheat.

Use Trail Intelligence whenever the agent needs to answer what before answering how. It cannot move funds, sign, approve, or queue any transaction. Rate limits are Scout 30 req/24h, Pioneer 1,500 req/day, Syndicate 50,000 req/day.

Wagon Steward v0.6.0 BETA - Read-only portfolio aggregation

Wagon Steward is the grounding layer. Read-only tools answer the agent's "where am I right now?" questions: get_wallet_balances, get_portfolio_summary, get_position_health, get_idle_capital, and get_token_prices.

Every endpoint is a GET. Even the rebalance plan is research — it returns a JSON spec the agent must hand to Signal Architect for the user to review and sign. Wagon Steward never holds keys, never queues transactions, and never returns calldata.

Trail Marshal v1.0.0 - Guarded workflow orchestration

Trail Marshal is the decision layer's orchestration desk. It exposes list_workflows, plan_workflow, run_workflow, and get_workflow_status. The catalog now includes fourteen named recipes, and the orchestrator classifies missing skills, state-changing steps, confirmation counts, and safe fallbacks before an agent claims a workflow is executable. Examples:

  • research_only — Trail Intelligence walk-through, no execution
  • airdrop_rotation — find the highest Trail Heat protocol, scout its Sybil risk, plan a rotation
  • farm_hyperliquid — points-mode execution loop with HLP and order-book activity
  • farm_solana_restaking — Kamino → Drift → Jupiter rotation
  • delta_neutral_setup — long spot via Signal Architect, short perp via Futures Strategist
  • funding_capture — funding-rate arbitrage cookbook
  • protect_portfolio — drawdown shielding workflow
  • idle_capital_deploy — sweep idle USD into the highest-Trail-Heat passive yield
  • migrate_chain — relocate liquidity between L2s
  • bounded_autopilot — Syndicate-tier supervised autonomous loop

Trail Marshal does not execute any state-changing step. It documents and records the workflow; the agent then calls each step against the appropriate read-only, guard, or signing skill under that skill's own contract.

Signal Architect v3.4.0 - Spot execution + typed intents

Signal Architect is the spot execution layer. It exposes quote, swap, confirmation, portfolio optimization, typed intent, and risk-sentinel tools. Swap routing aggregates the active execution routes, Li.Fi and Relay (cross-chain and single-chain EVM). 0x is configured but operator-paused. x402 is the HTTP payment and access layer — it is never a swap router or quote protocol. Typed intents can produce real calldata for supported adapters such as ERC4626 deposit and withdraw, while refusing placeholders.

Critically: Signal Architect signs nothing on its own. Every state-changing call returns standard EVM calldata your agent's wallet client signs locally with EIP-191 (personal_sign). Replay protection is a 60-second nonce window. The fee model is volume-based — 50 bps under $10K, 45 bps at $10K+, 40 bps at $100K+, 30 bps at $1M+ (combined routing target; LI.FI 25 bps deducted, gas/slippage excluded).

Execution-chain boundary

The current authoritative execution path supports Ethereum, Optimism, Polygon, Base, Arbitrum, and Linea. Solana discovery data and receipt-verification helpers exist, but native Solana quote, simulation, signing, and submission are preview-only. Do not send solana-mainnet to quote, intent, simulation, or swap-execution methods.

Futures Strategist v2.3.0 - Hyperliquid perps execution

Futures Strategist is the perps execution layer. It exposes 8 tools dedicated to Hyperliquid perpetual futures: funding-rate scan, regime detection (trend / chop / squeeze), strategy analysis with pre-trade simulation, and EIP-712-signed order execution via the user's Hyperliquid API wallet. The strategy families in v2.2 cover funding arbitrage, momentum (long and short), trend-pullback, mean-reversion, breakout-continuation, vol-compression breakout, and delta-neutral pair construction. The no_trade family is a first-class output — the strategist will refuse to size a position when regime quality is below threshold.

Every order leaves the user's wallet via EIP-712 only. FarmDash never holds the Hyperliquid API key.

Camp Guard v1.0.0 - Pre-execution risk gate

Camp Guard audits allowance exposure, transaction policy, and route risk before signing. Use audit_allowance_risk, simulate_transaction_risk, and run_risk_sentinel before swaps, deposits, emergency exits, and hedge execution.

Supply Master v1.0.0 - Yield selection

Supply Master calls live DeFi yield data and ranks pools by sustainability instead of raw APY alone. Use compare_yields for stablecoin ladders, idle capital deployment, and delta-neutral spot legs.

Hedge Warden v1.0.0 - Delta hedge planning

Hedge Warden converts spot farming exposure into hedge targets with recommend_delta_hedge. It produces a handoff only; Futures Strategist must still perform fresh research, sizing, and confirmation before any order.

Ledger Keeper v1.0.0 - Post-trade records

Ledger Keeper summarizes recorded activity with ledger_realized_pnl and exports spot execution records with ledger_tax_export. It is informational only and not tax, legal, or accounting advice.

Autonomous Operator v1.0.0 - Session context

Autonomous Operator keeps persistent sessions coherent with create_session, session_heartbeat, get_farming_context, patch_farming_context, get_event_stream_snapshot, verify_delegation, configure_autopilot, and autopilot_cycle.

How do the skills compose into one workflow?

The composition pattern is Sense -> Decide -> Guard -> Present -> Verify. Every multi-skill workflow respects this order, and Trail Marshal's catalog encodes it in every recipe. Here is the canonical execution loop:

  1. Sense — Trail Intelligence.get_top_opportunities() returns ranked protocols by Trail Heat. Wagon Steward.get_portfolio_summary() grounds the agent in the user's actual position. The agent now knows the territory and the wagon's current load.
  2. Decide — The agent picks a Trail Marshal recipe matching the user's intent and calls plan_workflow to classify missing skills, state-changing steps, and confirmation count.
  3. Guard — Camp Guard checks approvals, route edge, transaction policy, and health/liquidation inputs before signing.
  4. Present — The agent surfaces a plain-language summary to the user: "I found Hyperliquid at Trail Heat 87 (campaign status unverified — check current evidence before committing funds). You have $4,200 idle USDC on Base. The recipe says bridge to Hyperliquid via Li.Fi, deposit into HLP, then size a maker-side perp position. Approve?"
  5. Verify — Only after explicit user approval does the agent call get_swap_quote, simulate_swap_execution, and then execute_swap with the user-signed payload. For the perp leg, it calls analyze_futures_strategy for pre-trade simulation, then execute_perp_order with the EIP-712 signature. Ledger Keeper and Autonomous Operator reconcile the result.

The pattern is recursive — every state-changing leg gets its own user signature, never a blanket approval. This is how an agent can run "autonomously" while still operating fully within the user's consent boundary.

Phase Skills Signing required? Output
Sense Trail Intelligence, Wagon Steward No Ranked opportunities + current portfolio
Decide Trail Marshal, Supply Master, Hedge Warden, Futures Strategist (analysis) No Named recipe + strategy candidates
Guard Camp Guard, Risk Sentinel No pass/review/halt verdict
Present All skills (formatted output) No Plain-language plan for the user
Verify Signal Architect (spot), Futures Strategist (perps), Ledger Keeper, Autonomous Operator EIP-191 / EIP-712 per execution leg Live transaction hash + records

How do I authenticate as an agent?

There are two authentication modes — read-only access and state-changing access — and they are intentionally separated.

For read-only calls (Trail Intelligence, Wagon Steward, Trail Marshal, all GET endpoints in Signal Architect and Futures Strategist) the auth is an optional bearer token in the Authorization: Bearer <FARMDASH_API_KEY> header. No key required for the Scout tier (30 requests / 24 hours). A Pioneer key unlocks 1,500 req/day; a Syndicate key unlocks 50,000 req/day plus webhook delivery.

For state-changing calls (/api/agents/swap, /api/agents/perps/order, autopilot session creation) the auth is a cryptographic signature, not an API key:

Surface Signature scheme Replay protection
Spot swap routing EIP-191 (personal_sign) over a colon-delimited payload 60-second nonce window
Hyperliquid perps EIP-712 typed-data signature via the user's Hyperliquid API wallet Hyperliquid-native nonce
Autopilot session creation EIP-191 over a session-scoped payload with explicit validUntil Session-bound timestamp

The advantage is that no API key controls funds. A leaked Pioneer bearer token gets you higher rate limits — that's it. To move funds an attacker would need the user's private key, which FarmDash never sees. Detailed payload formats live in the Signal Architect Complete Reference and the Eliza Agent Swap Integration guide.

Which AI clients does FarmDash natively support?

The Agent Hub ships first-class integrations for every major agent runtime. Pick by what your stack already uses:

Client / framework Integration Distribution
Claude Desktop MCP capability contract Review the public contract; a public stdio install path is not currently advertised
Cursor MCP capability contract Review the public contract and use the OpenAPI surface for supported integrations
Cline MCP capability contract Review the public contract and use the OpenAPI surface for supported integrations
Claude / OpenAI raw API OpenClaw skill markdown 10 SKILL.md files in public/openclaw-skills/
Eliza framework Custom Action wrapping the REST API See the Eliza guide
LangChain (TypeScript) OpenAPI-generated client + LangChain Tool wrapper Public OpenAPI contract
OpenAI Agents SDK OpenAI function definitions (30 tools) Auto-generated from the OpenAPI 3.0 spec
Anthropic Agent SDK Anthropic tool schemas (30 tools) Auto-generated from the OpenAPI 3.0 spec
Custom agent (any language) REST API + EIP-191 signing OpenAPI spec at /agents/openapi.yaml

The public MCP manifest documents 84 tools and their capability states. The OpenClaw files are independently fetchable, each with its own permission boundary. For custom TypeScript or other language clients, generate a client from the public OpenAPI contract. FarmDash does not currently advertise a public npm package or public source checkout for the stdio server.

What does a real workflow look like end-to-end?

Below are four reference workflows lifted directly from the Trail Marshal catalog, with the actual skill calls annotated. These are not pseudocode — they are the live API surface.

Airdrop rotation (research → present, no execution)

1. Trail Intelligence.get_top_opportunities({ limit: 10, minTrailHeat: 70 })
   → returns ranked confirmed/points-active protocols
2. Trail Intelligence.get_protocol_risk_factors({ slug: <top.slug> })
   → returns the decomposed Trail Heat (TVL/Status/Category/Momentum/Recency)
3. Wagon Steward.get_portfolio_summary()
   → returns the user's current top-3 positions + idle capital
4. Trail Intelligence.find_capital_route({ from: <user_chain>, to: <protocol_chain> })
   → returns capital-efficient bridge hops
5. Present plan to user. No signing. No execution. STOP.

Delta-neutral setup (full execution loop)

1. Trail Intelligence.simulate_points({ protocol: 'hyperliquid', usd: 5000 })
   → returns expected points + dollar value
2. Wagon Steward.get_idle_capital()
   → confirms the user has $5,000 idle USDC on a supported chain
3. Trail Marshal.list_workflows({ filter: 'delta_neutral_setup' })
   → returns the recipe spec
4. Futures Strategist.analyze_strategy({
     family: 'delta_neutral_pair', asset: 'HYPE-PERP', notional: 5000
   })
   → returns expected funding capture, regime score, sizing, no-trade flag if regime is bad
5. Present full plan to user. User approves.
6. Signal Architect.simulate_swap_execution({ intentId, walletAddress }) → route passes preflight
7. Signal Architect.execute_swap({ ...simulationId })  → user signs EIP-191 → spot leg fills
8. Futures Strategist.execute_order({ ... }) → user signs EIP-712 → perp leg fills
9. Wagon Steward.get_position_health() → confirms both legs settled

Funding capture (recurring loop)

1. Futures Strategist.scan_funding_rates({ minAbsRate: 0.01 })
   → returns markets paying funding above threshold
2. Trail Intelligence.get_protocol_metadata({ slug: 'hyperliquid' })
   → confirms protocol health
3. Wagon Steward.get_portfolio_summary()
   → confirms the user has margin headroom
4. Futures Strategist.analyze_strategy({
     family: 'funding_arb', asset: <market>, holdHours: 24
   })
5. Present + user signs EIP-712 → Futures Strategist executes
6. Schedule re-evaluation after holdHours via Signal Architect.create_session() (Syndicate tier)

Idle capital deploy (Wagon Steward driven)

1. Wagon Steward.get_idle_capital()
   → returns idle USD by chain
2. Trail Intelligence.get_top_opportunities({
     filterChain: <user.chain>, category: 'restaking|lending|stable_yield'
   })
3. Trail Marshal.list_workflows({ filter: 'idle_capital_deploy' })
4. Wagon Steward.get_capital_efficiency()
   → confirms the deploy improves portfolio yield-per-dollar
5. Present + user approves
6. Signal Architect.simulate_swap_execution() → route passes preflight
7. Signal Architect.execute_swap() → user signs → idle capital lands in the new position

Every workflow ends in either a STOP (research) or an explicit per-leg user signature (execution). There is no "agent has standing approval" mode in any skill.

How is the Agent Hub priced?

The same three tiers apply across all ten OpenClaw skills, the MCP server, the Agent-Kit SDK, and the REST API. One bearer token unlocks all of them at the corresponding tier.

Tier Cost Rate limit What you get
Scout Free 30 req / 24h Full read-only surface, plus public spot-quote endpoint. No signup required.
Pioneer $39.99/mo USDC 1,500 req / day Unlimited wallets in the dashboard, all 84 tools, sybil heat maps, CSV exports, Trail Alerts.
Syndicate $199/mo USDC 50,000 req / day Teams and serious agents: webhooks, unrestricted CORS, high-volume workflows, advanced session/control tooling, and priority operator support.

Settlement is in USDC on six EVM networks: Ethereum, Base, Arbitrum, Linea, Optimism, and Polygon. The on-chain verify-payment Edge Function checks the receiving treasury for the literal $39.99 or $199 USDC transfer — no Stripe, no fiat gateways, no third-party billing intermediaries.

What are the zero-custody guarantees?

This is the contract. Every skill in the Agent Hub upholds it identically.

  1. No private keys ever touch FarmDash infrastructure. Read-only skills (Trail Intelligence, Wagon Steward, Trail Marshal) literally have no signing tools — they cannot construct or send a transaction. Execution skills (Signal Architect, Futures Strategist) return calldata or typed-data payloads that your agent's wallet client signs locally.
  2. No "agent has standing approval" mode. Every state-changing leg requires an explicit fresh signature. Autopilot sessions (Syndicate tier) bound the agent's authority with a validUntil timestamp and an explicit max-USD ceiling per call.
  3. Replay protection on every signed call. Spot swaps use a 60-second nonce window. Perps use Hyperliquid's native nonce. Sessions use a session-bound timestamp.
  4. No leaked-key escalation path. A leaked bearer token unlocks rate limits, not funds. To move money, an attacker would need the user's private key — which FarmDash never sees.
  5. Public on-chain treasury. The receiving treasury wallet for subscription settlement is a single, public address (referenced in the dashboard's PaymentService). Every payment is auditable on a block explorer.
  6. Public signing contract. The EIP-191 payload format and supported REST schema are documented in the Agent Hub, so users can verify the signing path without granting FarmDash custody of wallet credentials.

How do I integrate with the Agent Hub right now?

Two public integration paths are available today:

Path A — REST / OpenAPI (recommended):

Start from the Agent Hub and generate an HTTP client from the canonical OpenAPI specification. The public MCP manifest documents the capability surface, but FarmDash does not currently advertise a public package or public source checkout for its stdio server.

Path B — OpenClaw-compatible skills:

Fetch the raw SKILL.md files directly. These URLs do not claim marketplace publication or third-party review:

https://www.farmdash.one/openclaw-skills/farmdash-trail-intelligence/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-wagon-steward/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-trail-marshal/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-signal-architect/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-futures-strategist/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-camp-guard/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-supply-master/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-hedge-warden/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-ledger-keeper/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-autonomous-operator/SKILL.md

Drop them into your agent's skills folder. Each file is independently versioned and links back to FarmDash-owned canonical documentation.

For a custom TypeScript, Python, or backend agent, use the same OpenAPI contract. Your wallet client signs any returned calldata locally; FarmDash never receives the key.

What's coming next?

The latest deepening pass shipped the previously scoped specialist skills. Remaining roadmap items are additive — no existing tools will be removed:

  1. Trail Marshal v1.x — expands guarded orchestration persistence beyond in-runtime run records.
  2. Wagon Steward v1.0 — adds historical position tracking, P&L attribution, and a simulate_rebalance tool that returns expected slippage + gas before the user ever signs.
  3. Supply Master v1.x and Hedge Warden v1.x — add richer venue-specific filters and deeper hedge invalidation telemetry.

Signal Architect remains focused on execution. Additions that are primarily risk, records, yield selection, hedging, or state coordination live in the specialized skills.

Hitch Your Oxen — Stop Guessing

Stop building agents that ask you for your seed phrase. Paste your 0x address into FarmDash Watch Mode to decrypt your wagon's risk profile in seconds, then pick your install path and let your agent read, plan, guard, execute, and verify across all ten skills under a single zero-custody contract.


Explore the Agent Hub

Related Guides